using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Numerics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using <StartupCode$FSharpPlus>;
using FSharpPlus;
using FSharpPlus.Control;
using FSharpPlus.Data;
using FSharpPlus.Internals;
using Microsoft.FSharp.Collections;
using Microsoft.FSharp.Control;
using Microsoft.FSharp.Core;
using Microsoft.FSharp.Core.CompilerServices;
using Microsoft.FSharp.Quotations;

[assembly: FSharpInterfaceDataVersion(2, 0, 0)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("gusty; wallymathieu")]
[assembly: AssemblyCopyright("2012-2023 Gustavo M. Wild - Oskar Gewalli (and contributors https://github.com/fsprojects/FSharpPlus/graphs/contributors)")]
[assembly: AssemblyInformationalVersion("1.5.0")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/fsprojects/FSharpPlus")]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyVersion("0.0.0.0")]
namespace FSharpPlus.Internals
{
	[Serializable]
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	public class Default6
	{
	}
	[Serializable]
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	public class Default5 : Default6
	{
	}
	[Serializable]
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	public class Default4 : Default5
	{
	}
	[Serializable]
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	public class Default3 : Default4
	{
	}
	[Serializable]
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	public class Default2 : Default3
	{
	}
	[Serializable]
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	public class Default1 : Default2
	{
	}
	[Serializable]
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	public class Id<t>
	{
		internal t value;

		public t getValue => value;

		public Id(t v)
		{
			value = v;
		}
	}
	[Serializable]
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	public class Id0
	{
		internal string value;

		public string getValue => value;

		public Id0(string v)
		{
			value = v;
		}
	}
	[Serializable]
	[StructLayout(LayoutKind.Auto, CharSet = CharSet.Auto)]
	[DebuggerDisplay("{__DebugDisplay(),nq}")]
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	public abstract class Either<t, u> : IEquatable<Either<t, u>>, IStructuralEquatable, IComparable<Either<t, u>>, IComparable, IStructuralComparable
	{
		public static class Tags
		{
			public const int Left = 0;

			public const int Right = 1;
		}

		[Serializable]
		[SpecialName]
		[DebuggerTypeProxy(typeof(Either<, >.Left@DebugTypeProxy))]
		[DebuggerDisplay("{__DebugDisplay(),nq}")]
		public class Left : Either<t, u>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal readonly t item;

			[CompilationMapping(/*Could not decode attribute arguments.*/)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public t Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return item;
				}
			}

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal Left(t item)
			{
				this.item = item;
			}
		}

		[Serializable]
		[SpecialName]
		[DebuggerTypeProxy(typeof(Either<, >.Right@DebugTypeProxy))]
		[DebuggerDisplay("{__DebugDisplay(),nq}")]
		public class Right : Either<t, u>
		{
			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal readonly u item;

			[CompilationMapping(/*Could not decode attribute arguments.*/)]
			[CompilerGenerated]
			[DebuggerNonUserCode]
			public u Item
			{
				[CompilerGenerated]
				[DebuggerNonUserCode]
				get
				{
					return item;
				}
			}

			[CompilerGenerated]
			[DebuggerNonUserCode]
			internal Right(u item)
			{
				this.item = item;
			}
		}

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

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

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

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

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

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

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

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

		[CompilationMapping(/*Could not decode attribute arguments.*/)]
		public static Either<t, u> NewLeft(t item)
		{
			return new Left(item);
		}

		[CompilationMapping(/*Could not decode attribute arguments.*/)]
		public static Either<t, u> NewRight(u item)
		{
			return new Right(item);
		}

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

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

		[CompilerGenerated]
		public virtual sealed int CompareTo(Either<t, u> obj)
		{
			if (this != null)
			{
				if (obj != null)
				{
					int num = ((this is Right) ? 1 : 0);
					int num2 = ((obj is Right) ? 1 : 0);
					if (num == num2)
					{
						IComparer genericComparer;
						if (this is Left)
						{
							Left left = (Left)this;
							Left left2 = (Left)obj;
							genericComparer = LanguagePrimitives.GenericComparer;
							t item = left.item;
							t item2 = left2.item;
							return HashCompare.GenericComparisonWithComparerIntrinsic<t>(genericComparer, item, item2);
						}
						Right right = (Right)this;
						Right right2 = (Right)obj;
						genericComparer = LanguagePrimitives.GenericComparer;
						u item3 = right.item;
						u item4 = right2.item;
						return HashCompare.GenericComparisonWithComparerIntrinsic<u>(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((Either<t, u>)obj);
		}

		[CompilerGenerated]
		public virtual sealed int CompareTo(object obj, IComparer comp)
		{
			Either<t, u> either = (Either<t, u>)obj;
			if (this != null)
			{
				if ((Either<t, u>)obj != null)
				{
					int num = ((this is Right) ? 1 : 0);
					Either<t, u> either2 = either;
					int num2 = ((either2 is Right) ? 1 : 0);
					if (num == num2)
					{
						if (this is Left)
						{
							Left left = (Left)this;
							Left left2 = (Left)either;
							t item = left.item;
							t item2 = left2.item;
							return HashCompare.GenericComparisonWithComparerIntrinsic<t>(comp, item, item2);
						}
						Right right = (Right)this;
						Right right2 = (Right)either;
						u item3 = right.item;
						u item4 = right2.item;
						return HashCompare.GenericComparisonWithComparerIntrinsic<u>(comp, item3, item4);
					}
					return num - num2;
				}
				return 1;
			}
			if ((Either<t, u>)obj != null)
			{
				return -1;
			}
			return 0;
		}

		[CompilerGenerated]
		public virtual sealed int GetHashCode(IEqualityComparer comp)
		{
			if (this != null)
			{
				int num = 0;
				if (this is Left)
				{
					Left left = (Left)this;
					num = 0;
					t item = left.item;
					return -1640531527 + (HashCompare.GenericHashWithComparerIntrinsic<t>(comp, item) + ((num << 6) + (num >> 2)));
				}
				Right right = (Right)this;
				num = 1;
				u item2 = right.item;
				return -1640531527 + (HashCompare.GenericHashWithComparerIntrinsic<u>(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 Either<t, u> either)
				{
					int num = ((this is Right) ? 1 : 0);
					Either<t, u> either2 = either;
					int num2 = ((either2 is Right) ? 1 : 0);
					if (num == num2)
					{
						if (this is Left)
						{
							Left left = (Left)this;
							Left left2 = (Left)either;
							t item = left.item;
							t item2 = left2.item;
							return HashCompare.GenericEqualityWithComparerIntrinsic<t>(comp, item, item2);
						}
						Right right = (Right)this;
						Right right2 = (Right)either;
						u item3 = right.item;
						u item4 = right2.item;
						return HashCompare.GenericEqualityWithComparerIntrinsic<u>(comp, item3, item4);
					}
					return false;
				}
				return false;
			}
			return obj == null;
		}

		[CompilerGenerated]
		public virtual sealed bool Equals(Either<t, u> obj)
		{
			if (this != null)
			{
				if (obj != null)
				{
					int num = ((this is Right) ? 1 : 0);
					int num2 = ((obj is Right) ? 1 : 0);
					if (num == num2)
					{
						if (this is Left)
						{
							Left left = (Left)this;
							Left left2 = (Left)obj;
							t item = left.item;
							t item2 = left2.item;
							return HashCompare.GenericEqualityERIntrinsic<t>(item, item2);
						}
						Right right = (Right)this;
						Right right2 = (Right)obj;
						u item3 = right.item;
						u item4 = right2.item;
						return HashCompare.GenericEqualityERIntrinsic<u>(item3, item4);
					}
					return false;
				}
				return false;
			}
			return obj == null;
		}

		[CompilerGenerated]
		public sealed override bool Equals(object obj)
		{
			if (obj is Either<t, u> obj2)
			{
				return Equals(obj2);
			}
			return false;
		}
	}
	[Serializable]
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	public struct DmStruct : IEquatable<DmStruct>, IStructuralEquatable, IComparable<DmStruct>, IComparable, IStructuralComparable
	{
		[CompilerGenerated]
		public sealed int CompareTo(DmStruct obj)
		{
			return 0;
		}

		[CompilerGenerated]
		public sealed int CompareTo(object obj)
		{
			DmStruct dmStruct = (DmStruct)obj;
			return 0;
		}

		[CompilerGenerated]
		public sealed int CompareTo(object obj, IComparer comp)
		{
			DmStruct dmStruct = (DmStruct)obj;
			return 0;
		}

		[CompilerGenerated]
		public sealed int GetHashCode(IEqualityComparer comp)
		{
			return 0;
		}

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

		[CompilerGenerated]
		public sealed bool Equals(object obj, IEqualityComparer comp)
		{
			if (obj is DmStruct)
			{
				return true;
			}
			return false;
		}

		[CompilerGenerated]
		public sealed bool Equals(DmStruct obj)
		{
			return true;
		}

		[CompilerGenerated]
		public sealed override bool Equals(object obj)
		{
			if (obj is DmStruct)
			{
				return true;
			}
			return false;
		}
	}
	[Serializable]
	[Sealed]
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	public sealed class Set2<T>
	{
	}
	[Serializable]
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	public class BitConverter
	{
		public static byte[] GetBytes(bool value)
		{
			return new byte[1] { (byte)(value ? 1 : 0) };
		}

		public static byte[] GetBytes(char value, bool isLittleEndian)
		{
			return GetBytes((short)value, isLittleEndian);
		}

		public unsafe static byte[] GetBytes(short value, bool isLittleEndian)
		{
			//The blocks IL_004a are reachable both inside and outside the pinned region starting at IL_003c. ILSpy has duplicated these blocks in order to place them both within and outside the `fixed` statement.
			if (!isLittleEndian)
			{
				return new byte[2]
				{
					(byte)(short)(value >> 8),
					(byte)value
				};
			}
			byte[] array = ArrayModule.ZeroCreate<byte>(2);
			nint num;
			IntPtr intPtr;
			if (array != null)
			{
				if (ArrayModule.Length<byte>(array) != 0)
				{
					fixed (byte* ptr = &array[0])
					{
						num = (intPtr = (nint)ptr);
						*(short*)intPtr = value;
						return array;
					}
				}
				num = 0;
			}
			else
			{
				num = 0;
			}
			intPtr = num;
			*(short*)intPtr = value;
			return array;
		}

		public unsafe static byte[] GetBytes(int value, bool isLittleEndian)
		{
			//The blocks IL_0061 are reachable both inside and outside the pinned region starting at IL_0053. ILSpy has duplicated these blocks in order to place them both within and outside the `fixed` statement.
			if (!isLittleEndian)
			{
				return new byte[4]
				{
					(byte)(value >> 24),
					(byte)(value >> 16),
					(byte)(value >> 8),
					(byte)value
				};
			}
			byte[] array = ArrayModule.ZeroCreate<byte>(4);
			nint num;
			IntPtr intPtr;
			if (array != null)
			{
				if (ArrayModule.Length<byte>(array) != 0)
				{
					fixed (byte* ptr = &array[0])
					{
						num = (intPtr = (nint)ptr);
						*(int*)intPtr = value;
						return array;
					}
				}
				num = 0;
			}
			else
			{
				num = 0;
			}
			intPtr = num;
			*(int*)intPtr = value;
			return array;
		}

		public unsafe static byte[] GetBytes(long value, bool isLittleEndian)
		{
			//The blocks IL_0091 are reachable both inside and outside the pinned region starting at IL_0083. ILSpy has duplicated these blocks in order to place them both within and outside the `fixed` statement.
			if (!isLittleEndian)
			{
				return new byte[8]
				{
					(byte)(value >> 56),
					(byte)(value >> 48),
					(byte)(value >> 40),
					(byte)(value >> 32),
					(byte)(value >> 24),
					(byte)(value >> 16),
					(byte)(value >> 8),
					(byte)value
				};
			}
			byte[] array = ArrayModule.ZeroCreate<byte>(8);
			nint num;
			IntPtr intPtr;
			if (array != null)
			{
				if (ArrayModule.Length<byte>(array) != 0)
				{
					fixed (byte* ptr = &array[0])
					{
						num = (intPtr = (nint)ptr);
						*(long*)intPtr = value;
						return array;
					}
				}
				num = 0;
			}
			else
			{
				num = 0;
			}
			intPtr = num;
			*(long*)intPtr = value;
			return array;
		}

		public static byte[] GetBytes(ushort value, bool isLittleEndian)
		{
			return GetBytes((short)value, isLittleEndian);
		}

		public static byte[] GetBytes(uint value, bool isLittleEndian)
		{
			return GetBytes((int)value, isLittleEndian);
		}

		public static byte[] GetBytes(ulong value, bool isLittleEndian)
		{
			return GetBytes((long)value, isLittleEndian);
		}

		public unsafe static byte[] GetBytes(float value, bool isLittleEndian)
		{
			float num = value;
			return GetBytes(*(int*)(&num), isLittleEndian);
		}

		public unsafe static byte[] GetBytes(double value, bool isLittleEndian)
		{
			double num = value;
			return GetBytes(*(long*)(&num), isLittleEndian);
		}

		public static byte[] GetBytes(Guid value, bool isLittleEndian)
		{
			byte[] array = value.ToByteArray();
			if (isLittleEndian)
			{
				return array;
			}
			return $Internals.GetBytes$cont@207(array, null);
		}

		public static char ToChar(byte[] value, int startIndex, bool isLittleEndian)
		{
			return (char)ToInt16(value, startIndex, isLittleEndian);
		}

		public unsafe static short ToInt16(byte[] value, int startIndex, bool isLittleEndian)
		{
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}
			if (startIndex >= value.Length)
			{
				ArgumentOutOfRangeException ex = new ArgumentOutOfRangeException("startIndex", "ArgumentOutOfRange_Index");
				throw ex;
			}
			if (startIndex > value.Length - 2)
			{
				ArgumentException ex2 = new ArgumentException("Arg_ArrayPlusOffTooSmall");
				throw ex2;
			}
			fixed (byte* ptr = &value[startIndex])
			{
				nint num = (nint)ptr;
				short num3;
				if (isLittleEndian)
				{
					if (startIndex % 2 == 0)
					{
						return *(short*)num;
					}
					short num2 = *(byte*)(num + (nint)0 * (nint)sizeof(byte));
					num3 = *(byte*)(num + (nint)1 * (nint)sizeof(byte));
					return (short)(num2 | (short)(num3 << 8));
				}
				num3 = *(byte*)(num + (nint)0 * (nint)sizeof(byte));
				return (short)((short)(num3 << 8) | (short)(*(byte*)(num + (nint)1 * (nint)sizeof(byte))));
			}
		}

		public unsafe static int ToInt32(byte[] value, int startIndex, bool isLittleEndian)
		{
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}
			if (startIndex >= value.Length)
			{
				ArgumentOutOfRangeException ex = new ArgumentOutOfRangeException("startIndex", "ArgumentOutOfRange_Index");
				throw ex;
			}
			if (startIndex > value.Length - 4)
			{
				ArgumentException ex2 = new ArgumentException("Arg_ArrayPlusOffTooSmall");
				throw ex2;
			}
			fixed (byte* ptr = &value[startIndex])
			{
				nint num = (nint)ptr;
				if (isLittleEndian)
				{
					if (startIndex % 4 == 0)
					{
						return *(int*)num;
					}
					return *(byte*)(num + (nint)0 * (nint)sizeof(byte)) | (*(byte*)(num + (nint)1 * (nint)sizeof(byte)) << 8) | (*(byte*)(num + (nint)2 * (nint)sizeof(byte)) << 16) | (*(byte*)(num + (nint)3 * (nint)sizeof(byte)) << 24);
				}
				return (*(byte*)(num + (nint)0 * (nint)sizeof(byte)) << 24) | (*(byte*)(num + (nint)1 * (nint)sizeof(byte)) << 16) | (*(byte*)(num + (nint)2 * (nint)sizeof(byte)) << 8) | *(byte*)(num + (nint)3 * (nint)sizeof(byte));
			}
		}

		public unsafe static long ToInt64(byte[] value, int startIndex, bool isLittleEndian)
		{
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}
			if (startIndex >= value.Length)
			{
				ArgumentOutOfRangeException ex = new ArgumentOutOfRangeException("startIndex", "ArgumentOutOfRange_Index");
				throw ex;
			}
			if (startIndex > value.Length - 8)
			{
				ArgumentException ex2 = new ArgumentException("Arg_ArrayPlusOffTooSmall");
				throw ex2;
			}
			fixed (byte* ptr = &value[startIndex])
			{
				nint num = (nint)ptr;
				long num2;
				if (isLittleEndian)
				{
					if (startIndex % 8 == 0)
					{
						return *(long*)num;
					}
					num2 = (long)(*(byte*)(num + (nint)0 * (nint)sizeof(byte)) | ((ulong)(*(byte*)(num + (nint)1 * (nint)sizeof(byte))) << 8) | ((ulong)(*(byte*)(num + (nint)2 * (nint)sizeof(byte))) << 16) | ((ulong)(*(byte*)(num + (nint)3 * (nint)sizeof(byte))) << 24));
					long num3 = (long)(*(byte*)(num + (nint)4 * (nint)sizeof(byte)) | ((ulong)(*(byte*)(num + (nint)5 * (nint)sizeof(byte))) << 8) | ((ulong)(*(byte*)(num + (nint)6 * (nint)sizeof(byte))) << 16) | ((ulong)(*(byte*)(num + (nint)7 * (nint)sizeof(byte))) << 24));
					return num2 | (num3 << 32);
				}
				num2 = (long)(((ulong)(*(byte*)(num + (nint)0 * (nint)sizeof(byte))) << 24) | ((ulong)(*(byte*)(num + (nint)1 * (nint)sizeof(byte))) << 16) | ((ulong)(*(byte*)(num + (nint)2 * (nint)sizeof(byte))) << 8) | *(byte*)(num + (nint)3 * (nint)sizeof(byte)));
				return (long)(((ulong)(*(byte*)(num + (nint)4 * (nint)sizeof(byte))) << 24) | ((ulong)(*(byte*)(num + (nint)5 * (nint)sizeof(byte))) << 16) | ((ulong)(*(byte*)(num + (nint)6 * (nint)sizeof(byte))) << 8) | *(byte*)(num + (nint)7 * (nint)sizeof(byte))) | (num2 << 32);
			}
		}

		public static Guid ToGuid(byte[] value, int startIndex, bool isLittleEndian)
		{
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}
			if (startIndex >= value.Length)
			{
				ArgumentOutOfRangeException ex = new ArgumentOutOfRangeException("startIndex", "ArgumentOutOfRange_Index");
				throw ex;
			}
			if (startIndex > value.Length - 16)
			{
				ArgumentException ex2 = new ArgumentException("Arg_ArrayPlusOffTooSmall");
				throw ex2;
			}
			if (isLittleEndian)
			{
				if (startIndex == 0)
				{
					return new Guid(value);
				}
				int num = startIndex + 15;
				int num2 = value.Length;
				int num3 = ((startIndex >= 0) ? startIndex : 0);
				int num4 = ((num >= 0 + num2) ? (0 + num2 - 1) : num);
				int num5 = num4 - num3 + 1;
				int num6 = ((num5 >= 0) ? num5 : 0);
				byte[] array = new byte[num6];
				int num7 = 0;
				int num8 = num6 - 1;
				if (num8 >= num7)
				{
					do
					{
						array[num7] = value[num3 + num7];
						num7++;
					}
					while (num7 != num8 + 1);
				}
				return new Guid(array);
			}
			return $Internals.ToGuid$cont@267(value, startIndex, null);
		}

		public static ushort ToUInt16(byte[] value, int startIndex, bool isLittleEndian)
		{
			return (ushort)ToInt16(value, startIndex, isLittleEndian);
		}

		public static uint ToUInt32(byte[] value, int startIndex, bool isLittleEndian)
		{
			return (uint)ToInt32(value, startIndex, isLittleEndian);
		}

		public static ulong ToUInt64(byte[] value, int startIndex, bool isLittleEndian)
		{
			return (ulong)ToInt64(value, startIndex, isLittleEndian);
		}

		public unsafe static float ToSingle(byte[] value, int startIndex, bool isLittleEndian)
		{
			int num = ToInt32(value, startIndex, isLittleEndian);
			return *(float*)(&num);
		}

		public unsafe static double ToDouble(byte[] value, int startIndex, bool isLittleEndian)
		{
			long num = ToInt64(value, startIndex, isLittleEndian);
			return *(double*)(&num);
		}

		internal static char GetHexValue(int i)
		{
			char c;
			if (i < 10)
			{
				c = (char)i;
				return (char)(c + 48);
			}
			c = (char)(i - 10);
			return (char)(c + 65);
		}

		public static string ToString(byte[] value, int startIndex, int length)
		{
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}
			int num = value.Length;
			if (startIndex >= value.Length)
			{
				ArgumentOutOfRangeException ex = new ArgumentOutOfRangeException("startIndex", "ArgumentOutOfRange_StartIndex");
				throw ex;
			}
			if (length < 0)
			{
				ArgumentOutOfRangeException ex = new ArgumentOutOfRangeException("length", "ArgumentOutOfRange_GenericPositive");
				throw ex;
			}
			if (startIndex > num - length)
			{
				ArgumentException ex2 = new ArgumentException("Arg_ArrayPlusOffTooSmall");
				throw ex2;
			}
			if (length == 0)
			{
				return string.Empty;
			}
			char[] array = ArrayModule.ZeroCreate<char>(length * 3);
			int num2 = startIndex;
			IEnumerable<int> enumerable = OperatorIntrinsics.RangeInt32(0, 3, 3 * length - 1);
			foreach (int item in enumerable)
			{
				int num3 = value[num2];
				num2++;
				array[item] = GetHexValue(num3 / 16);
				array[item + 1] = GetHexValue(num3 % 16);
				array[item + 2] = '-';
			}
			return new string(array, 0, array.Length - 1);
		}

		public static string ToString(byte[] value)
		{
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}
			return ToString(value, 0, value.Length);
		}

		public static string ToString(byte[] value, int startIndex)
		{
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}
			return ToString(value, startIndex, value.Length - startIndex);
		}
	}
}
namespace FSharpPlus.Data
{
	[Serializable]
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	public interface NonEmptySeq<T> : IEnumerable<T>
	{
		T First { get; }
	}
}
namespace FSharpPlus.Control
{
	[Serializable]
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	public class Explicit : Default1
	{
		public static FSharpFunc<t, R> Explicit<R, t>(R _arg1, Default1 _arg2)
		{
			return $Converter.Explicit@18<R, t>.@_instance;
		}

		public static FSharpFunc<t, R> Explicit$W<R, t>(FSharpFunc<t, R> op_Explicit, R _arg1, Default1 _arg2)
		{
			return new $Converter.Explicit@18-1<R, t>(op_Explicit);
		}

		public static void Explicit<t>(t _arg3, Default1 _arg4) where t : class
		{
		}

		public static FSharpFunc<a, byte> Explicit<a>(byte _arg5, Explicit _arg6)
		{
			return $Converter.Explicit@21-2<a>.@_instance;
		}

		public static FSharpFunc<a, byte> Explicit$W<a>(FSharpFunc<a, byte> op_Explicit, byte _arg5, Explicit _arg6)
		{
			return new $Converter.Explicit@21-3<a>(op_Explicit);
		}

		public static FSharpFunc<a, sbyte> Explicit<a>(sbyte _arg7, Explicit _arg8)
		{
			return $Converter.Explicit@22-4<a>.@_instance;
		}

		public static FSharpFunc<a, sbyte> Explicit$W<a>(FSharpFunc<a, sbyte> op_Explicit, sbyte _arg7, Explicit _arg8)
		{
			return new $Converter.Explicit@22-5<a>(op_Explicit);
		}

		public static FSharpFunc<a, short> Explicit<a>(short _arg9, Explicit _arg10)
		{
			return $Converter.Explicit@23-6<a>.@_instance;
		}

		public static FSharpFunc<a, short> Explicit$W<a>(FSharpFunc<a, short> op_Explicit, short _arg9, Explicit _arg10)
		{
			return new $Converter.Explicit@23-7<a>(op_Explicit);
		}

		public static FSharpFunc<a, ushort> Explicit<a>(ushort _arg11, Explicit _arg12)
		{
			return $Converter.Explicit@24-8<a>.@_instance;
		}

		public static FSharpFunc<a, ushort> Explicit$W<a>(FSharpFunc<a, ushort> op_Explicit, ushort _arg11, Explicit _arg12)
		{
			return new $Converter.Explicit@24-9<a>(op_Explicit);
		}

		public static FSharpFunc<a, int> Explicit<a>(int _arg13, Explicit _arg14)
		{
			return $Converter.Explicit@25-10<a>.@_instance;
		}

		public static FSharpFunc<a, int> Explicit$W<a>(FSharpFunc<a, int> op_Explicit, int _arg13, Explicit _arg14)
		{
			return new $Converter.Explicit@25-11<a>(op_Explicit);
		}

		public static FSharpFunc<a, uint> Explicit<a>(uint _arg15, Explicit _arg16)
		{
			return $Converter.Explicit@26-12<a>.@_instance;
		}

		public static FSharpFunc<a, uint> Explicit$W<a>(FSharpFunc<a, uint> op_Explicit, uint _arg15, Explicit _arg16)
		{
			return new $Converter.Explicit@26-13<a>(op_Explicit);
		}

		public static FSharpFunc<a, long> Explicit<a>(long _arg17, Explicit _arg18)
		{
			return $Converter.Explicit@27-14<a>.@_instance;
		}

		public static FSharpFunc<a, long> Explicit$W<a>(FSharpFunc<a, long> op_Explicit, long _arg17, Explicit _arg18)
		{
			return new $Converter.Explicit@27-15<a>(op_Explicit);
		}

		public static FSharpFunc<a, ulong> Explicit<a>(ulong _arg19, Explicit _arg20)
		{
			return $Converter.Explicit@28-16<a>.@_instance;
		}

		public static FSharpFunc<a, ulong> Explicit$W<a>(FSharpFunc<a, ulong> op_Explicit, ulong _arg19, Explicit _arg20)
		{
			return new $Converter.Explicit@28-17<a>(op_Explicit);
		}

		public static FSharpFunc<a, IntPtr> Explicit<a>(IntPtr _arg21, Explicit _arg22)
		{
			return $Converter.Explicit@30-18<a>.@_instance;
		}

		public static FSharpFunc<a, IntPtr> Explicit$W<a>(FSharpFunc<a, int> op_Explicit, IntPtr _arg21, Explicit _arg22)
		{
			return new $Converter.Explicit@30-19<a>(op_Explicit);
		}

		public static FSharpFunc<a, UIntPtr> Explicit<a>(UIntPtr _arg23, Explicit _arg24)
		{
			return $Converter.Explicit@31-20<a>.@_instance;
		}

		public static FSharpFunc<a, UIntPtr> Explicit$W<a>(FSharpFunc<a, uint> op_Explicit, UIntPtr _arg23, Explicit _arg24)
		{
			return new $Converter.Explicit@31-21<a>(op_Explicit);
		}

		public static FSharpFunc<a, double> Explicit<a>(double _arg25, Explicit _arg26)
		{
			return $Converter.Explicit@33-22<a>.@_instance;
		}

		public static FSharpFunc<a, double> Explicit$W<a>(FSharpFunc<a, double> op_Explicit, double _arg25, Explicit _arg26)
		{
			return new $Converter.Explicit@33-23<a>(op_Explicit);
		}

		public static FSharpFunc<a, float> Explicit<a>(float _arg27, Explicit _arg28)
		{
			return $Converter.Explicit@34-24<a>.@_instance;
		}

		public static FSharpFunc<a, float> Explicit$W<a>(FSharpFunc<a, float> op_Explicit, float _arg27, Explicit _arg28)
		{
			return new $Converter.Explicit@34-25<a>(op_Explicit);
		}

		public static FSharpFunc<a, decimal> Explicit<a>(decimal _arg29, Explicit _arg30)
		{
			return $Converter.Explicit@35-26<a>.@_instance;
		}

		public static FSharpFunc<a, decimal> Explicit$W<a>(FSharpFunc<a, decimal> op_Explicit, decimal _arg29, Explicit _arg30)
		{
			return new $Converter.Explicit@35-27<a>(op_Explicit);
		}

		public static FSharpFunc<a, char> Explicit<a>(char _arg31, Explicit _arg32)
		{
			return $Converter.Explicit@36-28<a>.@_instance;
		}

		public static FSharpFunc<a, char> Explicit$W<a>(FSharpFunc<a, char> op_Explicit, char _arg31, Explicit _arg32)
		{
			return new $Converter.Explicit@36-29<a>(op_Explicit);
		}

		public static T Invoke<a, T>(a value)
		{
			Explicit item = null;
			return FSharpFunc<Tuple<FSharpPlus.Control.Explicit, ?>, T>.InvokeFast<T>((FSharpFunc<Tuple<Explicit, ?>, FSharpFunc<T, T>>)(object)$Converter.Invoke@40<a, T>.@_instance, (Tuple<Explicit, ?>)(object)new Tuple<Explicit, T>(item, default(T)), (T)value);
		}

		public static T Invoke$W<a, T>(FSharpFunc<T, FSharpFunc<Explicit, FSharpFunc<a, T>>> @explicit, a value)
		{
			Explicit item = null;
			return FSharpFunc<Tuple<FSharpPlus.Control.Explicit, ?>, T>.InvokeFast<T>((FSharpFunc<Tuple<Explicit, ?>, FSharpFunc<T, T>>)(object)new $Converter.Invoke@40-1<a, T>(@explicit), (Tuple<Explicit, ?>)(object)new Tuple<Explicit, T>(item, default(T)), (T)value);
		}
	}
	[Serializable]
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	public class OfBytes
	{
		public static FSharpFunc<Tuple<byte[], int, a>, bool> OfBytes<a>(bool _arg1, OfBytes _arg2)
		{
			return $Converter.OfBytes@43<a>.@_instance;
		}

		public static FSharpFunc<Tuple<byte[], int, bool>, char> OfBytes(char _arg3, OfBytes _arg4)
		{
			return $Converter.OfBytes@45-1.@_instance;
		}

		public static FSharpFunc<Tuple<byte[], int, bool>, double> OfBytes(double _arg5, OfBytes _arg6)
		{
			return $Converter.OfBytes@46-2.@_instance;
		}

		public static FSharpFunc<Tuple<byte[], int, bool>, short> OfBytes(short _arg7, OfBytes _arg8)
		{
			return $Converter.OfBytes@47-3.@_instance;
		}

		public static FSharpFunc<Tuple<byte[], int, bool>, int> OfBytes(int _arg9, OfBytes _arg10)
		{
			return $Converter.OfBytes@48-4.@_instance;
		}

		public static FSharpFunc<Tuple<byte[], int, bool>, long> OfBytes(long _arg11, OfBytes _arg12)
		{
			return $Converter.OfBytes@49-5.@_instance;
		}

		public static FSharpFunc<Tuple<byte[], int, bool>, float> OfBytes(float _arg13, OfBytes _arg14)
		{
			return $Converter.OfBytes@50-6.@_instance;
		}

		public static FSharpFunc<Tuple<byte[], int, b>, string> OfBytes<b>(string _arg15, OfBytes _arg16)
		{
			return $Converter.OfBytes@52-7<b>.@_instance;
		}

		public static FSharpFunc<Tuple<byte[], int, bool>, Guid> OfBytes(Guid _arg17, OfBytes _arg18)
		{
			return $Converter.OfBytes@53-8.@_instance;
		}

		public static FSharpFunc<Tuple<byte[], int, bool>, ushort> OfBytes(ushort _arg19, OfBytes _arg20)
		{
			return $Converter.OfBytes@55-9.@_instance;
		}

		public static FSharpFunc<Tuple<byte[], int, bool>, uint> OfBytes(uint _arg21, OfBytes _arg22)
		{
			return $Converter.OfBytes@56-10.@_instance;
		}

		public static FSharpFunc<Tuple<byte[], int, bool>, ulong> OfBytes(ulong _arg23, OfBytes _arg24)
		{
			return $Converter.OfBytes@57-11.@_instance;
		}

		[CompilationArgumentCounts(new int[] { 1, 1, 1 })]
		public static a Invoke<a>(bool isLtEndian, int startIndex, byte[] value)
		{
			OfBytes item = null;
			Tuple<byte[], int, bool> tuple = new Tuple<byte[], int, bool>(value, startIndex, isLtEndian);
			return FSharpFunc<Tuple<FSharpPlus.Control.OfBytes, a>, Tuple<byte[], int, bool>>.InvokeFast<a>((FSharpFunc<Tuple<OfBytes, a>, FSharpFunc<Tuple<byte[], int, bool>, a>>)$Converter.Invoke@62-2<a>.@_instance, new Tuple<OfBytes, a>(item, default(a)), tuple);
		}

		[CompilationArgumentCounts(new int[] { 1, 1, 1 })]
		public static a Invoke$W<a>(FSharpFunc<a, FSharpFunc<OfBytes, FSharpFunc<Tuple<byte[], int, bool>, a>>> ofBytes, bool isLtEndian, int startIndex, byte[] value)
		{
			OfBytes item = null;
			Tuple<byte[], int, bool> tuple = new Tuple<byte[], int, bool>(value, startIndex, isLtEndian);
			return FSharpFunc<Tuple<FSharpPlus.Control.OfBytes, a>, Tuple<byte[], int, bool>>.InvokeFast<a>((FSharpFunc<Tuple<OfBytes, a>, FSharpFunc<Tuple<byte[], int, bool>, a>>)new $Converter.Invoke@62-3<a>(ofBytes), new Tuple<OfBytes, a>(item, default(a)), tuple);
		}
	}
	[Serializable]
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	public class ToBytes
	{
		public static byte[] ToBytes<a>(bool x, a _arg1, ToBytes _arg2)
		{
			return new byte[1] { (byte)(x ? 1 : 0) };
		}

		public static byte[] ToBytes(char x, bool e, ToBytes _arg3)
		{
			bool isLittleEndian = System.BitConverter.IsLittleEndian == e;
			return FSharpPlus.Internals.BitConverter.GetBytes((short)x, isLittleEndian);
		}

		public unsafe static byte[] ToBytes(double x, bool e, ToBytes _arg4)
		{
			bool isLittleEndian = System.BitConverter.IsLittleEndian == e;
			double num = x;
			return FSharpPlus.Internals.BitConverter.GetBytes(*(long*)(&num), isLittleEndian);
		}

		public static byte[] ToBytes(short x, bool e, ToBytes _arg5)
		{
			return FSharpPlus.Internals.BitConverter.GetBytes(x, System.BitConverter.IsLittleEndian == e);
		}

		public static byte[] ToBytes(int x, bool e, ToBytes _arg6)
		{
			return FSharpPlus.Internals.BitConverter.GetBytes(x, System.BitConverter.IsLittleEndian == e);
		}

		public static byte[] ToBytes(long x, bool e, ToBytes _arg7)
		{
			return FSharpPlus.Internals.BitConverter.GetBytes(x, System.BitConverter.IsLittleEndian == e);
		}

		public unsafe static byte[] ToBytes(float x, bool e, ToBytes _arg8)
		{
			bool isLittleEndian = System.BitConverter.IsLittleEndian == e;
			float num = x;
			return FSharpPlus.Internals.BitConverter.GetBytes(*(int*)(&num), isLittleEndian);
		}

		public static byte[] ToBytes<b>(string x, b _arg9, ToBytes _arg10)
		{
			char[] array = x.ToCharArray();
			if (array == null)
			{
				throw new ArgumentNullException("array");
			}
			byte[] array2 = new byte[array.Length];
			for (int i = 0; i < array2.Length; i++)
			{
				array2[i] = (byte)array[i];
			}
			return array2;
		}

		public static byte[] ToBytes(Guid x, bool e, ToBytes _arg11)
		{
			return FSharpPlus.Internals.BitConverter.GetBytes(x, System.BitConverter.IsLittleEndian == e);
		}

		public static byte[] ToBytes(ushort x, bool e, ToBytes _arg12)
		{
			bool isLittleEndian = System.BitConverter.IsLittleEndian == e;
			return FSharpPlus.Internals.BitConverter.GetBytes((short)x, isLittleEndian);
		}

		public static byte[] ToBytes(uint x, bool e, ToBytes _arg13)
		{
			bool isLittleEndian = System.BitConverter.IsLittleEndian == e;
			return FSharpPlus.Internals.BitConverter.GetBytes((int)x, isLittleEndian);
		}

		public static byte[] ToBytes(ulong x, bool e, ToBytes _arg14)
		{
			bool isLittleEndian = System.BitConverter.IsLittleEndian == e;
			return FSharpPlus.Internals.BitConverter.GetBytes((long)x, isLittleEndian);
		}

		[CompilationArgumentCounts(new int[] { 1, 1 })]
		public static byte[] Invoke<a>(bool isLittleEndian, a value)
		{
			throw new NotSupportedException("Dynamic invocation of ToBytes is not supported");
		}

		[CompilationArgumentCounts(new int[] { 1, 1 })]
		public static byte[] Invoke$W<a>(FSharpFunc<a, FSharpFunc<bool, FSharpFunc<ToBytes, byte[]>>> toBytes, bool isLittleEndian, a value)
		{
			return FSharpFunc<FSharpPlus.Control.ToBytes, bool>.InvokeFast<ToBytes, byte[]>((FSharpFunc<ToBytes, FSharpFunc<bool, FSharpFunc<ToBytes, byte[]>>>)(object)toBytes, (ToBytes)value, isLittleEndian, (ToBytes)null);
		}
	}
	[Serializable]
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	public class TryParse : Default1
	{
		public static FSharpFunc<string, FSharpOption<decimal>> TryParse(decimal _arg1, TryParse _arg2)
		{
			return $Converter.TryParse@90.@_instance;
		}

		public static FSharpFunc<string, FSharpOption<float>> TryParse(float _arg3, TryParse _arg4)
		{
			return $Converter.TryParse@91-1.@_instance;
		}

		public static FSharpFunc<string, FSharpOption<double>> TryParse(double _arg5, TryParse _arg6)
		{
			return $Converter.TryParse@92-2.@_instance;
		}

		public static FSharpFunc<string, FSharpOption<ushort>> TryParse(ushort _arg7, TryParse _arg8)
		{
			return $Converter.TryParse@93-3.@_instance;
		}

		public static FSharpFunc<string, FSharpOption<uint>> TryParse(uint _arg9, TryParse _arg10)
		{
			return $Converter.TryParse@94-4.@_instance;
		}

		public static FSharpFunc<string, FSharpOption<ulong>> TryParse(ulong _arg11, TryParse _arg12)
		{
			return $Converter.TryParse@95-5.@_instance;
		}

		public static FSharpFunc<string, FSharpOption<short>> TryParse(short _arg13, TryParse _arg14)
		{
			return $Converter.TryParse@96-6.@_instance;
		}

		public static FSharpFunc<string, FSharpOption<int>> TryParse(int _arg15, TryParse _arg16)
		{
			return $Converter.TryParse@97-7.@_instance;
		}

		public static FSharpFunc<string, FSharpOption<long>> TryParse(long _arg17, TryParse _arg18)
		{
			return $Converter.TryParse@98-8.@_instance;
		}

		public static FSharpFunc<string, FSharpOption<string>> TryParse(string _arg19, TryParse _arg20)
		{
			return $Converter.TryParse@111-9.@_instance;
		}

		public static FSharpFunc<string, FSharpOption<StringBuilder>> TryParse(StringBuilder _arg21, TryParse _arg22)
		{
			return $Converter.TryParse@112-10.@_instance;
		}

		public static FSharpFunc<string, FSharpOption<DateTime>> TryParse(DateTime _arg23, TryParse _arg24)
		{
			return $Converter.TryParse@115-11.@_instance;
		}

		public static FSharpFunc<string, FSharpOption<DateTimeOffset>> TryParse(DateTimeOffset _arg25, TryParse _arg26)
		{
			return $Converter.TryParse@123-12.@_instance;
		}

		public static FSharpOption<b> Invoke<b>(string value)
		{
			TryParse item = null;
			return FSharpFunc<Tuple<FSharpPlus.Control.TryParse, FSharpOption<b>>, string>.InvokeFast<FSharpOption<b>>((FSharpFunc<Tuple<TryParse, FSharpOption<b>>, FSharpFunc<string, FSharpOption<b>>>)(object)$Converter.Invoke@135-4<b>.@_instance, (Tuple<TryParse, FSharpOption<b>>)(object)new Tuple<TryParse, b>(item, default(b)), value);
		}

		public static FSharpOption<b> Invoke$W<b>(FSharpFunc<b, FSharpFunc<TryParse, FSharpFunc<string, FSharpOption<b>>>> tryParse, string value)
		{
			TryParse item = null;
			return FSharpFunc<Tuple<FSharpPlus.Control.TryParse, FSharpOption<b>>, string>.InvokeFast<FSharpOption<b>>((FSharpFunc<Tuple<TryParse, FSharpOption<b>>, FSharpFunc<string, FSharpOption<b>>>)(object)new $Converter.Invoke@135-5<b>(tryParse), (Tuple<TryParse, FSharpOption<b>>)(object)new Tuple<TryParse, b>(item, default(b)), value);
		}

		public static FSharpOption<R> InvokeOnInstance<R>(string value)
		{
			throw new NotSupportedException("Dynamic invocation of TryParse is not supported");
		}

		public static FSharpOption<R> InvokeOnInstance$W<R>(FSharpFunc<string, FSharpOption<R>> tryParse, string value)
		{
			return tryParse.Invoke(value);
		}

		public static FSharpOption<R> InvokeOnConvention<R, a>(string value)
		{
			R val = default(R);
			if (0 == 0)
			{
				throw new NotSupportedException("Dynamic invocation of TryParse is not supported");
			}
			if ((bool)(object)null)
			{
				return FSharpOption<R>.Some(val);
			}
			return null;
		}

		public unsafe static FSharpOption<R> InvokeOnConvention$W<R, a>(FSharpFunc<string, FSharpFunc<ref R, bool>> tryParse, string value)
		{
			R val = default(R);
			if (FSharpFunc<string, ref bool>.InvokeFast<bool>((FSharpFunc<string, FSharpFunc<ref bool, bool>>)(object)tryParse, value, ref *(bool*)(&val)))
			{
				return FSharpOption<R>.Some(val);
			}
			return null;
		}

		public static FSharpFunc<string, FSharpOption<R>> TryParse<R>(R _arg1, Default4 _arg2)
		{
			return $Converter.TryParse@211-13<R>.@_instance;
		}

		public static FSharpFunc<string, FSharpOption<R>> TryParse$W<R>(FSharpFunc<string, R> parse, R _arg1, Default4 _arg2)
		{
			return new $Converter.TryParse@211-14<R>(parse);
		}

		public static FSharpFunc<string, FSharpOption<R>> TryParse<R, a>(R _arg3, Default3 _arg4)
		{
			return $Converter.TryParse@216-15<R, a>.@_instance;
		}

		public static FSharpFunc<string, FSharpOption<R>> TryParse$W<R, a>(FSharpFunc<string, FSharpFunc<ref R, bool>> tryParse, R _arg3, Default3 _arg4)
		{
			return new $Converter.TryParse@216-16<R, a>(tryParse);
		}

		public static FSharpFunc<string, FSharpOption<R>> TryParse<R>(R _arg5, Default2 _arg6)
		{
			return $Converter.TryParse@218-17<R>.@_instance;
		}

		public static FSharpFunc<string, FSharpOption<R>> TryParse$W<R>(FSharpFunc<string, FSharpOption<R>> tryParse, R _arg5, Default2 _arg6)
		{
			return new $Converter.TryParse@218-18<R>(tryParse);
		}

		public static FSharpFunc<a, a> TryParse<t, a>(t _arg7, Default2 _arg8) where t : class
		{
			return $Converter.TryParse@224-19<a>.@_instance;
		}
	}
	[Serializable]
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	public class Parse : Default1
	{
		public static FSharpFunc<string, R> Parse<R>(R _arg1, Parse _arg2)
		{
			return $Converter.Parse@155<R>.@_instance;
		}

		public static FSharpFunc<string, R> Parse$W<R>(FSharpFunc<string, FSharpFunc<CultureInfo, R>> parse, R _arg1, Parse _arg2)
		{
			return new $Converter.Parse@155-1<R>(parse);
		}

		public static FSharpFunc<string, @enum> Parse<T, a, @enum>(T _arg3, Parse _arg4) where @enum : struct
		{
			return $Converter.Parse@157-2<@enum>.@_instance;
		}

		public static FSharpFunc<string, DateTime> Parse(DateTime _arg5, Parse _arg6)
		{
			return $Converter.Parse@164-3.@_instance;
		}

		public static FSharpFunc<string, DateTimeOffset> Parse(DateTimeOffset _arg7, Parse _arg8)
		{
			return $Converter.Parse@169-4.@_instance;
		}

		public static FSharpFunc<string, bool> Parse(bool _arg9, Parse _arg10)
		{
			return $Converter.Parse@174-5.@_instance;
		}

		public static FSharpFunc<string, char> Parse(char _arg11, Parse _arg12)
		{
			return $Converter.Parse@176-6.@_instance;
		}

		public static FSharpFunc<string, string> Parse(string _arg13, Parse _arg14)
		{
			return $Converter.Parse@177-7.@_instance;
		}

		public static FSharpFunc<string, StringBuilder> Parse(StringBuilder _arg15, Parse _arg16)
		{
			return $Converter.Parse@178-8.@_instance;
		}

		public static a Invoke<a>(string value)
		{
			Parse item = null;
			return FSharpFunc<Tuple<FSharpPlus.Control.Parse, a>, string>.InvokeFast<a>((FSharpFunc<Tuple<Parse, a>, FSharpFunc<string, a>>)$Converter.Invoke@183-6<a>.@_instance, new Tuple<Parse, a>(item, default(a)), value);
		}

		public static a Invoke$W<a>(FSharpFunc<a, FSharpFunc<Parse, FSharpFunc<string, a>>> parse, string value)
		{
			Parse item = null;
			return FSharpFunc<Tuple<FSharpPlus.Control.Parse, a>, string>.InvokeFast<a>((FSharpFunc<Tuple<Parse, a>, FSharpFunc<string, a>>)new $Converter.Invoke@183-7<a>(parse), new Tuple<Parse, a>(item, default(a)), value);
		}

		public static R InvokeOnInstance<R>(string value)
		{
			throw new NotSupportedException("Dynamic invocation of Parse is not supported");
		}

		public static R InvokeOnInstance$W<R>(FSharpFunc<string, R> parse, string value)
		{
			return parse.Invoke(value);
		}

		public static FSharpFunc<string, R> Parse<R, a>(R _arg1, Default4 _arg2)
		{
			return $Converter.Parse@190-9<R, a>.@_instance;
		}

		public static FSharpFunc<string, R> Parse$W<R, a>(FSharpFunc<string, FSharpFunc<ref R, bool>> tryParse, R _arg1, Default4 _arg2)
		{
			return new $Converter.Parse@190-10<R, a>(tryParse);
		}

		public static FSharpFunc<string, R> Parse<R>(R _arg3, Default3 _arg4)
		{
			return $Converter.Parse@195-11<R>.@_instance;
		}

		public static FSharpFunc<string, R> Parse$W<R>(FSharpFunc<string, FSharpOption<R>> tryParse, R _arg3, Default3 _arg4)
		{
			return new $Converter.Parse@195-12<R>(tryParse);
		}

		public static FSharpFunc<string, R> Parse<R>(R _arg5, Default2 _arg6)
		{
			return $Converter.Parse@200-13<R>.@_instance;
		}

		public static FSharpFunc<string, R> Parse$W<R>(FSharpFunc<string, R> parse, R _arg5, Default2 _arg6)
		{
			return new $Converter.Parse@200-14<R>(parse);
		}

		public static FSharpFunc<a, a> Parse<t, a>(t _arg7, Default2 _arg8) where t : class
		{
			return $Converter.Parse@206-15<a>.@_instance;
		}
	}
	[Serializable]
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	public class FromBigInt : Default1
	{
		public static FSharpFunc<System.Numerics.BigInteger, R> FromBigInt<R>(R _arg1, Default4 _arg2)
		{
			return $Numeric.FromBigInt@19<R>.@_instance;
		}

		public static FSharpFunc<System.Numerics.BigInteger, R> FromBigInt$W<R>(FSharpFunc<R, FSharpFunc<Explicit, FSharpFunc<System.Numerics.BigInteger, R>>> @explicit, R _arg1, Default4 _arg2)
		{
			return new $Numeric.FromBigInt@19-2<R>(@explicit);
		}

		public static FSharpFunc<System.Numerics.BigInteger, R> FromBigInt<R>(R _arg3, Default3 _arg4)
		{
			return $Numeric.FromBigInt@20-4<R>.@_instance;
		}

		public static FSharpFunc<System.Numerics.BigInteger, R> FromBigInt$W<R>(FSharpFunc<long, R> op_Implicit, R _arg3, Default3 _arg4)
		{
			return new $Numeric.FromBigInt@20-5<R>(op_Implicit);
		}

		public static FSharpFunc<System.Numerics.BigInteger, R> FromBigInt<R>(R _arg5, Default2 _arg6)
		{
			return $Numeric.FromBigInt@21-6<R>.@_instance;
		}

		public static FSharpFunc<System.Numerics.BigInteger, R> FromBigInt$W<R>(FSharpFunc<System.Numerics.BigInteger, R> op_Implicit, R _arg5, Default2 _arg6)
		{
			return new $Numeric.FromBigInt@21-7<R>(op_Implicit);
		}

		public static FSharpFunc<System.Numerics.BigInteger, R> FromBigInt<R>(R _arg7, Default1 _arg8)
		{
			return $Numeric.FromBigInt@22-8<R>.@_instance;
		}

		public static FSharpFunc<System.Numerics.BigInteger, R> FromBigInt$W<R>(FSharpFunc<System.Numerics.BigInteger, R> fromBigInt, R _arg7, Default1 _arg8)
		{
			return new $Numeric.FromBigInt@22-9<R>(fromBigInt);
		}

		public static FSharpFunc<System.Numerics.BigInteger, R> FromBigInt<R>(Default1 _arg9, Default1 _arg10)
		{
			return $Numeric.FromBigInt@23-10<R>.@_instance;
		}

		public static FSharpFunc<System.Numerics.BigInteger, R> FromBigInt$W<R>(FSharpFunc<System.Numerics.BigInteger, R> fromBigInt, Default1 _arg9, Default1 _arg10)
		{
			return new $Numeric.FromBigInt@23-11<R>(fromBigInt);
		}

		public static FSharpFunc<System.Numerics.BigInteger, int> FromBigInt(int _arg11, FromBigInt _arg12)
		{
			return $Numeric.FromBigInt@24-12.@_instance;
		}

		public static FSharpFunc<System.Numerics.BigInteger, long> FromBigInt(long _arg13, FromBigInt _arg14)
		{
			return $Numeric.FromBigInt@25-13.@_instance;
		}

		public static FSharpFunc<System.Numerics.BigInteger, IntPtr> FromBigInt(IntPtr _arg15, FromBigInt _arg16)
		{
			return $Numeric.FromBigInt@26-14.@_instance;
		}

		public static FSharpFunc<System.Numerics.BigInteger, UIntPtr> FromBigInt(UIntPtr _arg17, FromBigInt _arg18)
		{
			return $Numeric.FromBigInt@27-15.@_instance;
		}

		public static FSharpFunc<System.Numerics.BigInteger, System.Numerics.BigInteger> FromBigInt(System.Numerics.BigInteger _arg19, FromBigInt _arg20)
		{
			return $Numeric.FromBigInt@28-16.@_instance;
		}

		public static FSharpFunc<System.Numerics.BigInteger, double> FromBigInt(double _arg21, FromBigInt _arg22)
		{
			return $Numeric.FromBigInt@29-17.@_instance;
		}

		public static FSharpFunc<System.Numerics.BigInteger, sbyte> FromBigInt(sbyte _arg23, FromBigInt _arg24)
		{
			return $Numeric.FromBigInt@30-18.@_instance;
		}

		public static FSharpFunc<System.Numerics.BigInteger, short> FromBigInt(short _arg25, FromBigInt _arg26)
		{
			return $Numeric.FromBigInt@31-19.@_instance;
		}

		public static FSharpFunc<System.Numerics.BigInteger, byte> FromBigInt(byte _arg27, FromBigInt _arg28)
		{
			return $Numeric.FromBigInt@32-20.@_instance;
		}

		public static FSharpFunc<System.Numerics.BigInteger, ushort> FromBigInt(ushort _arg29, FromBigInt _arg30)
		{
			return $Numeric.FromBigInt@33-21.@_instance;
		}

		public static FSharpFunc<System.Numerics.BigInteger, uint> FromBigInt(uint _arg31, FromBigInt _arg32)
		{
			return $Numeric.FromBigInt@34-22.@_instance;
		}

		public static FSharpFunc<System.Numerics.BigInteger, ulong> FromBigInt(ulong _arg33, FromBigInt _arg34)
		{
			return $Numeric.FromBigInt@35-23.@_instance;
		}

		public static FSharpFunc<System.Numerics.BigInteger, float> FromBigInt(float _arg35, FromBigInt _arg36)
		{
			return $Numeric.FromBigInt@36-24.@_instance;
		}

		public static FSharpFunc<System.Numerics.BigInteger, decimal> FromBigInt(decimal _arg37, FromBigInt _arg38)
		{
			return $Numeric.FromBigInt@37-25.@_instance;
		}

		public static Num Invoke<Num>(System.Numerics.BigInteger x)
		{
			FromBigInt item = null;
			return FSharpFunc<Tuple<FSharpPlus.Control.FromBigInt, Num>, System.Numerics.BigInteger>.InvokeFast<Num>((FSharpFunc<Tuple<FromBigInt, Num>, FSharpFunc<System.Numerics.BigInteger, Num>>)$Numeric.Invoke@42-8<Num>.@_instance, new Tuple<FromBigInt, Num>(item, default(Num)), x);
		}

		public static Num Invoke$W<Num>(FSharpFunc<Num, FSharpFunc<FromBigInt, FSharpFunc<System.Numerics.BigInteger, Num>>> fromBigInt, System.Numerics.BigInteger x)
		{
			FromBigInt item = null;
			return FSharpFunc<Tuple<FSharpPlus.Control.FromBigInt, Num>, System.Numerics.BigInteger>.InvokeFast<Num>((FSharpFunc<Tuple<FromBigInt, Num>, FSharpFunc<System.Numerics.BigInteger, Num>>)new $Numeric.Invoke@42-9<Num>(fromBigInt), new Tuple<FromBigInt, Num>(item, default(Num)), x);
		}
	}
	[Serializable]
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	public class FromInt64 : Default1
	{
		public static FSharpFunc<long, R> FromInt64<R>(R _arg1, Default4 _arg2)
		{
			return $Numeric.FromInt64@49<R>.@_instance;
		}

		public static FSharpFunc<long, R> FromInt64$W<R>(FSharpFunc<R, FSharpFunc<Explicit, FSharpFunc<long, R>>> @explicit, R _arg1, Default4 _arg2)
		{
			return new $Numeric.FromInt64@49-2<R>(@explicit);
		}

		public static FSharpFunc<long, R> FromInt64<R>(R _arg3, Default3 _arg4)
		{
			return $Numeric.FromInt64@51-4<R>.@_instance;
		}

		public static FSharpFunc<long, R> FromInt64$W<R>(FSharpFunc<R, FSharpFunc<FromBigInt, FSharpFunc<System.Numerics.BigInteger, R>>> fromBigInt, R _arg3, Default3 _arg4)
		{
			return new $Numeric.FromInt64@51-6<R>(fromBigInt);
		}

		public static FSharpFunc<long, R> FromInt64<R>(R _arg5, Default2 _arg6)
		{
			return $Numeric.FromInt64@53-8<R>.@_instance;
		}

		public static FSharpFunc<long, R> FromInt64$W<R>(FSharpFunc<long, R> op_Implicit, R _arg5, Default2 _arg6)
		{
			return new $Numeric.FromInt64@53-9<R>(op_Implicit);
		}

		public static FSharpFunc<long, R> FromInt64<R>(R _arg7, Default1 _arg8)
		{
			return $Numeric.FromInt64@54-10<R>.@_instance;
		}

		public static FSharpFunc<long, R> FromInt64$W<R>(FSharpFunc<long, R> fromInt64, R _arg7, Default1 _arg8)
		{
			return new $Numeric.FromInt64@54-11<R>(fromInt64);
		}

		public static FSharpFunc<long, R> FromInt64<R>(Default1 _arg9, Default1 _arg10)
		{
			return $Numeric.FromInt64@55-12<R>.@_instance;
		}

		public static FSharpFunc<long, R> FromInt64$W<R>(FSharpFunc<long, R> fromInt64, Default1 _arg9, Default1 _arg10)
		{
			return new $Numeric.FromInt64@55-13<R>(fromInt64);
		}

		public static FSharpFunc<long, int> FromInt64(int _arg11, FromInt64 _arg12)
		{
			return $Numeric.FromInt64@56-14.@_instance;
		}

		public static FSharpFunc<long, long> FromInt64(long _arg13, FromInt64 _arg14)
		{
			return $Numeric.FromInt64@57-15.@_instance;
		}

		public static FSharpFunc<long, IntPtr> FromInt64(IntPtr _arg15, FromInt64 _arg16)
		{
			return $Numeric.FromInt64@59-16.@_instance;
		}

		public static FSharpFunc<long, UIntPtr> FromInt64(UIntPtr _arg17, FromInt64 _arg18)
		{
			return $Numeric.FromInt64@60-17.@_instance;
		}

		public static FSharpFunc<long, System.Numerics.BigInteger> FromInt64(System.Numerics.BigInteger _arg19, FromInt64 _arg20)
		{
			return $Numeric.FromInt64@61-18.@_instance;
		}

		public static FSharpFunc<long, double> FromInt64(double _arg21, FromInt64 _arg22)
		{
			return $Numeric.FromInt64@63-19.@_instance;
		}

		public static FSharpFunc<long, float> FromInt64(float _arg23, FromInt64 _arg24)
		{
			return $Numeric.FromInt64@64-20.@_instance;
		}

		public static FSharpFunc<long, decimal> FromInt64(decimal _arg25, FromInt64 _arg26)
		{
			return $Numeric.FromInt64@65-21.@_instance;
		}

		public static FSharpFunc<long, sbyte> FromInt64(sbyte _arg27, FromInt64 _arg28)
		{
			return $Numeric.FromInt64@66-22.@_instance;
		}

		public static FSharpFunc<long, short> FromInt64(short _arg29, FromInt64 _arg30)
		{
			return $Numeric.FromInt64@67-23.@_instance;
		}

		public static FSharpFunc<long, byte> FromInt64(byte _arg31, FromInt64 _arg32)
		{
			return $Numeric.FromInt64@68-24.@_instance;
		}

		public static FSharpFunc<long, ushort> FromInt64(ushort _arg33, FromInt64 _arg34)
		{
			return $Numeric.FromInt64@69-25.@_instance;
		}

		public static FSharpFunc<long, uint> FromInt64(uint _arg35, FromInt64 _arg36)
		{
			return $Numeric.FromInt64@70-26.@_instance;
		}

		public static FSharpFunc<long, ulong> FromInt64(ulong _arg37, FromInt64 _arg38)
		{
			return $Numeric.FromInt64@71-27.@_instance;
		}

		public static Num Invoke<Num>(long x)
		{
			FromInt64 item = null;
			return FSharpFunc<Tuple<FSharpPlus.Control.FromInt64, Num>, long>.InvokeFast<Num>((FSharpFunc<Tuple<FromInt64, Num>, FSharpFunc<long, Num>>)$Numeric.Invoke@76-10<Num>.@_instance, new Tuple<FromInt64, Num>(item, default(Num)), x);
		}

		public static Num Invoke$W<Num>(FSharpFunc<Num, FSharpFunc<FromInt64, FSharpFunc<long, Num>>> fromInt64, long x)
		{
			FromInt64 item = null;
			return FSharpFunc<Tuple<FSharpPlus.Control.FromInt64, Num>, long>.InvokeFast<Num>((FSharpFunc<Tuple<FromInt64, Num>, FSharpFunc<long, Num>>)new $Numeric.Invoke@76-11<Num>(fromInt64), new Tuple<FromInt64, Num>(item, default(Num)), x);
		}
	}
	[Serializable]
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	public class FromInt32 : Default1
	{
		public static FSharpFunc<int, R> FromInt32<R>(R _arg1, Default4 _arg2)
		{
			return $Numeric.FromInt32@81<R>.@_instance;
		}

		public static FSharpFunc<int, R> FromInt32$W<R>(FSharpFunc<R, FSharpFunc<Explicit, FSharpFunc<int, R>>> @explicit, R _arg1, Default4 _arg2)
		{
			return new $Numeric.FromInt32@81-2<R>(@explicit);
		}

		public static FSharpFunc<int, R> FromInt32<R>(R _arg3, Default3 _arg4)
		{
			return $Numeric.FromInt32@82-4<R>.@_instance;
		}

		public static FSharpFunc<int, R> FromInt32$W<R>(FSharpFunc<R, FSharpFunc<FromInt64, FSharpFunc<long, R>>> fromInt64, R _arg3, Default3 _arg4)
		{
			return new $Numeric.FromInt32@82-6<R>(fromInt64);
		}

		public static FSharpFunc<int, R> FromInt32<R>(R _arg5, Default2 _arg6)
		{
			return $Numeric.FromInt32@83-8<R>.@_instance;
		}

		public static FSharpFunc<int, R> FromInt32$W<R>(FSharpFunc<int, R> op_Implicit, R _arg5, Default2 _arg6)
		{
			return new $Numeric.FromInt32@83-9<R>(op_Implicit);
		}

		public static FSharpFunc<int, R> FromInt32<R>(R _arg7, Default1 _arg8)
		{
			return $Numeric.FromInt32@84-10<R>.@_instance;
		}

		public static FSharpFunc<int, R> FromInt32$W<R>(FSharpFunc<int, R> fromInt32, R _arg7, Default1 _arg8)
		{
			return new $Numeric.FromInt32@84-11<R>(fromInt32);
		}

		public static FSharpFunc<int, R> FromInt32<R>(Default1 _arg9, Default1 _arg10)
		{
			return $Numeric.FromInt32@85-12<R>.@_instance;
		}

		public static FSharpFunc<int, R> FromInt32$W<R>(FSharpFunc<int, R> fromInt32, Default1 _arg9, Default1 _arg10)
		{
			return new $Numeric.FromInt32@85-13<R>(fromInt32);
		}

		public static FSharpFunc<int, int> FromInt32(int _arg11, FromInt32 _arg12)
		{
			return $Numeric.FromInt32@86-14.@_instance;
		}

		public static FSharpFunc<int, long> FromInt32(long _arg13, FromInt32 _arg14)
		{
			return $Numeric.FromInt32@87-15.@_instance;
		}

		public static FSharpFunc<int, IntPtr> FromInt32(IntPtr _arg15, FromInt32 _arg16)
		{
			return $Numeric.FromInt32@89-16.@_instance;
		}

		public static FSharpFunc<int, UIntPtr> FromInt32(UIntPtr _arg17, FromInt32 _arg18)
		{
			return $Numeric.FromInt32@90-17.@_instance;
		}

		public static FSharpFunc<int, System.Numerics.BigInteger> FromInt32(System.Numerics.BigInteger _arg19, FromInt32 _arg20)
		{
			return $Numeric.FromInt32@91-18.@_instance;
		}

		public static FSharpFunc<int, double> FromInt32(double _arg21, FromInt32 _arg22)
		{
			return $Numeric.FromInt32@93-19.@_instance;
		}

		public static FSharpFunc<int, sbyte> FromInt32(sbyte _arg23, FromInt32 _arg24)
		{
			return $Numeric.FromInt32@94-20.@_instance;
		}

		public static FSharpFunc<int, short> FromInt32(short _arg25, FromInt32 _arg26)
		{
			return $Numeric.FromInt32@95-21.@_instance;
		}

		public static FSharpFunc<int, byte> FromInt32(byte _arg27, FromInt32 _arg28)
		{
			return $Numeric.FromInt32@96-22.@_instance;
		}

		public static FSharpFunc<int, ushort> FromInt32(ushort _arg29, FromInt32 _arg30)
		{
			return $Numeric.FromInt32@97-23.@_instance;
		}

		public static FSharpFunc<int, uint> FromInt32(uint _arg31, FromInt32 _arg32)
		{
			return $Numeric.FromInt32@98-24.@_instance;
		}

		public static FSharpFunc<int, ulong> FromInt32(ulong _arg33, FromInt32 _arg34)
		{
			return $Numeric.FromInt32@99-25.@_instance;
		}

		public static FSharpFunc<int, float> FromInt32(float _arg35, FromInt32 _arg36)
		{
			return $Numeric.FromInt32@100-26.@_instance;
		}

		public static FSharpFunc<int, decimal> FromInt32(decimal _arg37, FromInt32 _arg38)
		{
			return $Numeric.FromInt32@101-27.@_instance;
		}

		public static Num Invoke<Num>(int x)
		{
			FromInt32 item = null;
			return FSharpFunc<Tuple<FSharpPlus.Control.FromInt32, Num>, int>.InvokeFast<Num>((FSharpFunc<Tuple<FromInt32, Num>, FSharpFunc<int, Num>>)$Numeric.Invoke@106-12<Num>.@_instance, new Tuple<FromInt32, Num>(item, default(Num)), x);
		}

		public static Num Invoke$W<Num>(FSharpFunc<Num, FSharpFunc<FromInt32, FSharpFunc<int, Num>>> fromInt32, int x)
		{
			FromInt32 item = null;
			return FSharpFunc<Tuple<FSharpPlus.Control.FromInt32, Num>, int>.InvokeFast<Num>((FSharpFunc<Tuple<FromInt32, Num>, FSharpFunc<int, Num>>)new $Numeric.Invoke@106-13<Num>(fromInt32), new Tuple<FromInt32, Num>(item, default(Num)), x);
		}

		public static Num InvokeOnInstance<Num>(int x)
		{
			throw new NotSupportedException("Dynamic invocation of FromInt32 is not supported");
		}

		public static Num InvokeOnInstance$W<Num>(FSharpFunc<int, Num> fromInt32, int x)
		{
			return fromInt32.Invoke(x);
		}
	}
	[Serializable]
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	public class One : Default1
	{
		public static t One<t>(t _arg1, Default1 _arg2)
		{
			FromInt32 item = null;
			return FSharpFunc<Tuple<FromInt32, t>, int>.InvokeFast<t>((FSharpFunc<Tuple<FromInt32, t>, FSharpFunc<int, t>>)$Numeric.One@115<t>.@_instance, new Tuple<FromInt32, t>(item, default(t)), 1);
		}

		public static t One$W<t>(FSharpFunc<t, FSharpFunc<FromInt32, FSharpFunc<int, t>>> fromInt32, t _arg1, Default1 _arg2)
		{
			FromInt32 item = null;
			return FSharpFunc<Tuple<FromInt32, t>, int>.InvokeFast<t>((FSharpFunc<Tuple<FromInt32, t>, FSharpFunc<int, t>>)new $Numeric.One@115-1<t>(fromInt32), new Tuple<FromInt32, t>(item, default(t)), 1);
		}

		public static t One<t>(t _arg3, One _arg4)
		{
			return LanguagePrimitives.GenericOneDynamic<t>();
		}

		public static t One$W<t>(FSharpFunc<Unit, t> get_One, t _arg3, One _arg4)
		{
			return get_One.Invoke((Unit)null);
		}

		public static FSharpFunc<a, a> One<t, a>(t _arg5, One _arg6) where t : class
		{
			return $Numeric.One@117-2<a>.@_instance;
		}

		public static Num Invoke<Num>()
		{
			One one = null;
			throw new NotSupportedException("Dynamic invocation of One is not supported");
		}

		public static Num Invoke$W<Num>(FSharpFunc<Num, FSharpFunc<One, Num>> one)
		{
			One one2 = null;
			return FSharpFunc<Num, FSharpPlus.Control.One>.InvokeFast<Num>(one, default(Num), one2);
		}
	}
	[Serializable]
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	public class Zero : Default1
	{
		public static TimeSpan Zero(TimeSpan _arg1, Zero _arg2)
		{
			return default(TimeSpan);
		}

		public static DmStruct Zero(DmStruct _arg3, Zero _arg4)
		{
			return default(DmStruct);
		}

		public static FSharpList<a> Zero<a>(FSharpList<a> _arg5, Zero _arg6)
		{
			return FSharpList<a>.Empty;
		}

		public static FSharpOption<a> Zero<a>(FSharpOption<a> _arg7, Zero _arg8)
		{
			return null;
		}

		public static FSharpValueOption<a> Zero<a>(FSharpValueOption<a> _arg9, Zero _arg10)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return FSharpValueOption<a>.ValueNone;
		}

		public static a[] Zero<a>(a[] _arg11, Zero _arg12)
		{
			return System.Array.Empty<a>();
		}

		public static string Zero(string _arg13, Zero _arg14)
		{
			return "";
		}

		public static StringBuilder Zero(StringBuilder _arg15, Zero _arg16)
		{
			return new StringBuilder();
		}

		public static void Zero(Unit _arg17, Zero _arg18)
		{
		}

		public static bool Zero(bool _arg19, Zero _arg20)
		{
			return false;
		}

		public static FSharpSet<a> Zero<a>(FSharpSet<a> _arg21, Zero _arg22)
		{
			return SetModule.Empty<a>();
		}

		public static FSharpMap<a, b> Zero<a, b>(FSharpMap<a, b> _arg23, Zero _arg24)
		{
			return MapModule.Empty<a, b>();
		}

		public static a Invoke<a>()
		{
			Zero zero = null;
			throw new NotSupportedException("Dynamic invocation of Zero is not supported");
		}

		public static a Invoke$W<a>(FSharpFunc<a, FSharpFunc<Zero, a>> zero)
		{
			Zero zero2 = null;
			return FSharpFunc<a, FSharpPlus.Control.Zero>.InvokeFast<a>(zero, default(a), zero2);
		}

		public static t Zero<t, t1, t2, t3, t4, t5, t6, t7, tr>(t t, Zero _arg1)
		{
			Zero zero = null;
			if (0 == 0)
			{
				throw new NotSupportedException("Dynamic invocation of Zero is not supported");
			}
			tr rest = (tr)(object)null;
			zero = null;
			if (0 == 0)
			{
				throw new NotSupportedException("Dynamic invocation of Zero is not supported");
			}
			t7 item = (t7)(object)null;
			zero = null;
			if (0 == 0)
			{
				throw new NotSupportedException("Dynamic invocation of Zero is not supported");
			}
			t6 item2 = (t6)(object)null;
			zero = null;
			if (0 == 0)
			{
				throw new NotSupportedException("Dynamic invocation of Zero is not supported");
			}
			t5 item3 = (t5)(object)null;
			zero = null;
			if (0 == 0)
			{
				throw new NotSupportedException("Dynamic invocation of Zero is not supported");
			}
			t4 item4 = (t4)(object)null;
			zero = null;
			if (0 == 0)
			{
				throw new NotSupportedException("Dynamic invocation of Zero is not supported");
			}
			t3 item5 = (t3)(object)null;
			zero = null;
			if (0 == 0)
			{
				throw new NotSupportedException("Dynamic invocation of Zero is not supported");
			}
			t2 item6 = (t2)(object)null;
			zero = null;
			if (0 == 0)
			{
				throw new NotSupportedException("Dynamic invocation of Zero is not supported");
			}
			t1 item7 = (t1)(object)null;
			return (t)new Tuple<t1, t2, t3, t4, t5, t6, t7, tr>(item7, item6, item5, item4, item3, item2, item, rest);
		}

		public static t Zero$W<t, t1, t2, t3, t4, t5, t6, t7, tr>(FSharpFunc<t1, FSharpFunc<Zero, t1>> zero, FSharpFunc<t2, FSharpFunc<Zero, t2>> zero1, FSharpFunc<t3, FSharpFunc<Zero, t3>> zero2, FSharpFunc<t4, FSharpFunc<Zero, t4>> zero3, FSharpFunc<t5, FSharpFunc<Zero, t5>> zero4, FSharpFunc<t6, FSharpFunc<Zero, t6>> zero5, FSharpFunc<t7, FSharpFunc<Zero, t7>> zero6, FSharpFunc<tr, FSharpFunc<Zero, tr>> zero7, FSharpFunc<t, t1> get_Item1, FSharpFunc<t, t2> get_Item2, FSharpFunc<t, t3> get_Item3, FSharpFunc<t, t4> get_Item4, FSharpFunc<t, t5> get_Item5, FSharpFunc<t, t6> get_Item6, FSharpFunc<t, t7> get_Item7, FSharpFunc<t, tr> get_Rest, t t, Zero _arg1)
		{
			Zero zero8 = null;
			tr rest = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<tr>((FSharpFunc<?, FSharpFunc<Zero, tr>>)(object)zero7, default(tr), zero8);
			zero8 = null;
			t7 item = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<t7>((FSharpFunc<?, FSharpFunc<Zero, t7>>)(object)zero6, default(t7), zero8);
			zero8 = null;
			t6 item2 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<t6>((FSharpFunc<?, FSharpFunc<Zero, t6>>)(object)zero5, default(t6), zero8);
			zero8 = null;
			t5 item3 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<t5>((FSharpFunc<?, FSharpFunc<Zero, t5>>)(object)zero4, default(t5), zero8);
			zero8 = null;
			t4 item4 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<t4>((FSharpFunc<?, FSharpFunc<Zero, t4>>)(object)zero3, default(t4), zero8);
			zero8 = null;
			t3 item5 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<t3>((FSharpFunc<?, FSharpFunc<Zero, t3>>)(object)zero2, default(t3), zero8);
			zero8 = null;
			t2 item6 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<t2>((FSharpFunc<?, FSharpFunc<Zero, t2>>)(object)zero1, default(t2), zero8);
			zero8 = null;
			t1 item7 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<t1>((FSharpFunc<?, FSharpFunc<Zero, t1>>)(object)zero, default(t1), zero8);
			return (t)new Tuple<t1, t2, t3, t4, t5, t6, t7, tr>(item7, item6, item5, item4, item3, item2, item, rest);
		}

		public static Tuple<a> Zero<a>(Tuple<a> _arg1, Zero _arg2)
		{
			Zero zero = null;
			if (0 == 0)
			{
				throw new NotSupportedException("Dynamic invocation of Zero is not supported");
			}
			return new Tuple<a>((a)(object)null);
		}

		public static Tuple<a> Zero$W<a>(FSharpFunc<a, FSharpFunc<Zero, a>> zero, Tuple<a> _arg1, Zero _arg2)
		{
			Zero zero2 = null;
			return new Tuple<a>(FSharpFunc<a, FSharpPlus.Control.Zero>.InvokeFast<a>(zero, default(a), zero2));
		}

		public static Id<a> Zero<a, a>(Id<a> _arg3, Zero _arg4)
		{
			Zero zero = null;
			if (0 == 0)
			{
				throw new NotSupportedException("Dynamic invocation of Zero is not supported");
			}
			return new Id<a>((a)(object)null);
		}

		public static Id<a> Zero$W<a, a>(FSharpFunc<a, FSharpFunc<Zero, a>> zero, Id<a> _arg3, Zero _arg4)
		{
			Zero zero2 = null;
			return new Id<a>(FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<a>((FSharpFunc<?, FSharpFunc<Zero, a>>)(object)zero, default(a), zero2));
		}

		public static ValueTuple<a> Zero<a>(ValueTuple<a> _arg5, Zero _arg6)
		{
			Zero zero = null;
			if (0 == 0)
			{
				throw new NotSupportedException("Dynamic invocation of Zero is not supported");
			}
			return ValueTuple.Create((a)(object)null);
		}

		public static ValueTuple<a> Zero$W<a>(FSharpFunc<a, FSharpFunc<Zero, a>> zero, ValueTuple<a> _arg5, Zero _arg6)
		{
			Zero zero2 = null;
			return ValueTuple.Create(FSharpFunc<a, FSharpPlus.Control.Zero>.InvokeFast<a>(zero, default(a), zero2));
		}

		public static Tuple<a, b> Zero<a, b>(Tuple<a, b> _arg1, Zero _arg2)
		{
			Zero zero = null;
			if (false)
			{
				a item = (a)(object)null;
				zero = null;
				if (0 == 0)
				{
					throw new NotSupportedException("Dynamic invocation of Zero is not supported");
				}
				return new Tuple<a, b>(item, (b)(object)null);
			}
			throw new NotSupportedException("Dynamic invocation of Zero is not supported");
		}

		public static Tuple<a, b> Zero$W<a, b>(FSharpFunc<a, FSharpFunc<Zero, a>> zero, FSharpFunc<b, FSharpFunc<Zero, b>> zero1, Tuple<a, b> _arg1, Zero _arg2)
		{
			Zero zero2 = null;
			a item = FSharpFunc<a, FSharpPlus.Control.Zero>.InvokeFast<a>(zero, default(a), zero2);
			zero2 = null;
			return new Tuple<a, b>(item, FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<b>((FSharpFunc<?, FSharpFunc<Zero, b>>)(object)zero1, default(b), zero2));
		}

		public static Tuple<a, b, c> Zero<a, b, c>(Tuple<a, b, c> _arg1, Zero _arg2)
		{
			Zero zero = null;
			if (false)
			{
				a item = (a)(object)null;
				zero = null;
				if (false)
				{
					b item2 = (b)(object)null;
					zero = null;
					if (0 == 0)
					{
						throw new NotSupportedException("Dynamic invocation of Zero is not supported");
					}
					return new Tuple<a, b, c>(item, item2, (c)(object)null);
				}
				throw new NotSupportedException("Dynamic invocation of Zero is not supported");
			}
			throw new NotSupportedException("Dynamic invocation of Zero is not supported");
		}

		public static Tuple<a, b, c> Zero$W<a, b, c>(FSharpFunc<a, FSharpFunc<Zero, a>> zero, FSharpFunc<b, FSharpFunc<Zero, b>> zero1, FSharpFunc<c, FSharpFunc<Zero, c>> zero2, Tuple<a, b, c> _arg1, Zero _arg2)
		{
			Zero zero3 = null;
			a item = FSharpFunc<a, FSharpPlus.Control.Zero>.InvokeFast<a>(zero, default(a), zero3);
			zero3 = null;
			b item2 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<b>((FSharpFunc<?, FSharpFunc<Zero, b>>)(object)zero1, default(b), zero3);
			zero3 = null;
			return new Tuple<a, b, c>(item, item2, FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<c>((FSharpFunc<?, FSharpFunc<Zero, c>>)(object)zero2, default(c), zero3));
		}

		public static Tuple<a, b, c, d> Zero<a, b, c, d>(Tuple<a, b, c, d> _arg1, Zero _arg2)
		{
			Zero zero = null;
			if (false)
			{
				a item = (a)(object)null;
				zero = null;
				if (false)
				{
					b item2 = (b)(object)null;
					zero = null;
					if (false)
					{
						c item3 = (c)(object)null;
						zero = null;
						if (0 == 0)
						{
							throw new NotSupportedException("Dynamic invocation of Zero is not supported");
						}
						return new Tuple<a, b, c, d>(item, item2, item3, (d)(object)null);
					}
					throw new NotSupportedException("Dynamic invocation of Zero is not supported");
				}
				throw new NotSupportedException("Dynamic invocation of Zero is not supported");
			}
			throw new NotSupportedException("Dynamic invocation of Zero is not supported");
		}

		public static Tuple<a, b, c, d> Zero$W<a, b, c, d>(FSharpFunc<a, FSharpFunc<Zero, a>> zero, FSharpFunc<b, FSharpFunc<Zero, b>> zero1, FSharpFunc<c, FSharpFunc<Zero, c>> zero2, FSharpFunc<d, FSharpFunc<Zero, d>> zero3, Tuple<a, b, c, d> _arg1, Zero _arg2)
		{
			Zero zero4 = null;
			a item = FSharpFunc<a, FSharpPlus.Control.Zero>.InvokeFast<a>(zero, default(a), zero4);
			zero4 = null;
			b item2 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<b>((FSharpFunc<?, FSharpFunc<Zero, b>>)(object)zero1, default(b), zero4);
			zero4 = null;
			c item3 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<c>((FSharpFunc<?, FSharpFunc<Zero, c>>)(object)zero2, default(c), zero4);
			zero4 = null;
			return new Tuple<a, b, c, d>(item, item2, item3, FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<d>((FSharpFunc<?, FSharpFunc<Zero, d>>)(object)zero3, default(d), zero4));
		}

		public static Tuple<a, b, c, d, e> Zero<a, b, c, d, e>(Tuple<a, b, c, d, e> _arg1, Zero _arg2)
		{
			Zero zero = null;
			if (false)
			{
				a item = (a)(object)null;
				zero = null;
				if (false)
				{
					b item2 = (b)(object)null;
					zero = null;
					if (false)
					{
						c item3 = (c)(object)null;
						zero = null;
						if (false)
						{
							d item4 = (d)(object)null;
							zero = null;
							if (0 == 0)
							{
								throw new NotSupportedException("Dynamic invocation of Zero is not supported");
							}
							return new Tuple<a, b, c, d, e>(item, item2, item3, item4, (e)(object)null);
						}
						throw new NotSupportedException("Dynamic invocation of Zero is not supported");
					}
					throw new NotSupportedException("Dynamic invocation of Zero is not supported");
				}
				throw new NotSupportedException("Dynamic invocation of Zero is not supported");
			}
			throw new NotSupportedException("Dynamic invocation of Zero is not supported");
		}

		public static Tuple<a, b, c, d, e> Zero$W<a, b, c, d, e>(FSharpFunc<a, FSharpFunc<Zero, a>> zero, FSharpFunc<b, FSharpFunc<Zero, b>> zero1, FSharpFunc<c, FSharpFunc<Zero, c>> zero2, FSharpFunc<d, FSharpFunc<Zero, d>> zero3, FSharpFunc<e, FSharpFunc<Zero, e>> zero4, Tuple<a, b, c, d, e> _arg1, Zero _arg2)
		{
			Zero zero5 = null;
			a item = FSharpFunc<a, FSharpPlus.Control.Zero>.InvokeFast<a>(zero, default(a), zero5);
			zero5 = null;
			b item2 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<b>((FSharpFunc<?, FSharpFunc<Zero, b>>)(object)zero1, default(b), zero5);
			zero5 = null;
			c item3 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<c>((FSharpFunc<?, FSharpFunc<Zero, c>>)(object)zero2, default(c), zero5);
			zero5 = null;
			d item4 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<d>((FSharpFunc<?, FSharpFunc<Zero, d>>)(object)zero3, default(d), zero5);
			zero5 = null;
			return new Tuple<a, b, c, d, e>(item, item2, item3, item4, FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<e>((FSharpFunc<?, FSharpFunc<Zero, e>>)(object)zero4, default(e), zero5));
		}

		public static Tuple<a, b, c, d, e, f> Zero<a, b, c, d, e, f>(Tuple<a, b, c, d, e, f> _arg1, Zero _arg2)
		{
			Zero zero = null;
			if (false)
			{
				a item = (a)(object)null;
				zero = null;
				if (false)
				{
					b item2 = (b)(object)null;
					zero = null;
					if (false)
					{
						c item3 = (c)(object)null;
						zero = null;
						if (false)
						{
							d item4 = (d)(object)null;
							zero = null;
							if (false)
							{
								e item5 = (e)(object)null;
								zero = null;
								if (0 == 0)
								{
									throw new NotSupportedException("Dynamic invocation of Zero is not supported");
								}
								return new Tuple<a, b, c, d, e, f>(item, item2, item3, item4, item5, (f)(object)null);
							}
							throw new NotSupportedException("Dynamic invocation of Zero is not supported");
						}
						throw new NotSupportedException("Dynamic invocation of Zero is not supported");
					}
					throw new NotSupportedException("Dynamic invocation of Zero is not supported");
				}
				throw new NotSupportedException("Dynamic invocation of Zero is not supported");
			}
			throw new NotSupportedException("Dynamic invocation of Zero is not supported");
		}

		public static Tuple<a, b, c, d, e, f> Zero$W<a, b, c, d, e, f>(FSharpFunc<a, FSharpFunc<Zero, a>> zero, FSharpFunc<b, FSharpFunc<Zero, b>> zero1, FSharpFunc<c, FSharpFunc<Zero, c>> zero2, FSharpFunc<d, FSharpFunc<Zero, d>> zero3, FSharpFunc<e, FSharpFunc<Zero, e>> zero4, FSharpFunc<f, FSharpFunc<Zero, f>> zero5, Tuple<a, b, c, d, e, f> _arg1, Zero _arg2)
		{
			Zero zero6 = null;
			a item = FSharpFunc<a, FSharpPlus.Control.Zero>.InvokeFast<a>(zero, default(a), zero6);
			zero6 = null;
			b item2 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<b>((FSharpFunc<?, FSharpFunc<Zero, b>>)(object)zero1, default(b), zero6);
			zero6 = null;
			c item3 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<c>((FSharpFunc<?, FSharpFunc<Zero, c>>)(object)zero2, default(c), zero6);
			zero6 = null;
			d item4 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<d>((FSharpFunc<?, FSharpFunc<Zero, d>>)(object)zero3, default(d), zero6);
			zero6 = null;
			e item5 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<e>((FSharpFunc<?, FSharpFunc<Zero, e>>)(object)zero4, default(e), zero6);
			zero6 = null;
			return new Tuple<a, b, c, d, e, f>(item, item2, item3, item4, item5, FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<f>((FSharpFunc<?, FSharpFunc<Zero, f>>)(object)zero5, default(f), zero6));
		}

		public static Tuple<a, b, c, d, e, f, g> Zero<a, b, c, d, e, f, g>(Tuple<a, b, c, d, e, f, g> _arg1, Zero _arg2)
		{
			Zero zero = null;
			if (false)
			{
				a item = (a)(object)null;
				zero = null;
				if (false)
				{
					b item2 = (b)(object)null;
					zero = null;
					if (false)
					{
						c item3 = (c)(object)null;
						zero = null;
						if (false)
						{
							d item4 = (d)(object)null;
							zero = null;
							if (false)
							{
								e item5 = (e)(object)null;
								zero = null;
								if (false)
								{
									f item6 = (f)(object)null;
									zero = null;
									if (0 == 0)
									{
										throw new NotSupportedException("Dynamic invocation of Zero is not supported");
									}
									return new Tuple<a, b, c, d, e, f, g>(item, item2, item3, item4, item5, item6, (g)(object)null);
								}
								throw new NotSupportedException("Dynamic invocation of Zero is not supported");
							}
							throw new NotSupportedException("Dynamic invocation of Zero is not supported");
						}
						throw new NotSupportedException("Dynamic invocation of Zero is not supported");
					}
					throw new NotSupportedException("Dynamic invocation of Zero is not supported");
				}
				throw new NotSupportedException("Dynamic invocation of Zero is not supported");
			}
			throw new NotSupportedException("Dynamic invocation of Zero is not supported");
		}

		public static Tuple<a, b, c, d, e, f, g> Zero$W<a, b, c, d, e, f, g>(FSharpFunc<a, FSharpFunc<Zero, a>> zero, FSharpFunc<b, FSharpFunc<Zero, b>> zero1, FSharpFunc<c, FSharpFunc<Zero, c>> zero2, FSharpFunc<d, FSharpFunc<Zero, d>> zero3, FSharpFunc<e, FSharpFunc<Zero, e>> zero4, FSharpFunc<f, FSharpFunc<Zero, f>> zero5, FSharpFunc<g, FSharpFunc<Zero, g>> zero6, Tuple<a, b, c, d, e, f, g> _arg1, Zero _arg2)
		{
			Zero zero7 = null;
			a item = FSharpFunc<a, FSharpPlus.Control.Zero>.InvokeFast<a>(zero, default(a), zero7);
			zero7 = null;
			b item2 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<b>((FSharpFunc<?, FSharpFunc<Zero, b>>)(object)zero1, default(b), zero7);
			zero7 = null;
			c item3 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<c>((FSharpFunc<?, FSharpFunc<Zero, c>>)(object)zero2, default(c), zero7);
			zero7 = null;
			d item4 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<d>((FSharpFunc<?, FSharpFunc<Zero, d>>)(object)zero3, default(d), zero7);
			zero7 = null;
			e item5 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<e>((FSharpFunc<?, FSharpFunc<Zero, e>>)(object)zero4, default(e), zero7);
			zero7 = null;
			f item6 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<f>((FSharpFunc<?, FSharpFunc<Zero, f>>)(object)zero5, default(f), zero7);
			zero7 = null;
			return new Tuple<a, b, c, d, e, f, g>(item, item2, item3, item4, item5, item6, FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<g>((FSharpFunc<?, FSharpFunc<Zero, g>>)(object)zero6, default(g), zero7));
		}

		public static (a, b) Zero<a, b>((a, b) _arg1, Zero _arg2)
		{
			Zero zero = null;
			if (false)
			{
				a item = (a)(object)null;
				zero = null;
				if (0 == 0)
				{
					throw new NotSupportedException("Dynamic invocation of Zero is not supported");
				}
				return ValueTuple.Create(item, (b)(object)null);
			}
			throw new NotSupportedException("Dynamic invocation of Zero is not supported");
		}

		public static (a, b) Zero$W<a, b>(FSharpFunc<a, FSharpFunc<Zero, a>> zero, FSharpFunc<b, FSharpFunc<Zero, b>> zero1, (a, b) _arg1, Zero _arg2)
		{
			Zero zero2 = null;
			a item = FSharpFunc<a, FSharpPlus.Control.Zero>.InvokeFast<a>(zero, default(a), zero2);
			zero2 = null;
			return ValueTuple.Create(item, FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<b>((FSharpFunc<?, FSharpFunc<Zero, b>>)(object)zero1, default(b), zero2));
		}

		public static (a, b, c) Zero<a, b, c>((a, b, c) _arg1, Zero _arg2)
		{
			Zero zero = null;
			if (false)
			{
				a item = (a)(object)null;
				zero = null;
				if (false)
				{
					b item2 = (b)(object)null;
					zero = null;
					if (0 == 0)
					{
						throw new NotSupportedException("Dynamic invocation of Zero is not supported");
					}
					return ValueTuple.Create(item, item2, (c)(object)null);
				}
				throw new NotSupportedException("Dynamic invocation of Zero is not supported");
			}
			throw new NotSupportedException("Dynamic invocation of Zero is not supported");
		}

		public static (a, b, c) Zero$W<a, b, c>(FSharpFunc<a, FSharpFunc<Zero, a>> zero, FSharpFunc<b, FSharpFunc<Zero, b>> zero1, FSharpFunc<c, FSharpFunc<Zero, c>> zero2, (a, b, c) _arg1, Zero _arg2)
		{
			Zero zero3 = null;
			a item = FSharpFunc<a, FSharpPlus.Control.Zero>.InvokeFast<a>(zero, default(a), zero3);
			zero3 = null;
			b item2 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<b>((FSharpFunc<?, FSharpFunc<Zero, b>>)(object)zero1, default(b), zero3);
			zero3 = null;
			return ValueTuple.Create(item, item2, FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<c>((FSharpFunc<?, FSharpFunc<Zero, c>>)(object)zero2, default(c), zero3));
		}

		public static (a, b, c, d) Zero<a, b, c, d>((a, b, c, d) _arg1, Zero _arg2)
		{
			Zero zero = null;
			if (false)
			{
				a item = (a)(object)null;
				zero = null;
				if (false)
				{
					b item2 = (b)(object)null;
					zero = null;
					if (false)
					{
						c item3 = (c)(object)null;
						zero = null;
						if (0 == 0)
						{
							throw new NotSupportedException("Dynamic invocation of Zero is not supported");
						}
						return ValueTuple.Create(item, item2, item3, (d)(object)null);
					}
					throw new NotSupportedException("Dynamic invocation of Zero is not supported");
				}
				throw new NotSupportedException("Dynamic invocation of Zero is not supported");
			}
			throw new NotSupportedException("Dynamic invocation of Zero is not supported");
		}

		public static (a, b, c, d) Zero$W<a, b, c, d>(FSharpFunc<a, FSharpFunc<Zero, a>> zero, FSharpFunc<b, FSharpFunc<Zero, b>> zero1, FSharpFunc<c, FSharpFunc<Zero, c>> zero2, FSharpFunc<d, FSharpFunc<Zero, d>> zero3, (a, b, c, d) _arg1, Zero _arg2)
		{
			Zero zero4 = null;
			a item = FSharpFunc<a, FSharpPlus.Control.Zero>.InvokeFast<a>(zero, default(a), zero4);
			zero4 = null;
			b item2 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<b>((FSharpFunc<?, FSharpFunc<Zero, b>>)(object)zero1, default(b), zero4);
			zero4 = null;
			c item3 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<c>((FSharpFunc<?, FSharpFunc<Zero, c>>)(object)zero2, default(c), zero4);
			zero4 = null;
			return ValueTuple.Create(item, item2, item3, FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<d>((FSharpFunc<?, FSharpFunc<Zero, d>>)(object)zero3, default(d), zero4));
		}

		public static (a, b, c, d, e) Zero<a, b, c, d, e>((a, b, c, d, e) _arg1, Zero _arg2)
		{
			Zero zero = null;
			if (false)
			{
				a item = (a)(object)null;
				zero = null;
				if (false)
				{
					b item2 = (b)(object)null;
					zero = null;
					if (false)
					{
						c item3 = (c)(object)null;
						zero = null;
						if (false)
						{
							d item4 = (d)(object)null;
							zero = null;
							if (0 == 0)
							{
								throw new NotSupportedException("Dynamic invocation of Zero is not supported");
							}
							return ValueTuple.Create(item, item2, item3, item4, (e)(object)null);
						}
						throw new NotSupportedException("Dynamic invocation of Zero is not supported");
					}
					throw new NotSupportedException("Dynamic invocation of Zero is not supported");
				}
				throw new NotSupportedException("Dynamic invocation of Zero is not supported");
			}
			throw new NotSupportedException("Dynamic invocation of Zero is not supported");
		}

		public static (a, b, c, d, e) Zero$W<a, b, c, d, e>(FSharpFunc<a, FSharpFunc<Zero, a>> zero, FSharpFunc<b, FSharpFunc<Zero, b>> zero1, FSharpFunc<c, FSharpFunc<Zero, c>> zero2, FSharpFunc<d, FSharpFunc<Zero, d>> zero3, FSharpFunc<e, FSharpFunc<Zero, e>> zero4, (a, b, c, d, e) _arg1, Zero _arg2)
		{
			Zero zero5 = null;
			a item = FSharpFunc<a, FSharpPlus.Control.Zero>.InvokeFast<a>(zero, default(a), zero5);
			zero5 = null;
			b item2 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<b>((FSharpFunc<?, FSharpFunc<Zero, b>>)(object)zero1, default(b), zero5);
			zero5 = null;
			c item3 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<c>((FSharpFunc<?, FSharpFunc<Zero, c>>)(object)zero2, default(c), zero5);
			zero5 = null;
			d item4 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<d>((FSharpFunc<?, FSharpFunc<Zero, d>>)(object)zero3, default(d), zero5);
			zero5 = null;
			return ValueTuple.Create(item, item2, item3, item4, FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<e>((FSharpFunc<?, FSharpFunc<Zero, e>>)(object)zero4, default(e), zero5));
		}

		public static (a, b, c, d, e, f) Zero<a, b, c, d, e, f>((a, b, c, d, e, f) _arg1, Zero _arg2)
		{
			Zero zero = null;
			if (false)
			{
				a item = (a)(object)null;
				zero = null;
				if (false)
				{
					b item2 = (b)(object)null;
					zero = null;
					if (false)
					{
						c item3 = (c)(object)null;
						zero = null;
						if (false)
						{
							d item4 = (d)(object)null;
							zero = null;
							if (false)
							{
								e item5 = (e)(object)null;
								zero = null;
								if (0 == 0)
								{
									throw new NotSupportedException("Dynamic invocation of Zero is not supported");
								}
								return ValueTuple.Create(item, item2, item3, item4, item5, (f)(object)null);
							}
							throw new NotSupportedException("Dynamic invocation of Zero is not supported");
						}
						throw new NotSupportedException("Dynamic invocation of Zero is not supported");
					}
					throw new NotSupportedException("Dynamic invocation of Zero is not supported");
				}
				throw new NotSupportedException("Dynamic invocation of Zero is not supported");
			}
			throw new NotSupportedException("Dynamic invocation of Zero is not supported");
		}

		public static (a, b, c, d, e, f) Zero$W<a, b, c, d, e, f>(FSharpFunc<a, FSharpFunc<Zero, a>> zero, FSharpFunc<b, FSharpFunc<Zero, b>> zero1, FSharpFunc<c, FSharpFunc<Zero, c>> zero2, FSharpFunc<d, FSharpFunc<Zero, d>> zero3, FSharpFunc<e, FSharpFunc<Zero, e>> zero4, FSharpFunc<f, FSharpFunc<Zero, f>> zero5, (a, b, c, d, e, f) _arg1, Zero _arg2)
		{
			Zero zero6 = null;
			a item = FSharpFunc<a, FSharpPlus.Control.Zero>.InvokeFast<a>(zero, default(a), zero6);
			zero6 = null;
			b item2 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<b>((FSharpFunc<?, FSharpFunc<Zero, b>>)(object)zero1, default(b), zero6);
			zero6 = null;
			c item3 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<c>((FSharpFunc<?, FSharpFunc<Zero, c>>)(object)zero2, default(c), zero6);
			zero6 = null;
			d item4 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<d>((FSharpFunc<?, FSharpFunc<Zero, d>>)(object)zero3, default(d), zero6);
			zero6 = null;
			e item5 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<e>((FSharpFunc<?, FSharpFunc<Zero, e>>)(object)zero4, default(e), zero6);
			zero6 = null;
			return ValueTuple.Create(item, item2, item3, item4, item5, FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<f>((FSharpFunc<?, FSharpFunc<Zero, f>>)(object)zero5, default(f), zero6));
		}

		public static (a, b, c, d, e, f, g) Zero<a, b, c, d, e, f, g>((a, b, c, d, e, f, g) _arg1, Zero _arg2)
		{
			Zero zero = null;
			if (false)
			{
				a item = (a)(object)null;
				zero = null;
				if (false)
				{
					b item2 = (b)(object)null;
					zero = null;
					if (false)
					{
						c item3 = (c)(object)null;
						zero = null;
						if (false)
						{
							d item4 = (d)(object)null;
							zero = null;
							if (false)
							{
								e item5 = (e)(object)null;
								zero = null;
								if (false)
								{
									f item6 = (f)(object)null;
									zero = null;
									if (0 == 0)
									{
										throw new NotSupportedException("Dynamic invocation of Zero is not supported");
									}
									return ValueTuple.Create(item, item2, item3, item4, item5, item6, (g)(object)null);
								}
								throw new NotSupportedException("Dynamic invocation of Zero is not supported");
							}
							throw new NotSupportedException("Dynamic invocation of Zero is not supported");
						}
						throw new NotSupportedException("Dynamic invocation of Zero is not supported");
					}
					throw new NotSupportedException("Dynamic invocation of Zero is not supported");
				}
				throw new NotSupportedException("Dynamic invocation of Zero is not supported");
			}
			throw new NotSupportedException("Dynamic invocation of Zero is not supported");
		}

		public static (a, b, c, d, e, f, g) Zero$W<a, b, c, d, e, f, g>(FSharpFunc<a, FSharpFunc<Zero, a>> zero, FSharpFunc<b, FSharpFunc<Zero, b>> zero1, FSharpFunc<c, FSharpFunc<Zero, c>> zero2, FSharpFunc<d, FSharpFunc<Zero, d>> zero3, FSharpFunc<e, FSharpFunc<Zero, e>> zero4, FSharpFunc<f, FSharpFunc<Zero, f>> zero5, FSharpFunc<g, FSharpFunc<Zero, g>> zero6, (a, b, c, d, e, f, g) _arg1, Zero _arg2)
		{
			Zero zero7 = null;
			a item = FSharpFunc<a, FSharpPlus.Control.Zero>.InvokeFast<a>(zero, default(a), zero7);
			zero7 = null;
			b item2 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<b>((FSharpFunc<?, FSharpFunc<Zero, b>>)(object)zero1, default(b), zero7);
			zero7 = null;
			c item3 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<c>((FSharpFunc<?, FSharpFunc<Zero, c>>)(object)zero2, default(c), zero7);
			zero7 = null;
			d item4 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<d>((FSharpFunc<?, FSharpFunc<Zero, d>>)(object)zero3, default(d), zero7);
			zero7 = null;
			e item5 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<e>((FSharpFunc<?, FSharpFunc<Zero, e>>)(object)zero4, default(e), zero7);
			zero7 = null;
			f item6 = FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<f>((FSharpFunc<?, FSharpFunc<Zero, f>>)(object)zero5, default(f), zero7);
			zero7 = null;
			return ValueTuple.Create(item, item2, item3, item4, item5, item6, FSharpFunc<?, FSharpPlus.Control.Zero>.InvokeFast<g>((FSharpFunc<?, FSharpFunc<Zero, g>>)(object)zero6, default(g), zero7));
		}

		public static Task<a> Zero<a>(Task<a> _arg1, Zero _arg2)
		{
			Zero zero = null;
			if (0 == 0)
			{
				throw new NotSupportedException("Dynamic invocation of Zero is not supported");
			}
			a result = (a)(object)null;
			TaskCompletionSource<a> taskCompletionSource = new TaskCompletionSource<a>();
			taskCompletionSource.SetResult(result);
			return taskCompletionSource.Task;
		}

		public static Task<a> Zero$W<a>(FSharpFunc<a, FSharpFunc<Zero, a>> zero, Task<a> _arg1, Zero _arg2)
		{
			Zero zero2 = null;
			a result = FSharpFunc<a, FSharpPlus.Control.Zero>.InvokeFast<a>(zero, default(a), zero2);
			TaskCompletionSource<a> taskCompletionSource = new TaskCompletionSource<a>();
			taskCompletionSource.SetResult(result);
			return taskCompletionSource.Task;
		}

		public static ValueTask<a> Zero<a>(ValueTask<a> _arg3, Zero _arg4)
		{
			Zero zero = null;
			if (0 == 0)
			{
				throw new NotSupportedException("Dynamic invocation of Zero is not supported");
			}
			a result = (a)(object)null;
			return new ValueTask<a>(result);
		}

		public static ValueTask<a> Zero$W<a>(FSharpFunc<a, FSharpFunc<Zero, a>> zero, ValueTask<a> _arg3, Zero _arg4)
		{
			Zero zero2 = null;
			a result = FSharpFunc<a, FSharpPlus.Control.Zero>.InvokeFast<a>(zero, default(a), zero2);
			return new ValueTask<a>(result);
		}

		public static FSharpFunc<T, Monoid> Zero<T, Monoid>(FSharpFunc<T, Monoid> _arg5, Zero _arg6)
		{
			return $Numeric.Zero@201<T, Monoid>.@_instance;
		}

		public static FSharpFunc<T, Monoid> Zero$W<T, Monoid>(FSharpFunc<Monoid, FSharpFunc<Zero, Monoid>> zero, FSharpFunc<T, Monoid> _arg5, Zero _arg6)
		{
			return new $Numeric.Zero@201-1<T, Monoid>(zero);
		}

		public static FSharpAsync<a> Zero<a>(FSharpAsync<a> _arg7, Zero _arg8)
		{
			Zero zero = null;
			if (0 == 0)
			{
				throw new NotSupportedException("Dynamic invocation of Zero is not supported");
			}
			a v = (a)(object)null;
			return AsyncPrimitives.MakeAsync<a>((FSharpFunc<AsyncActivation<a>, AsyncReturn>)new $Numeric.Zero@202-2<a>(v));
		}

		public static FSharpAsync<a> Zero$W<a>(FSharpFunc<a, FSharpFunc<Zero, a>> zero, FSharpAsync<a> _arg7, Zero _arg8)
		{
			Zero zero2 = null;
			a v = FSharpFunc<a, FSharpPlus.Control.Zero>.InvokeFast<a>(zero, default(a), zero2);
			return AsyncPrimitives.MakeAsync<a>((FSharpFunc<AsyncActivation<a>, AsyncReturn>)new $Numeric.Zero@202-3<a>(zero, v));
		}

		public static FSharpExpr<a> Zero<a>(FSharpExpr<a> _arg9, Zero _arg10)
		{
			Zero zero = null;
			if (0 == 0)
			{
				throw new NotSupportedException("Dynamic invocation of Zero is not supported");
			}
			a val = (a)(object)null;
			return FSharpExpr.Cast<a>(FSharpExpr.Value<a>(val));
		}

		public static FSharpExpr<a> Zero$W<a>(FSharpFunc<a, FSharpFunc<Zero, a>> zero, FSharpExpr<a> _arg9, Zero _arg10)
		{
			Zero zero2 = null;
			a val = FSharpFunc<a, FSharpPlus.Control.Zero>.InvokeFast<a>(zero, default(a), zero2);
			return FSharpExpr.Cast<a>(FSharpExpr.Value<a>(val));
		}

		public static Lazy<a> Zero<a>(Lazy<a> _arg11, Zero _arg12)
		{
			Zero zero = null;
			if (0 == 0)
			{
				throw new NotSupportedException("Dynamic invocation of Zero is not supported");
			}
			a v = (a)(object)null;
			return LazyExtensions.Create<a>((FSharpFunc<Unit, a>)new $Numeric.Zero@206-4<a>(v));
		}

		public static Lazy<a> Zero$W<a>(FSharpFunc<a, FSharpFunc<Zero, a>> zero, Lazy<a> _arg11, Zero _arg12)
		{
			Zero zero2 = null;
			a v = FSharpFunc<a, FSharpPlus.Control.Zero>.InvokeFast<a>(zero, default(a), zero2);
			return LazyExtensions.Create<a>((FSharpFunc<Unit, a>)new $Numeric.Zero@206-5<a>(zero, v));
		}

		public static Dictionary<a, b> Zero<a, b>(Dictionary<a, b> _arg13, Zero _arg14)
		{
			return new Dictionary<a, b>();
		}

		public static List<a> Zero<a>(List<a> _arg15, Zero _arg16)
		{
			return new List<a>();
		}

		public static R Zero<R>(R _arg1, Default6 _arg2)
		{
			FromInt64 item = null;
			return FSharpFunc<Tuple<FromInt64, R>, long>.InvokeFast<R>((FSharpFunc<Tuple<FromInt64, R>, FSharpFunc<long, R>>)$Numeric.Zero@211-6<R>.@_instance, new Tuple<FromInt64, R>(item, default(R)), 0L);
		}

		public static R Zero$W<R>(FSharpFunc<R, FSharpFunc<FromInt64, FSharpFunc<long, R>>> fromInt64, R _arg1, Default6 _arg2)
		{
			FromInt64 item = null;
			return FSharpFunc<Tuple<FromInt64, R>, long>.InvokeFast<R>((FSharpFunc<Tuple<FromInt64, R>, FSharpFunc<long, R>>)new $Numeric.Zero@211-7<R>(fromInt64), new Tuple<FromInt64, R>(item, default(R)), 0L);
		}

		public static R Zero<R>(R _arg3, Default5 _arg4)
		{
			throw new NotSupportedException("Dynamic invocation of op_Implicit is not supported");
		}

		public static R Zero$W<R>(FSharpFunc<int, R> op_Implicit, R _arg3, Default5 _arg4)
		{
			return op_Implicit.Invoke(0);
		}

		public static IEnumerable<a> Zero<a>(IEnumerable<a> _arg5, Default4 _arg6)
		{
			return SeqModule.Empty<a>();
		}

		public static IEnumerator<a> Zero<a>(IEnumerator<a> _arg7, Default4 _arg8)
		{
			return new Enumerator.EmptyEnumerator<a>();
		}

		public static IDictionary<a, b> Zero<a, b>(IDictionary<a, b> _arg9, Default4 _arg10)
		{
			return new Dictionary<a, b>();
		}

		public static IReadOnlyDictionary<a, b> Zero<a, b>(IReadOnlyDictionary<a, b> _arg11, Default4 _arg12)
		{
			return new Dictionary<a, b>();
		}

		public static t Zero<t>(t _arg13, Default3 _arg14)
		{
			throw new NotSupportedException("Dynamic invocation of get_Empty is not supported");
		}

		public static t Zero$W<t>(FSharpFunc<Unit, t> get_Empty, t _arg13, Default3 _arg14)
		{
			return get_Empty.Invoke((Unit)null);
		}

		public static t Zero<t>(t _arg15, Default2 _arg16)
		{
			throw new NotSupportedException("Dynamic invocation of FromInt32 is not supported");
		}

		public static t Zero$W<t>(FSharpFunc<int, t> fromInt32, t _arg15, Default2 _arg16)
		{
			return fromInt32.Invoke(0);
		}

		public static FSharpFunc<a, a> Zero<t, a>(t _arg17, Default2 _arg18) where t : class
		{
			return $Numeric.Zero@222-8<a>.@_instance;
		}

		public static t Zero<t>(t _arg19, Default1 _arg20)
		{
			return LanguagePrimitives.GenericZeroDynamic<t>();
		}

		public static t Zero$W<t>(FSharpFunc<Unit, t> get_Zero, t _arg19, Default1 _arg20)
		{
			return get_Zero.Invoke((Unit)null);
		}

		public static FSharpFunc<a, a> Zero<t, a>(t _arg21, Default1 _arg22) where t : class
		{
			return $Numeric.Zero@225-9<a>.@_instance;
		}
	}
	[Serializable]
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	public class Abs : Default1
	{
		public static t Abs<t, u>(t x, Default2 _arg1)
		{
			if (0 == 0)
			{
				throw new NotSupportedException("Dynamic invocation of Abs is not supported");
			}
			u val = (u)(object)null;
			Explicit item = null;
			return FSharpFunc<Tuple<Explicit, t>, ?>.InvokeFast<t>((FSharpFunc<Tuple<Explicit, t>, FSharpFunc<?, t>>)(object)$Numeric.Abs@231<t, u>.@_instance, new Tuple<Explicit, t>(item, default(t)), val);
		}

		public static t Abs$W<t, u>(FSharpFunc<t, u> abs, FSharpFunc<t, FSharpFunc<Explicit, FSharpFunc<u, t>>> @explicit, t x, Default2 _arg1)
		{
			u val = abs.Invoke(x);
			Explicit item = null;
			return FSharpFunc<Tuple<Explicit, t>, ?>.InvokeFast<t>((FSharpFunc<Tuple<Explicit, t>, FSharpFunc<?, t>>)(object)new $Numeric.Abs@231-1<t, u>(abs, @explicit), new Tuple<Explicit, t>(item, default(t)), val);
		}

		public static t Abs<t, u>(t x, Default1 _arg2)
		{
			throw new NotSupportedException("Dynamic invocation of op_Implicit is not supported");
		}

		public static t Abs$W<t, u>(FSharpFunc<t, u> abs, FSharpFunc<u, t> op_Implicit, t x, Default1 _arg2)
		{
			return op_Implicit.Invoke(abs.Invoke(x));
		}

		public static t Abs<t>(t x, Abs _arg3)
		{
			return OperatorIntrinsics.AbsDynamic<t>(x);
		}

		public static t Abs$W<t>(FSharpFunc<t, t> abs, t x, Abs _arg3)
		{
			return abs.Invoke(x);
		}

		public static FSharpFunc<a, R> Abs<a, R>(Default1 _arg4, Abs _arg5)
		{
			return $Numeric.Abs@234-2<a, R>.@_instance;
		}

		public static FSharpFunc<a, R> Abs$W<a, R>(FSharpFunc<a, R> abs, Default1 _arg4, Abs _arg5)
		{
			return new $Numeric.Abs@234-3<a, R>(abs);
		}

		public static Num Invoke<Num>(Num x)
		{
			throw new NotSupportedException("Dynamic invocation of Abs is not supported");
		}

		public static Num Invoke$W<Num>(FSharpFunc<Num, FSharpFunc<Abs, Num>> abs, Num x)
		{
			return FSharpFunc<Num, FSharpPlus.Control.Abs>.InvokeFast<Num>(abs, x, (Abs)null);
		}
	}
	[Serializable]
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	public class Abs' : Abs
	{
		public static byte Abs(byte x, Abs' _arg1)
		{
			return x;
		}

		public static ushort Abs(ushort x, Abs' _arg2)
		{
			return x;
		}

		public static uint Abs(uint x, Abs' _arg3)
		{
			return x;
		}

		public static ulong Abs(ulong x, Abs' _arg4)
		{
			return x;
		}

		public static UIntPtr Abs(UIntPtr x, Abs' _arg5)
		{
			return x;
		}

		public new static Num Invoke<Num>(Num x)
		{
			throw new NotSupportedException("Dynamic invocation of Abs is not supported");
		}

		public static Num Invoke$W<Num>(FSharpFunc<Num, FSharpFunc<Abs', Num>> abs, Num x)
		{
			return FSharpFunc<Num, Abs'>.InvokeFast<Num>(abs, x, (Abs')null);
		}
	}
	[Serializable]
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	public class Signum : Default1
	{
		public static t Signum<t>(t x, Default2 _arg1)
		{
			Zero zero = null;
			if (0 == 0)
			{
				throw new NotSupportedException("Dynamic invocation of Zero is not supported");
			}
			t val = (t)(object)null;
			if (HashCompare.GenericEqualityIntrinsic<t>(x, val))
			{
				return val;
			}
			if (0 == 0)
			{
				throw new NotSupportedException("Dynamic invocation of Abs is not supported");
			}
			t val2 = (t)(object)null;
			return LanguagePrimitives.DivisionDynamic<t, t, t>(x, val2);
		}

		public static t Signum$W<t>(FSharpFunc<t, FSharpFunc<Abs, t>> abs, FSharpFunc<t, FSharpFunc<Zero, t>> zero, FSharpFunc<t, FSharpFunc<t, t>> op_Division, t x, Default2 _arg1)
		{
			Zero zero2 = null;
			t val = FSharpFunc<t, Zero>.InvokeFast<t>(zero, default(t), zero2);
			if (HashCompare.GenericEqualityIntrinsic<t>(x, val))
			{
				return val;
			}
			t val2 = FSharpFunc<t, Abs>.InvokeFast<t>(abs, x, (Abs)null);
			return FSharpFunc<t, t>.InvokeFast<t>(op_Division, x, val2);
		}

		public static FSharpFunc<a, a> Signum<t, a>(t _arg2, Default1 _arg3) where t : class
		{
			return $Numeric.Signum@263<a>.@_instance;
		}

		public static t Signum<t>(t x, Default1 _arg4)
		{
			int num = OperatorIntrinsics.SignDynamic<t>(x);
			FromInt32 item = null;
			return FSharpFunc<Tuple<FromInt32, t>, int>.InvokeFast<t>((FSharpFunc<Tuple<FromInt32, t>, FSharpFunc<int, t>>)$Numeric.Signum@264-1<t>.@_instance, new Tuple<FromInt32, t>(item, default(t)), num);
		}

		public static t Signum$W<t>(FSharpFunc<t, FSharpFunc<FromInt32, FSharpFunc<int, t>>> fromInt32, FSharpFunc<t, int> get_Sign, t x, Default1 _arg4)
		{
			int num = get_Sign.Invoke(x);
			FromInt32 item = null;
			return FSharpFunc<Tuple<FromInt32, t>, int>.InvokeFast<t>((FSharpFunc<Tuple<FromInt32, t>, FSharpFunc<int, t>>)new $Numeric.Signum@264-2<t>(fromInt32, get_Sign), new Tuple<FromInt32, t>(item, default(t)), num);
		}

		public static Num Invoke<Num>(Num x)
		{
			throw new NotSupportedException("Dynamic invocation of Signum is not supported");
		}

		public static Num Invoke$W<Num>(FSharpFunc<Num, FSharpFunc<Signum, Num>> signum, Num x)
		{
			return FSharpFunc<Num, FSharpPlus.Control.Signum>.InvokeFast<Num>(signum, x, (Signum)null);
		}
	}
	[Serializable]
	[CompilationMapping(/*Could not decode attribute arguments.*/)]
	public class Signum' : Signum
	{
		public static byte Signum(byte x, Signum' _arg1)
		{
			if (x == 0)
			{
				return 0;
			}
			return 1;
		}

		public static ushort Signum(ushort x, Signum' _arg2)
		{
			if (x == 0)
			{
				re