using System;
using System.Buffers;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.Contracts;
using System.Globalization;
using System.Linq;
using System.Linq.Expressions;
using System.Net;
using System.Numerics;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.ExceptionServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using LanguageExt;
using LanguageExt.Attributes;
using LanguageExt.ClassInstances;
using LanguageExt.ClassInstances.Const;
using LanguageExt.ClassInstances.Pred;
using LanguageExt.Common;
using LanguageExt.DataTypes.Serialisation;
using LanguageExt.Effects.Traits;
using LanguageExt.Pipes;
using LanguageExt.TypeClasses;
using LanguageExt.UnitsOfMeasure;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("Paul Louth")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright (c) Paul Louth. All rights reserved.")]
[assembly: AssemblyDescription("This library uses and abuses the features of C# to provide a functional 'Base class library', that, if you squint, can look like extensions to the language itself.")]
[assembly: AssemblyFileVersion("4.4.5.0")]
[assembly: AssemblyInformationalVersion("4.4.5-dev.5+d8167ed3491f17e813ed9e9422b0384b15b2982d")]
[assembly: AssemblyProduct("LanguageExt.Core")]
[assembly: AssemblyTitle("LanguageExt.Core")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/Lordfirespeed/LanguageExtThunderstore")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("4.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsByRefLikeAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
public static class CompositionsExt
{
	public static Compositions<A> Cons<MonoidA, A>(this A a, Compositions<A> ma) where MonoidA : struct, Monoid<A>
	{
		return Compositions.cons<MonoidA, A>(a, ma);
	}
}
public static class Tuple1Extensions
{
	[Pure]
	public static Tuple<A, B> Add<A, B>(this Tuple<A> self, B second)
	{
		return Prelude.Tuple(self.Item1, second);
	}

	[Pure]
	public static Tuple<A> Append<SemiA, A>(this Tuple<A> a, Tuple<A> b) where SemiA : struct, Semigroup<A>
	{
		return Prelude.Tuple(default(SemiA).Append(a.Item1, b.Item1));
	}

	[Pure]
	public static Tuple<A> Concat<MonoidA, A>(this Tuple<A> a, Tuple<A> b) where MonoidA : struct, Monoid<A>
	{
		return Prelude.Tuple(TypeClass.mconcat<MonoidA, A>(new A[2] { a.Item1, b.Item1 }));
	}

	[Pure]
	public static A Head<A>(this Tuple<A> self)
	{
		return self.Item1;
	}

	[Pure]
	public static A Last<A>(this Tuple<A> self)
	{
		return self.Item1;
	}

	[Pure]
	public static A Sum<NUM, A>(this Tuple<A> self) where NUM : struct, Num<A>
	{
		return self.Item1;
	}

	[Pure]
	public static A Product<NUM, A>(this Tuple<A> self) where NUM : struct, Num<A>
	{
		return self.Item1;
	}

	[Pure]
	public static bool Contains<EQ, A>(this Tuple<A> self, A value) where EQ : struct, Eq<A>
	{
		return default(EQ).Equals(self.Item1, value);
	}

	[Pure]
	public static Tuple<R> Map<A, R>(this Tuple<A> self, Func<A, R> map)
	{
		return Prelude.Tuple(map(self.Item1));
	}

	[Pure]
	public static Tuple<R> Select<A, R>(this Tuple<A> self, Func<A, R> map)
	{
		return Prelude.Tuple(map(self.Item1));
	}

	public static Unit Iter<A>(this Tuple<A> self, Action<A> func)
	{
		func(self.Item1);
		return Unit.Default;
	}

	[Pure]
	public static S Fold<A, S>(this Tuple<A> self, S state, Func<S, A, S> fold)
	{
		return fold(state, self.Item1);
	}
}
public static class Tuple2Extensions
{
	[Pure]
	public static Tuple<A, B, C> add<A, B, C>(this Tuple<A, B> self, C third)
	{
		return Prelude.Tuple(self.Item1, self.Item2, third);
	}

	[Pure]
	public static Tuple<A, B> Append<SemiA, SemiB, A, B>(this Tuple<A, B> a, Tuple<A, B> b) where SemiA : struct, Semigroup<A> where SemiB : struct, Semigroup<B>
	{
		return Prelude.Tuple(default(SemiA).Append(a.Item1, b.Item1), default(SemiB).Append(a.Item2, b.Item2));
	}

	[Pure]
	public static A Append<SemiA, A>(this Tuple<A, A> a) where SemiA : struct, Semigroup<A>
	{
		return default(SemiA).Append(a.Item1, a.Item2);
	}

	[Pure]
	public static Tuple<A, B> Concat<MonoidA, MonoidB, A, B>(this Tuple<A, B> a, Tuple<A, B> b) where MonoidA : struct, Monoid<A> where MonoidB : struct, Monoid<B>
	{
		return Prelude.Tuple(TypeClass.mconcat<MonoidA, A>(new A[2] { a.Item1, b.Item1 }), TypeClass.mconcat<MonoidB, B>(new B[2] { a.Item2, b.Item2 }));
	}

	[Pure]
	public static A Concat<MonoidA, A>(this Tuple<A, A> a) where MonoidA : struct, Monoid<A>
	{
		return TypeClass.mconcat<MonoidA, A>(new A[2] { a.Item1, a.Item2 });
	}

	[Pure]
	public static T1 Head<T1, T2>(this Tuple<T1, T2> self)
	{
		return self.Item1;
	}

	[Pure]
	public static T2 Last<T1, T2>(this Tuple<T1, T2> self)
	{
		return self.Item2;
	}

	[Pure]
	public static Tuple<T2> Tail<T1, T2>(this Tuple<T1, T2> self)
	{
		return Prelude.Tuple(self.Item2);
	}

	[Pure]
	public static A Sum<NUM, A>(this Tuple<A, A> self) where NUM : struct, Num<A>
	{
		return TypeClass.sum<NUM, FoldTuple<A>, Tuple<A, A>, A>(self);
	}

	[Pure]
	public static A Product<NUM, A>(this Tuple<A, A> self) where NUM : struct, Num<A>
	{
		return TypeClass.product<NUM, FoldTuple<A>, Tuple<A, A>, A>(self);
	}

	[Pure]
	public static bool Contains<EQ, A>(this Tuple<A, A> self, A value) where EQ : struct, Eq<A>
	{
		return TypeClass.contains<EQ, FoldTuple<A>, Tuple<A, A>, A>(self, value);
	}

	[Pure]
	public static R Map<T1, T2, R>(this Tuple<T1, T2> self, Func<T1, T2, R> map)
	{
		return map(self.Item1, self.Item2);
	}

	[Pure]
	public static R Map<A, B, R>(this Tuple<A, B> self, Func<Tuple<A, B>, R> map)
	{
		return map(self);
	}

	[Pure]
	public static Tuple<Y, Z> Map<A, B, Y, Z>(this Tuple<A, B> self, Func<A, B, Tuple<Y, Z>> map)
	{
		return map(self.Item1, self.Item2);
	}

	[Pure]
	public static Tuple<R1, R2> Map<T1, T2, R1, R2>(this Tuple<T1, T2> self, Func<Tuple<T1, T2>, Tuple<R1, R2>> map)
	{
		return map(self);
	}

	[Pure]
	public static Tuple<R1, R2> BiMap<T1, T2, R1, R2>(this Tuple<T1, T2> self, Func<T1, R1> firstMap, Func<T2, R2> secondMap)
	{
		return Prelude.Tuple(firstMap(self.Item1), secondMap(self.Item2));
	}

	[Pure]
	public static Tuple<R1, T2> MapFirst<T1, T2, R1>(this Tuple<T1, T2> self, Func<T1, R1> firstMap)
	{
		return Prelude.Tuple(firstMap(self.Item1), self.Item2);
	}

	[Pure]
	public static Tuple<T1, R2> MapSecond<T1, T2, R2>(this Tuple<T1, T2> self, Func<T2, R2> secondMap)
	{
		return Prelude.Tuple(self.Item1, secondMap(self.Item2));
	}

	[Pure]
	public static Tuple<R1, R2> Select<T1, T2, R1, R2>(this Tuple<T1, T2> self, Func<Tuple<T1, T2>, Tuple<R1, R2>> map)
	{
		return map(self);
	}

	public static Unit Iter<T1, T2>(this Tuple<T1, T2> self, Action<T1, T2> func)
	{
		func(self.Item1, self.Item2);
		return Unit.Default;
	}

	public static Unit Iter<T1, T2>(this Tuple<T1, T2> self, Action<T1> first, Action<T2> second)
	{
		first(self.Item1);
		second(self.Item2);
		return Unit.Default;
	}

	[Pure]
	public static S Fold<T1, T2, S>(this Tuple<T1, T2> self, S state, Func<S, T1, T2, S> fold)
	{
		return fold(state, self.Item1, self.Item2);
	}

	[Pure]
	public static S BiFold<T1, T2, S>(this Tuple<T1, T2> self, S state, Func<S, T1, S> firstFold, Func<S, T2, S> secondFold)
	{
		return secondFold(firstFold(state, self.Item1), self.Item2);
	}

	[Pure]
	public static S BiFoldBack<T1, T2, S>(this Tuple<T1, T2> self, S state, Func<S, T2, S> firstFold, Func<S, T1, S> secondFold)
	{
		return secondFold(firstFold(state, self.Item2), self.Item1);
	}
}
public static class Tuple3Extensions
{
	[Pure]
	public static Tuple<T1, T2, T3, T4> Add<T1, T2, T3, T4>(this Tuple<T1, T2, T3> self, T4 fourth)
	{
		return Prelude.Tuple(self.Item1, self.Item2, self.Item3, fourth);
	}

	[Pure]
	public static Tuple<A, B, C> Append<SemiA, SemiB, SemiC, A, B, C>(this Tuple<A, B, C> a, Tuple<A, B, C> b) where SemiA : struct, Semigroup<A> where SemiB : struct, Semigroup<B> where SemiC : struct, Semigroup<C>
	{
		return Prelude.Tuple(default(SemiA).Append(a.Item1, b.Item1), default(SemiB).Append(a.Item2, b.Item2), default(SemiC).Append(a.Item3, b.Item3));
	}

	[Pure]
	public static A Append<SemiA, A>(this Tuple<A, A, A> a) where SemiA : struct, Semigroup<A>
	{
		return default(SemiA).Append(a.Item1, default(SemiA).Append(a.Item2, a.Item3));
	}

	[Pure]
	public static Tuple<A, B, C> Concat<MonoidA, MonoidB, MonoidC, A, B, C>(this Tuple<A, B, C> a, Tuple<A, B, C> b) where MonoidA : struct, Monoid<A> where MonoidB : struct, Monoid<B> where MonoidC : struct, Monoid<C>
	{
		return Prelude.Tuple(TypeClass.mconcat<MonoidA, A>(new A[2] { a.Item1, b.Item1 }), TypeClass.mconcat<MonoidB, B>(new B[2] { a.Item2, b.Item2 }), TypeClass.mconcat<MonoidC, C>(new C[2] { a.Item3, b.Item3 }));
	}

	[Pure]
	public static A Concat<MonoidA, A>(this Tuple<A, A, A> a) where MonoidA : struct, Monoid<A>
	{
		return TypeClass.mconcat<MonoidA, A>(new A[3] { a.Item1, a.Item2, a.Item3 });
	}

	[Pure]
	public static T1 Head<T1, T2, T3>(this Tuple<T1, T2, T3> self)
	{
		return self.Item1;
	}

	[Pure]
	public static T3 Last<T1, T2, T3>(this Tuple<T1, T2, T3> self)
	{
		return self.Item3;
	}

	[Pure]
	public static Tuple<T2, T3> Tail<T1, T2, T3>(this Tuple<T1, T2, T3> self)
	{
		return Prelude.Tuple(self.Item2, self.Item3);
	}

	[Pure]
	public static A Sum<NUM, A>(this Tuple<A, A, A> self) where NUM : struct, Num<A>
	{
		return default(NUM).Plus(self.Item1, default(NUM).Plus(self.Item2, self.Item3));
	}

	[Pure]
	public static A Product<NUM, A>(this Tuple<A, A, A> self) where NUM : struct, Num<A>
	{
		return default(NUM).Product(self.Item1, default(NUM).Product(self.Item2, self.Item3));
	}

	[Pure]
	public static bool Contains<EQ, A>(this Tuple<A, A, A> self, A value) where EQ : struct, Eq<A>
	{
		if (!default(EQ).Equals(self.Item1, value) && !default(EQ).Equals(self.Item2, value))
		{
			return default(EQ).Equals(self.Item3, value);
		}
		return true;
	}

	[Pure]
	public static R Map<A, B, C, R>(this Tuple<A, B, C> self, Func<Tuple<A, B, C>, R> map)
	{
		return map(self);
	}

	[Pure]
	public static R Map<A, B, C, R>(this Tuple<A, B, C> self, Func<A, B, C, R> map)
	{
		return map(self.Item1, self.Item2, self.Item3);
	}

	[Pure]
	public static Tuple<X, Y, Z> Map<A, B, C, X, Y, Z>(this Tuple<A, B, C> self, Func<A, B, C, Tuple<X, Y, Z>> map)
	{
		return map(self.Item1, self.Item2, self.Item3);
	}

	[Pure]
	public static Tuple<R1, R2, R3> Map<T1, T2, T3, R1, R2, R3>(this Tuple<T1, T2, T3> self, Func<T1, R1> firstMap, Func<T2, R2> secondMap, Func<T3, R3> thirdMap)
	{
		return Prelude.Tuple(firstMap(self.Item1), secondMap(self.Item2), thirdMap(self.Item3));
	}

	[Pure]
	public static Tuple<R1, T2, T3> MapFirst<T1, T2, T3, R1>(this Tuple<T1, T2, T3> self, Func<T1, R1> firstMap)
	{
		return Prelude.Tuple(firstMap(self.Item1), self.Item2, self.Item3);
	}

	[Pure]
	public static Tuple<T1, R2, T3> MapSecond<T1, T2, T3, R2>(this Tuple<T1, T2, T3> self, Func<T2, R2> secondMap)
	{
		return Prelude.Tuple(self.Item1, secondMap(self.Item2), self.Item3);
	}

	[Pure]
	public static Tuple<T1, T2, R3> MapThird<T1, T2, T3, R3>(this Tuple<T1, T2, T3> self, Func<T3, R3> thirdMap)
	{
		return Prelude.Tuple(self.Item1, self.Item2, thirdMap(self.Item3));
	}

	[Pure]
	public static Tuple<R1, R2, R3> Select<T1, T2, T3, R1, R2, R3>(this Tuple<T1, T2, T3> self, Func<Tuple<T1, T2, T3>, Tuple<R1, R2, R3>> map)
	{
		return map(self);
	}

	public static Unit Iter<T1, T2, T3>(this Tuple<T1, T2, T3> self, Action<T1, T2, T3> func)
	{
		func(self.Item1, self.Item2, self.Item3);
		return Unit.Default;
	}

	public static Unit Iter<T1, T2, T3>(this Tuple<T1, T2, T3> self, Action<T1> first, Action<T2> second, Action<T3> third)
	{
		first(self.Item1);
		second(self.Item2);
		third(self.Item3);
		return Unit.Default;
	}

	[Pure]
	public static S Fold<T1, T2, T3, S>(this Tuple<T1, T2, T3> self, S state, Func<S, T1, T2, T3, S> fold)
	{
		return fold(state, self.Item1, self.Item2, self.Item3);
	}

	[Pure]
	public static S TriFold<T1, T2, T3, S>(this Tuple<T1, T2, T3> self, S state, Func<S, T1, S> firstFold, Func<S, T2, S> secondFold, Func<S, T3, S> thirdFold)
	{
		return thirdFold(secondFold(firstFold(state, self.Item1), self.Item2), self.Item3);
	}

	[Pure]
	public static S TriFoldBack<T1, T2, T3, S>(this Tuple<T1, T2, T3> self, S state, Func<S, T3, S> firstFold, Func<S, T2, S> secondFold, Func<S, T1, S> thirdFold)
	{
		return thirdFold(secondFold(firstFold(state, self.Item3), self.Item2), self.Item1);
	}
}
public static class Tuple4Extensions
{
	[Pure]
	public static Tuple<A, B, C, D, E> Add<A, B, C, D, E>(this Tuple<A, B, C, D> self, E fifth)
	{
		return Prelude.Tuple(self.Item1, self.Item2, self.Item3, self.Item4, fifth);
	}

	[Pure]
	public static Tuple<A, B, C, D> Append<SemiA, SemiB, SemiC, SemiD, A, B, C, D>(this Tuple<A, B, C, D> a, Tuple<A, B, C, D> b) where SemiA : struct, Semigroup<A> where SemiB : struct, Semigroup<B> where SemiC : struct, Semigroup<C> where SemiD : struct, Semigroup<D>
	{
		return Prelude.Tuple(default(SemiA).Append(a.Item1, b.Item1), default(SemiB).Append(a.Item2, b.Item2), default(SemiC).Append(a.Item3, b.Item3), default(SemiD).Append(a.Item4, b.Item4));
	}

	[Pure]
	public static A Append<SemiA, A>(this Tuple<A, A, A, A> a) where SemiA : struct, Semigroup<A>
	{
		return default(SemiA).Append(a.Item1, default(SemiA).Append(a.Item2, default(SemiA).Append(a.Item3, a.Item4)));
	}

	[Pure]
	public static Tuple<A, B, C, D> Concat<MonoidA, MonoidB, MonoidC, MonoidD, A, B, C, D>(this Tuple<A, B, C, D> a, Tuple<A, B, C, D> b) where MonoidA : struct, Monoid<A> where MonoidB : struct, Monoid<B> where MonoidC : struct, Monoid<C> where MonoidD : struct, Monoid<D>
	{
		return Prelude.Tuple(TypeClass.mconcat<MonoidA, A>(new A[2] { a.Item1, b.Item1 }), TypeClass.mconcat<MonoidB, B>(new B[2] { a.Item2, b.Item2 }), TypeClass.mconcat<MonoidC, C>(new C[2] { a.Item3, b.Item3 }), TypeClass.mconcat<MonoidD, D>(new D[2] { a.Item4, b.Item4 }));
	}

	[Pure]
	public static A Concat<MonoidA, A>(this Tuple<A, A, A, A> a) where MonoidA : struct, Monoid<A>
	{
		return TypeClass.mconcat<MonoidA, A>(new A[4] { a.Item1, a.Item2, a.Item3, a.Item4 });
	}

	[Pure]
	public static A Head<A, B, C, D>(this Tuple<A, B, C, D> self)
	{
		return self.Item1;
	}

	[Pure]
	public static D Last<A, B, C, D>(this Tuple<A, B, C, D> self)
	{
		return self.Item4;
	}

	[Pure]
	public static Tuple<B, C, D> Tail<A, B, C, D>(this Tuple<A, B, C, D> self)
	{
		return Prelude.Tuple(self.Item2, self.Item3, self.Item4);
	}

	[Pure]
	public static A Sum<NUM, A>(this Tuple<A, A, A, A> self) where NUM : struct, Num<A>
	{
		return TypeClass.sum<NUM, FoldTuple<A>, Tuple<A, A, A, A>, A>(self);
	}

	[Pure]
	public static A Product<NUM, A>(this Tuple<A, A, A, A> self) where NUM : struct, Num<A>
	{
		return TypeClass.product<NUM, FoldTuple<A>, Tuple<A, A, A, A>, A>(self);
	}

	[Pure]
	public static bool Contains<EQ, A>(this Tuple<A, A, A, A> self, A value) where EQ : struct, Eq<A>
	{
		if (!default(EQ).Equals(self.Item1, value) && !default(EQ).Equals(self.Item2, value) && !default(EQ).Equals(self.Item3, value))
		{
			return default(EQ).Equals(self.Item4, value);
		}
		return true;
	}

	[Pure]
	public static R Map<A, B, C, D, R>(this Tuple<A, B, C, D> self, Func<Tuple<A, B, C, D>, R> map)
	{
		return map(self);
	}

	[Pure]
	public static R Map<A, B, C, D, R>(this Tuple<A, B, C, D> self, Func<A, B, C, D, R> map)
	{
		return map(self.Item1, self.Item2, self.Item3, self.Item4);
	}

	[Pure]
	public static Tuple<W, X, Y, Z> Map<A, B, C, D, W, X, Y, Z>(this Tuple<A, B, C, D> self, Func<A, W> firstMap, Func<B, X> secondMap, Func<C, Y> thirdMap, Func<D, Z> fourthMap)
	{
		return Prelude.Tuple(firstMap(self.Item1), secondMap(self.Item2), thirdMap(self.Item3), fourthMap(self.Item4));
	}

	[Pure]
	public static Tuple<R1, B, C, D> MapFirst<A, B, C, D, R1>(this Tuple<A, B, C, D> self, Func<A, R1> firstMap)
	{
		return Prelude.Tuple(firstMap(self.Item1), self.Item2, self.Item3, self.Item4);
	}

	[Pure]
	public static Tuple<A, R2, C, D> MapSecond<A, B, C, D, R2>(this Tuple<A, B, C, D> self, Func<B, R2> secondMap)
	{
		return Prelude.Tuple(self.Item1, secondMap(self.Item2), self.Item3, self.Item4);
	}

	[Pure]
	public static Tuple<A, B, R3, D> MapThird<A, B, C, D, R3>(this Tuple<A, B, C, D> self, Func<C, R3> thirdMap)
	{
		return Prelude.Tuple(self.Item1, self.Item2, thirdMap(self.Item3), self.Item4);
	}

	[Pure]
	public static Tuple<A, B, C, R4> MapFourth<A, B, C, D, R4>(this Tuple<A, B, C, D> self, Func<D, R4> fourthMap)
	{
		return Prelude.Tuple(self.Item1, self.Item2, self.Item3, fourthMap(self.Item4));
	}

	[Pure]
	public static Tuple<W, X, Y, Z> Select<A, B, C, D, W, X, Y, Z>(this Tuple<A, B, C, D> self, Func<Tuple<A, B, C, D>, Tuple<W, X, Y, Z>> map)
	{
		return map(self);
	}

	public static Unit Iter<A, B, C, D>(this Tuple<A, B, C, D> self, Action<A, B, C, D> func)
	{
		func(self.Item1, self.Item2, self.Item3, self.Item4);
		return Unit.Default;
	}

	public static Unit Iter<A, B, C, D>(this Tuple<A, B, C, D> self, Action<A> first, Action<B> second, Action<C> third, Action<D> fourth)
	{
		first(self.Item1);
		second(self.Item2);
		third(self.Item3);
		fourth(self.Item4);
		return Unit.Default;
	}

	[Pure]
	public static S Fold<A, B, C, D, S>(this Tuple<A, B, C, D> self, S state, Func<S, A, B, C, D, S> fold)
	{
		return fold(state, self.Item1, self.Item2, self.Item3, self.Item4);
	}

	[Pure]
	public static S QuadFold<A, B, C, D, S>(this Tuple<A, B, C, D> self, S state, Func<S, A, S> firstFold, Func<S, B, S> secondFold, Func<S, C, S> thirdFold, Func<S, D, S> fourthFold)
	{
		return fourthFold(thirdFold(secondFold(firstFold(state, self.Item1), self.Item2), self.Item3), self.Item4);
	}

	[Pure]
	public static S QuadFoldBack<A, B, C, D, S>(this Tuple<A, B, C, D> self, S state, Func<S, D, S> firstFold, Func<S, C, S> secondFold, Func<S, B, S> thirdFold, Func<S, A, S> fourthFold)
	{
		return fourthFold(thirdFold(secondFold(firstFold(state, self.Item4), self.Item3), self.Item2), self.Item1);
	}
}
public static class Tuple5Extensions
{
	[Pure]
	public static Tuple<A, B, C, D, E, F> Add<A, B, C, D, E, F>(this Tuple<A, B, C, D, E> self, F sixth)
	{
		return Prelude.Tuple(self.Item1, self.Item2, self.Item3, self.Item4, self.Item5, sixth);
	}

	[Pure]
	public static Tuple<A, B, C, D, E> Append<SemiA, SemiB, SemiC, SemiD, SemiE, A, B, C, D, E>(this Tuple<A, B, C, D, E> a, Tuple<A, B, C, D, E> b) where SemiA : struct, Semigroup<A> where SemiB : struct, Semigroup<B> where SemiC : struct, Semigroup<C> where SemiD : struct, Semigroup<D> where SemiE : struct, Semigroup<E>
	{
		return Prelude.Tuple(default(SemiA).Append(a.Item1, b.Item1), default(SemiB).Append(a.Item2, b.Item2), default(SemiC).Append(a.Item3, b.Item3), default(SemiD).Append(a.Item4, b.Item4), default(SemiE).Append(a.Item5, b.Item5));
	}

	[Pure]
	public static A Append<SemiA, A>(this Tuple<A, A, A, A, A> a) where SemiA : struct, Semigroup<A>
	{
		return default(SemiA).Append(a.Item1, default(SemiA).Append(a.Item2, default(SemiA).Append(a.Item3, default(SemiA).Append(a.Item4, a.Item5))));
	}

	[Pure]
	public static Tuple<A, B, C, D, E> Concat<MonoidA, MonoidB, MonoidC, MonoidD, MonoidE, A, B, C, D, E>(this Tuple<A, B, C, D, E> a, Tuple<A, B, C, D, E> b) where MonoidA : struct, Monoid<A> where MonoidB : struct, Monoid<B> where MonoidC : struct, Monoid<C> where MonoidD : struct, Monoid<D> where MonoidE : struct, Monoid<E>
	{
		return Prelude.Tuple(TypeClass.mconcat<MonoidA, A>(new A[2] { a.Item1, b.Item1 }), TypeClass.mconcat<MonoidB, B>(new B[2] { a.Item2, b.Item2 }), TypeClass.mconcat<MonoidC, C>(new C[2] { a.Item3, b.Item3 }), TypeClass.mconcat<MonoidD, D>(new D[2] { a.Item4, b.Item4 }), TypeClass.mconcat<MonoidE, E>(new E[2] { a.Item5, b.Item5 }));
	}

	[Pure]
	public static A Concat<MonoidA, A>(this Tuple<A, A, A, A, A> a) where MonoidA : struct, Monoid<A>
	{
		return TypeClass.mconcat<MonoidA, A>(new A[5] { a.Item1, a.Item2, a.Item3, a.Item4, a.Item5 });
	}

	[Pure]
	public static A Head<A, B, C, D, E>(this Tuple<A, B, C, D, E> self)
	{
		return self.Item1;
	}

	[Pure]
	public static E Last<A, B, C, D, E>(this Tuple<A, B, C, D, E> self)
	{
		return self.Item5;
	}

	[Pure]
	public static Tuple<B, C, D, E> Tail<A, B, C, D, E>(this Tuple<A, B, C, D, E> self)
	{
		return Prelude.Tuple(self.Item2, self.Item3, self.Item4, self.Item5);
	}

	[Pure]
	public static A Sum<NUM, A>(this Tuple<A, A, A, A, A> self) where NUM : struct, Num<A>
	{
		return TypeClass.sum<NUM, FoldTuple<A>, Tuple<A, A, A, A, A>, A>(self);
	}

	[Pure]
	public static A Product<NUM, A>(this Tuple<A, A, A, A, A> self) where NUM : struct, Num<A>
	{
		return TypeClass.product<NUM, FoldTuple<A>, Tuple<A, A, A, A, A>, A>(self);
	}

	[Pure]
	public static bool Contains<EQ, A>(this Tuple<A, A, A, A, A> self, A value) where EQ : struct, Eq<A>
	{
		if (!default(EQ).Equals(self.Item1, value) && !default(EQ).Equals(self.Item2, value) && !default(EQ).Equals(self.Item3, value) && !default(EQ).Equals(self.Item4, value))
		{
			return default(EQ).Equals(self.Item5, value);
		}
		return true;
	}

	[Pure]
	public static R Map<A, B, C, D, E, R>(this Tuple<A, B, C, D, E> self, Func<Tuple<A, B, C, D, E>, R> map)
	{
		return map(self);
	}

	[Pure]
	public static R Map<A, B, C, D, E, R>(this Tuple<A, B, C, D, E> self, Func<A, B, C, D, E, R> map)
	{
		return map(self.Item1, self.Item2, self.Item3, self.Item4, self.Item5);
	}

	[Pure]
	public static Tuple<V, W, X, Y, Z> Map<A, B, C, D, E, V, W, X, Y, Z>(this Tuple<A, B, C, D, E> self, Func<A, B, C, D, E, Tuple<V, W, X, Y, Z>> map)
	{
		return map(self.Item1, self.Item2, self.Item3, self.Item4, self.Item5);
	}

	[Pure]
	public static Tuple<V, W, X, Y, Z> Map<A, B, C, D, E, V, W, X, Y, Z>(this Tuple<A, B, C, D, E> self, Func<A, V> firstMap, Func<B, W> secondMap, Func<C, X> thirdMap, Func<D, Y> fourthMap, Func<E, Z> fifthMap)
	{
		return Prelude.Tuple(firstMap(self.Item1), secondMap(self.Item2), thirdMap(self.Item3), fourthMap(self.Item4), fifthMap(self.Item5));
	}

	[Pure]
	public static Tuple<R1, B, C, D, E> MapFirst<A, B, C, D, E, R1>(this Tuple<A, B, C, D, E> self, Func<A, R1> firstMap)
	{
		return Prelude.Tuple(firstMap(self.Item1), self.Item2, self.Item3, self.Item4, self.Item5);
	}

	[Pure]
	public static Tuple<A, R2, C, D, E> MapSecond<A, B, C, D, E, R2>(this Tuple<A, B, C, D, E> self, Func<B, R2> secondMap)
	{
		return Prelude.Tuple(self.Item1, secondMap(self.Item2), self.Item3, self.Item4, self.Item5);
	}

	[Pure]
	public static Tuple<A, B, R3, D, E> MapThird<A, B, C, D, E, R3>(this Tuple<A, B, C, D, E> self, Func<C, R3> thirdMap)
	{
		return Prelude.Tuple(self.Item1, self.Item2, thirdMap(self.Item3), self.Item4, self.Item5);
	}

	[Pure]
	public static Tuple<A, B, C, R4, E> MapFourth<A, B, C, D, E, R4>(this Tuple<A, B, C, D, E> self, Func<D, R4> fourthMap)
	{
		return Prelude.Tuple(self.Item1, self.Item2, self.Item3, fourthMap(self.Item4), self.Item5);
	}

	[Pure]
	public static Tuple<A, B, C, D, R5> MapFifth<A, B, C, D, E, R5>(this Tuple<A, B, C, D, E> self, Func<E, R5> fifthMap)
	{
		return Prelude.Tuple(self.Item1, self.Item2, self.Item3, self.Item4, fifthMap(self.Item5));
	}

	[Pure]
	public static Tuple<V, W, X, Y, Z> Select<A, B, C, D, E, V, W, X, Y, Z>(this Tuple<A, B, C, D, E> self, Func<Tuple<A, B, C, D, E>, Tuple<V, W, X, Y, Z>> map)
	{
		return map(self);
	}

	public static Unit Iter<A, B, C, D, E>(this Tuple<A, B, C, D, E> self, Action<A, B, C, D, E> func)
	{
		func(self.Item1, self.Item2, self.Item3, self.Item4, self.Item5);
		return Unit.Default;
	}

	public static Unit Iter<A, B, C, D, E>(this Tuple<A, B, C, D, E> self, Action<A> first, Action<B> second, Action<C> third, Action<D> fourth, Action<E> fifth)
	{
		first(self.Item1);
		second(self.Item2);
		third(self.Item3);
		fourth(self.Item4);
		fifth(self.Item5);
		return Unit.Default;
	}

	[Pure]
	public static S Fold<A, B, C, D, E, S>(this Tuple<A, B, C, D, E> self, S state, Func<S, A, B, C, D, E, S> fold)
	{
		return fold(state, self.Item1, self.Item2, self.Item3, self.Item4, self.Item5);
	}

	[Pure]
	public static S QuintFold<A, B, C, D, E, S>(this Tuple<A, B, C, D, E> self, S state, Func<S, A, S> firstFold, Func<S, B, S> secondFold, Func<S, C, S> thirdFold, Func<S, D, S> fourthFold, Func<S, E, S> fifthFold)
	{
		return fifthFold(fourthFold(thirdFold(secondFold(firstFold(state, self.Item1), self.Item2), self.Item3), self.Item4), self.Item5);
	}

	[Pure]
	public static S QuintFoldBack<A, B, C, D, E, S>(this Tuple<A, B, C, D, E> self, S state, Func<S, E, S> firstFold, Func<S, D, S> secondFold, Func<S, C, S> thirdFold, Func<S, B, S> fourthFold, Func<S, A, S> fifthFold)
	{
		return fifthFold(fourthFold(thirdFold(secondFold(firstFold(state, self.Item5), self.Item4), self.Item3), self.Item2), self.Item1);
	}
}
public static class Tuple6Extensions
{
	[Pure]
	public static Tuple<A, B, C, D, E, F, G> Add<A, B, C, D, E, F, G>(this Tuple<A, B, C, D, E, F> self, G seventh)
	{
		return Prelude.Tuple(self.Item1, self.Item2, self.Item3, self.Item4, self.Item5, self.Item6, seventh);
	}

	[Pure]
	public static Tuple<A, B, C, D, E, F> Append<SemiA, SemiB, SemiC, SemiD, SemiE, SemiF, A, B, C, D, E, F>(this Tuple<A, B, C, D, E, F> a, Tuple<A, B, C, D, E, F> b) where SemiA : struct, Semigroup<A> where SemiB : struct, Semigroup<B> where SemiC : struct, Semigroup<C> where SemiD : struct, Semigroup<D> where SemiE : struct, Semigroup<E> where SemiF : struct, Semigroup<F>
	{
		return Prelude.Tuple(default(SemiA).Append(a.Item1, b.Item1), default(SemiB).Append(a.Item2, b.Item2), default(SemiC).Append(a.Item3, b.Item3), default(SemiD).Append(a.Item4, b.Item4), default(SemiE).Append(a.Item5, b.Item5), default(SemiF).Append(a.Item6, b.Item6));
	}

	[Pure]
	public static A Append<SemiA, A>(this Tuple<A, A, A, A, A, A> a) where SemiA : struct, Semigroup<A>
	{
		return default(SemiA).Append(a.Item1, default(SemiA).Append(a.Item2, default(SemiA).Append(a.Item3, default(SemiA).Append(a.Item4, default(SemiA).Append(a.Item5, a.Item6)))));
	}

	[Pure]
	public static Tuple<A, B, C, D, E, F> Concat<MonoidA, MonoidB, MonoidC, MonoidD, MonoidE, MonoidF, A, B, C, D, E, F>(this Tuple<A, B, C, D, E, F> a, Tuple<A, B, C, D, E, F> b) where MonoidA : struct, Monoid<A> where MonoidB : struct, Monoid<B> where MonoidC : struct, Monoid<C> where MonoidD : struct, Monoid<D> where MonoidE : struct, Monoid<E> where MonoidF : struct, Monoid<F>
	{
		return Prelude.Tuple(TypeClass.mconcat<MonoidA, A>(new A[2] { a.Item1, b.Item1 }), TypeClass.mconcat<MonoidB, B>(new B[2] { a.Item2, b.Item2 }), TypeClass.mconcat<MonoidC, C>(new C[2] { a.Item3, b.Item3 }), TypeClass.mconcat<MonoidD, D>(new D[2] { a.Item4, b.Item4 }), TypeClass.mconcat<MonoidE, E>(new E[2] { a.Item5, b.Item5 }), TypeClass.mconcat<MonoidF, F>(new F[2] { a.Item6, b.Item6 }));
	}

	[Pure]
	public static A Concat<MonoidA, A>(this Tuple<A, A, A, A, A, A> a) where MonoidA : struct, Monoid<A>
	{
		return TypeClass.mconcat<MonoidA, A>(new A[6] { a.Item1, a.Item2, a.Item3, a.Item4, a.Item5, a.Item6 });
	}

	[Pure]
	public static A Head<A, B, C, D, E, F>(this Tuple<A, B, C, D, E, F> self)
	{
		return self.Item1;
	}

	[Pure]
	public static F Last<A, B, C, D, E, F>(this Tuple<A, B, C, D, E, F> self)
	{
		return self.Item6;
	}

	[Pure]
	public static Tuple<B, C, D, E, F> Tail<A, B, C, D, E, F>(this Tuple<A, B, C, D, E, F> self)
	{
		return Prelude.Tuple(self.Item2, self.Item3, self.Item4, self.Item5, self.Item6);
	}

	[Pure]
	public static A Sum<NUM, A>(this Tuple<A, A, A, A, A, A> self) where NUM : struct, Num<A>
	{
		return TypeClass.sum<NUM, FoldTuple<A>, Tuple<A, A, A, A, A, A>, A>(self);
	}

	[Pure]
	public static A Product<NUM, A>(this Tuple<A, A, A, A, A, A> self) where NUM : struct, Num<A>
	{
		return TypeClass.product<NUM, FoldTuple<A>, Tuple<A, A, A, A, A, A>, A>(self);
	}

	[Pure]
	public static bool Contains<EQ, A>(this Tuple<A, A, A, A, A, A> self, A value) where EQ : struct, Eq<A>
	{
		if (!default(EQ).Equals(self.Item1, value) && !default(EQ).Equals(self.Item2, value) && !default(EQ).Equals(self.Item3, value) && !default(EQ).Equals(self.Item4, value) && !default(EQ).Equals(self.Item5, value))
		{
			return default(EQ).Equals(self.Item6, value);
		}
		return true;
	}

	[Pure]
	public static R Map<A, B, C, D, E, F, R>(this Tuple<A, B, C, D, E, F> self, Func<Tuple<A, B, C, D, E, F>, R> map)
	{
		return map(self);
	}

	[Pure]
	public static R Map<A, B, C, D, E, F, R>(this Tuple<A, B, C, D, E, F> self, Func<A, B, C, D, E, F, R> map)
	{
		return map(self.Item1, self.Item2, self.Item3, self.Item4, self.Item5, self.Item6);
	}

	[Pure]
	public static Tuple<U, V, W, X, Y, Z> Map<A, B, C, D, E, F, U, V, W, X, Y, Z>(this Tuple<A, B, C, D, E, F> self, Func<A, B, C, D, E, F, Tuple<U, V, W, X, Y, Z>> map)
	{
		return map(self.Item1, self.Item2, self.Item3, self.Item4, self.Item5, self.Item6);
	}

	[Pure]
	public static Tuple<U, V, W, X, Y, Z> Map<A, B, C, D, E, F, U, V, W, X, Y, Z>(this Tuple<A, B, C, D, E, F> self, Func<A, U> firstMap, Func<B, V> secondMap, Func<C, W> thirdMap, Func<D, X> fourthMap, Func<E, Y> fifthMap, Func<F, Z> sixthMap)
	{
		return Prelude.Tuple(firstMap(self.Item1), secondMap(self.Item2), thirdMap(self.Item3), fourthMap(self.Item4), fifthMap(self.Item5), sixthMap(self.Item6));
	}

	[Pure]
	public static Tuple<R1, B, C, D, E, F> MapFirst<A, B, C, D, E, F, R1>(this Tuple<A, B, C, D, E, F> self, Func<A, R1> firstMap)
	{
		return Prelude.Tuple(firstMap(self.Item1), self.Item2, self.Item3, self.Item4, self.Item5, self.Item6);
	}

	[Pure]
	public static Tuple<A, R2, C, D, E, F> MapSecond<A, B, C, D, E, F, R2>(this Tuple<A, B, C, D, E, F> self, Func<B, R2> secondMap)
	{
		return Prelude.Tuple(self.Item1, secondMap(self.Item2), self.Item3, self.Item4, self.Item5, self.Item6);
	}

	[Pure]
	public static Tuple<A, B, R3, D, E, F> MapThird<A, B, C, D, E, F, R3>(this Tuple<A, B, C, D, E, F> self, Func<C, R3> thirdMap)
	{
		return Prelude.Tuple(self.Item1, self.Item2, thirdMap(self.Item3), self.Item4, self.Item5, self.Item6);
	}

	[Pure]
	public static Tuple<A, B, C, R4, E, F> MapFourth<A, B, C, D, E, F, R4>(this Tuple<A, B, C, D, E, F> self, Func<D, R4> fourthMap)
	{
		return Prelude.Tuple(self.Item1, self.Item2, self.Item3, fourthMap(self.Item4), self.Item5, self.Item6);
	}

	[Pure]
	public static Tuple<A, B, C, D, R5, F> MapFifth<A, B, C, D, E, F, R5>(this Tuple<A, B, C, D, E, F> self, Func<E, R5> fifthMap)
	{
		return Prelude.Tuple(self.Item1, self.Item2, self.Item3, self.Item4, fifthMap(self.Item5), self.Item6);
	}

	[Pure]
	public static Tuple<A, B, C, D, E, R6> MapSixth<A, B, C, D, E, F, R6>(this Tuple<A, B, C, D, E, F> self, Func<F, R6> sixthMap)
	{
		return Prelude.Tuple(self.Item1, self.Item2, self.Item3, self.Item4, self.Item5, sixthMap(self.Item6));
	}

	[Pure]
	public static Tuple<U, V, W, X, Y, Z> Select<A, B, C, D, E, F, U, V, W, X, Y, Z>(this Tuple<A, B, C, D, E, F> self, Func<Tuple<A, B, C, D, E, F>, Tuple<U, V, W, X, Y, Z>> map)
	{
		return map(self);
	}

	public static Unit Iter<A, B, C, D, E, F>(this Tuple<A, B, C, D, E, F> self, Action<A, B, C, D, E, F> func)
	{
		func(self.Item1, self.Item2, self.Item3, self.Item4, self.Item5, self.Item6);
		return Unit.Default;
	}

	public static Unit Iter<A, B, C, D, E, F>(this Tuple<A, B, C, D, E, F> self, Action<A> first, Action<B> second, Action<C> third, Action<D> fourth, Action<E> fifth, Action<F> sixth)
	{
		first(self.Item1);
		second(self.Item2);
		third(self.Item3);
		fourth(self.Item4);
		fifth(self.Item5);
		sixth(self.Item6);
		return Unit.Default;
	}

	[Pure]
	public static S Fold<A, B, C, D, E, F, S>(this Tuple<A, B, C, D, E, F> self, S state, Func<S, A, B, C, D, E, F, S> fold)
	{
		return fold(state, self.Item1, self.Item2, self.Item3, self.Item4, self.Item5, self.Item6);
	}

	[Pure]
	public static S SextFold<A, B, C, D, E, F, S>(this Tuple<A, B, C, D, E, F> self, S state, Func<S, A, S> firstFold, Func<S, B, S> secondFold, Func<S, C, S> thirdFold, Func<S, D, S> fourthFold, Func<S, E, S> fifthFold, Func<S, F, S> sixthFold)
	{
		return sixthFold(fifthFold(fourthFold(thirdFold(secondFold(firstFold(state, self.Item1), self.Item2), self.Item3), self.Item4), self.Item5), self.Item6);
	}

	[Pure]
	public static S SextFoldBack<A, B, C, D, E, F, S>(this Tuple<A, B, C, D, E, F> self, S state, Func<S, F, S> firstFold, Func<S, E, S> secondFold, Func<S, D, S> thirdFold, Func<S, C, S> fourthFold, Func<S, B, S> fifthFold, Func<S, A, S> sixthFold)
	{
		return sixthFold(fifthFold(fourthFold(thirdFold(secondFold(firstFold(state, self.Item6), self.Item5), self.Item4), self.Item3), self.Item2), self.Item1);
	}
}
public static class Tuple7Extensions
{
	[Pure]
	public static Tuple<A, B, C, D, E, F, G> Append<SemiA, SemiB, SemiC, SemiD, SemiE, SemiF, SemiG, A, B, C, D, E, F, G>(this Tuple<A, B, C, D, E, F, G> a, Tuple<A, B, C, D, E, F, G> b) where SemiA : struct, Semigroup<A> where SemiB : struct, Semigroup<B> where SemiC : struct, Semigroup<C> where SemiD : struct, Semigroup<D> where SemiE : struct, Semigroup<E> where SemiF : struct, Semigroup<F> where SemiG : struct, Semigroup<G>
	{
		return Prelude.Tuple(default(SemiA).Append(a.Item1, b.Item1), default(SemiB).Append(a.Item2, b.Item2), default(SemiC).Append(a.Item3, b.Item3), default(SemiD).Append(a.Item4, b.Item4), default(SemiE).Append(a.Item5, b.Item5), default(SemiF).Append(a.Item6, b.Item6), default(SemiG).Append(a.Item7, b.Item7));
	}

	[Pure]
	public static A Append<SemiA, A>(this Tuple<A, A, A, A, A, A, A> a) where SemiA : struct, Semigroup<A>
	{
		return default(SemiA).Append(a.Item1, default(SemiA).Append(a.Item2, default(SemiA).Append(a.Item3, default(SemiA).Append(a.Item4, default(SemiA).Append(a.Item5, default(SemiA).Append(a.Item6, a.Item7))))));
	}

	[Pure]
	public static Tuple<A, B, C, D, E, F, G> Concat<MonoidA, MonoidB, MonoidC, MonoidD, MonoidE, MonoidF, MonoidG, A, B, C, D, E, F, G>(this Tuple<A, B, C, D, E, F, G> a, Tuple<A, B, C, D, E, F, G> b) where MonoidA : struct, Monoid<A> where MonoidB : struct, Monoid<B> where MonoidC : struct, Monoid<C> where MonoidD : struct, Monoid<D> where MonoidE : struct, Monoid<E> where MonoidF : struct, Monoid<F> where MonoidG : struct, Monoid<G>
	{
		return Prelude.Tuple(TypeClass.mconcat<MonoidA, A>(new A[2] { a.Item1, b.Item1 }), TypeClass.mconcat<MonoidB, B>(new B[2] { a.Item2, b.Item2 }), TypeClass.mconcat<MonoidC, C>(new C[2] { a.Item3, b.Item3 }), TypeClass.mconcat<MonoidD, D>(new D[2] { a.Item4, b.Item4 }), TypeClass.mconcat<MonoidE, E>(new E[2] { a.Item5, b.Item5 }), TypeClass.mconcat<MonoidF, F>(new F[2] { a.Item6, b.Item6 }), TypeClass.mconcat<MonoidG, G>(new G[2] { a.Item7, b.Item7 }));
	}

	[Pure]
	public static A Concat<MonoidA, A>(this Tuple<A, A, A, A, A, A, A> a) where MonoidA : struct, Monoid<A>
	{
		return TypeClass.mconcat<MonoidA, A>(new A[7] { a.Item1, a.Item2, a.Item3, a.Item4, a.Item5, a.Item6, a.Item7 });
	}

	[Pure]
	public static A Head<A, B, C, D, E, F, G>(this Tuple<A, B, C, D, E, F, G> self)
	{
		return self.Item1;
	}

	[Pure]
	public static G Last<A, B, C, D, E, F, G>(this Tuple<A, B, C, D, E, F, G> self)
	{
		return self.Item7;
	}

	[Pure]
	public static (B, C, D, E, F, G) Tail<A, B, C, D, E, F, G>(this Tuple<A, B, C, D, E, F, G> self)
	{
		return (self.Item2, self.Item3, self.Item4, self.Item5, self.Item6, self.Item7);
	}

	[Pure]
	public static A Sum<NUM, A>(this Tuple<A, A, A, A, A, A, A> self) where NUM : struct, Num<A>
	{
		return TypeClass.sum<NUM, FoldTuple<A>, Tuple<A, A, A, A, A, A, A>, A>(self);
	}

	[Pure]
	public static A Product<NUM, A>(this Tuple<A, A, A, A, A, A, A> self) where NUM : struct, Num<A>
	{
		return TypeClass.product<NUM, FoldTuple<A>, Tuple<A, A, A, A, A, A, A>, A>(self);
	}

	[Pure]
	public static bool Contains<EQ, A>(this Tuple<A, A, A, A, A, A, A> self, A value) where EQ : struct, Eq<A>
	{
		if (!default(EQ).Equals(self.Item1, value) && !default(EQ).Equals(self.Item2, value) && !default(EQ).Equals(self.Item3, value) && !default(EQ).Equals(self.Item4, value) && !default(EQ).Equals(self.Item5, value) && !default(EQ).Equals(self.Item6, value))
		{
			return default(EQ).Equals(self.Item7, value);
		}
		return true;
	}

	[Pure]
	public static R Map<A, B, C, D, E, F, G, R>(this Tuple<A, B, C, D, E, F, G> self, Func<Tuple<A, B, C, D, E, F, G>, R> map)
	{
		return map(self);
	}

	[Pure]
	public static R Map<A, B, C, D, E, F, G, R>(this Tuple<A, B, C, D, E, F, G> self, Func<A, B, C, D, E, F, G, R> map)
	{
		return map(self.Item1, self.Item2, self.Item3, self.Item4, self.Item5, self.Item6, self.Item7);
	}

	[Pure]
	public static Tuple<T, U, V, W, X, Y, Z> Map<A, B, C, D, E, F, G, T, U, V, W, X, Y, Z>(this Tuple<A, B, C, D, E, F, G> self, Func<A, T> firstMap, Func<B, U> secondMap, Func<C, V> thirdMap, Func<D, W> fourthMap, Func<E, X> fifthMap, Func<F, Y> sixthMap, Func<G, Z> seventhMap)
	{
		return Prelude.Tuple(firstMap(self.Item1), secondMap(self.Item2), thirdMap(self.Item3), fourthMap(self.Item4), fifthMap(self.Item5), sixthMap(self.Item6), seventhMap(self.Item7));
	}

	[Pure]
	public static Tuple<R1, B, C, D, E, F, G> MapFirst<A, B, C, D, E, F, G, R1>(this Tuple<A, B, C, D, E, F, G> self, Func<A, R1> firstMap)
	{
		return Prelude.Tuple(firstMap(self.Item1), self.Item2, self.Item3, self.Item4, self.Item5, self.Item6, self.Item7);
	}

	[Pure]
	public static Tuple<A, R2, C, D, E, F, G> MapSecond<A, B, C, D, E, F, G, R2>(this Tuple<A, B, C, D, E, F, G> self, Func<B, R2> secondMap)
	{
		return Prelude.Tuple(self.Item1, secondMap(self.Item2), self.Item3, self.Item4, self.Item5, self.Item6, self.Item7);
	}

	[Pure]
	public static Tuple<A, B, R3, D, E, F, G> MapThird<A, B, C, D, E, F, G, R3>(this Tuple<A, B, C, D, E, F, G> self, Func<C, R3> thirdMap)
	{
		return Prelude.Tuple(self.Item1, self.Item2, thirdMap(self.Item3), self.Item4, self.Item5, self.Item6, self.Item7);
	}

	[Pure]
	public static Tuple<A, B, C, R4, E, F, G> MapFourth<A, B, C, D, E, F, G, R4>(this Tuple<A, B, C, D, E, F, G> self, Func<D, R4> fourthMap)
	{
		return Prelude.Tuple(self.Item1, self.Item2, self.Item3, fourthMap(self.Item4), self.Item5, self.Item6, self.Item7);
	}

	[Pure]
	public static Tuple<A, B, C, D, R5, F, G> MapFifth<A, B, C, D, E, F, G, R5>(this Tuple<A, B, C, D, E, F, G> self, Func<E, R5> fifthMap)
	{
		return Prelude.Tuple(self.Item1, self.Item2, self.Item3, self.Item4, fifthMap(self.Item5), self.Item6, self.Item7);
	}

	[Pure]
	public static Tuple<A, B, C, D, E, R6, G> MapSixth<A, B, C, D, E, F, G, R6>(this Tuple<A, B, C, D, E, F, G> self, Func<F, R6> sixthMap)
	{
		return Prelude.Tuple(self.Item1, self.Item2, self.Item3, self.Item4, self.Item5, sixthMap(self.Item6), self.Item7);
	}

	[Pure]
	public static Tuple<A, B, C, D, E, F, R7> MapSeventh<A, B, C, D, E, F, G, R7>(this Tuple<A, B, C, D, E, F, G> self, Func<G, R7> seventhMap)
	{
		return Prelude.Tuple(self.Item1, self.Item2, self.Item3, self.Item4, self.Item5, self.Item6, seventhMap(self.Item7));
	}

	[Pure]
	public static Tuple<U, V, W, X, Y, Z> Select<A, B, C, D, E, F, G, U, V, W, X, Y, Z>(this Tuple<A, B, C, D, E, F, G> self, Func<Tuple<A, B, C, D, E, F, G>, Tuple<U, V, W, X, Y, Z>> map)
	{
		return map(self);
	}

	public static Unit Iter<A, B, C, D, E, F, G>(this Tuple<A, B, C, D, E, F, G> self, Action<A, B, C, D, E, F, G> func)
	{
		func(self.Item1, self.Item2, self.Item3, self.Item4, self.Item5, self.Item6, self.Item7);
		return Unit.Default;
	}

	public static Unit Iter<A, B, C, D, E, F, G>(this Tuple<A, B, C, D, E, F, G> self, Action<A> first, Action<B> second, Action<C> third, Action<D> fourth, Action<E> fifth, Action<F> sixth, Action<G> seventh)
	{
		first(self.Item1);
		second(self.Item2);
		third(self.Item3);
		fourth(self.Item4);
		fifth(self.Item5);
		sixth(self.Item6);
		seventh(self.Item7);
		return Unit.Default;
	}

	[Pure]
	public static S Fold<A, B, C, D, E, F, G, S>(this Tuple<A, B, C, D, E, F, G> self, S state, Func<S, A, B, C, D, E, F, G, S> fold)
	{
		return fold(state, self.Item1, self.Item2, self.Item3, self.Item4, self.Item5, self.Item6, self.Item7);
	}

	[Pure]
	public static S SeptFold<A, B, C, D, E, F, G, S>(this Tuple<A, B, C, D, E, F, G> self, S state, Func<S, A, S> firstFold, Func<S, B, S> secondFold, Func<S, C, S> thirdFold, Func<S, D, S> fourthFold, Func<S, E, S> fifthFold, Func<S, F, S> sixthFold, Func<S, G, S> seventhFold)
	{
		return seventhFold(sixthFold(fifthFold(fourthFold(thirdFold(secondFold(firstFold(state, self.Item1), self.Item2), self.Item3), self.Item4), self.Item5), self.Item6), self.Item7);
	}

	[Pure]
	public static S SeptFoldBack<A, B, C, D, E, F, G, S>(this Tuple<A, B, C, D, E, F, G> self, S state, Func<S, G, S> firstFold, Func<S, F, S> secondFold, Func<S, E, S> thirdFold, Func<S, D, S> fourthFold, Func<S, C, S> fifthFold, Func<S, B, S> sixthFold, Func<S, A, S> seventhFold)
	{
		return seventhFold(sixthFold(fifthFold(fourthFold(thirdFold(secondFold(firstFold(state, self.Item7), self.Item6), self.Item5), self.Item4), self.Item3), self.Item2), self.Item1);
	}
}
public static class ValueTuple1Extensions
{
	[Pure]
	public static (A, B) Add<A, B>(this ValueTuple<A> self, B second)
	{
		return (self.Item1, second);
	}

	[Pure]
	public static ValueTuple<A> Append<SemiA, SemiB, A, B>(this ValueTuple<A> a, ValueTuple<A> b) where SemiA : struct, Semigroup<A>
	{
		return Prelude.VTuple(default(SemiA).Append(a.Item1, b.Item1));
	}

	[Pure]
	public static ValueTuple<A> Concat<MonoidA, MonoidB, A, B>(this ValueTuple<A> a, ValueTuple<A> b) where MonoidA : struct, Monoid<A> where MonoidB : struct, Monoid<B>
	{
		return Prelude.VTuple(TypeClass.mconcat<MonoidA, A>(new A[2] { a.Item1, b.Item1 }));
	}

	[Pure]
	public static A Head<A>(this ValueTuple<A> self)
	{
		return self.Item1;
	}

	[Pure]
	public static A Last<A>(this ValueTuple<A> self)
	{
		return self.Item1;
	}

	[Pure]
	public static A Sum<NUM, A>(this ValueTuple<A> self) where NUM : struct, Num<A>
	{
		return self.Item1;
	}

	[Pure]
	public static A Product<NUM, A>(this ValueTuple<A> self) where NUM : struct, Num<A>
	{
		return self.Item1;
	}

	[Pure]
	public static bool Contains<EQ, A>(this ValueTuple<A> self, A value) where EQ : struct, Eq<A>
	{
		return default(EQ).Equals(self.Item1, value);
	}

	[Pure]
	public static ValueTuple<R> Map<A, R>(this ValueTuple<A> self, Func<A, R> map)
	{
		return Prelude.VTuple(map(self.Item1));
	}

	[Pure]
	public static ValueTuple<R> Select<A, R>(this ValueTuple<A> self, Func<A, R> map)
	{
		return Prelude.VTuple(map(self.Item1));
	}

	public static Unit Iter<A>(this ValueTuple<A> self, Action<A> func)
	{
		func(self.Item1);
		return Unit.Default;
	}

	[Pure]
	public static S Fold<A, S>(this ValueTuple<A> self, S state, Func<S, A, S> fold)
	{
		return fold(state, self.Item1);
	}
}
public static class ValueTuple2Extensions
{
	[Pure]
	public static (A, B, C) Add<A, B, C>(this (A, B) self, C third)
	{
		return (self.Item1, self.Item2, third);
	}

	[Pure]
	public static (A, B) Append<SemiA, SemiB, A, B>(this (A, B) a, (A, B) b) where SemiA : struct, Semigroup<A> where SemiB : struct, Semigroup<B>
	{
		return (default(SemiA).Append(a.Item1, b.Item1), default(SemiB).Append(a.Item2, b.Item2));
	}

	[Pure]
	public static A Append<SemiA, A>(this (A, A) a) where SemiA : struct, Semigroup<A>
	{
		return default(SemiA).Append(a.Item1, a.Item2);
	}

	[Pure]
	public static (A, B) Concat<MonoidA, MonoidB, A, B>(this (A, B) a, (A, B) b) where MonoidA : struct, Monoid<A> where MonoidB : struct, Monoid<B>
	{
		return (TypeClass.mconcat<MonoidA, A>(new A[2] { a.Item1, b.Item1 }), TypeClass.mconcat<MonoidB, B>(new B[2] { a.Item2, b.Item2 }));
	}

	[Pure]
	public static A Concat<MonoidA, A>(this (A, A) a) where MonoidA : struct, Monoid<A>
	{
		return TypeClass.mconcat<MonoidA, A>(new A[2] { a.Item1, a.Item2 });
	}

	[Pure]
	public static T1 Head<T1, T2>(this (T1, T2) self)
	{
		return self.Item1;
	}

	[Pure]
	public static T2 Last<T1, T2>(this (T1, T2) self)
	{
		return self.Item2;
	}

	[Pure]
	public static ValueTuple<T2> Tail<T1, T2>(this (T1, T2) self)
	{
		return Prelude.VTuple(self.Item2);
	}

	[Pure]
	public static A Sum<NUM, A>(this (A, A) self) where NUM : struct, Num<A>
	{
		return TypeClass.sum<NUM, FoldTuple<A>, (A, A), A>(self);
	}

	[Pure]
	public static A Product<NUM, A>(this (A, A) self) where NUM : struct, Num<A>
	{
		return TypeClass.product<NUM, FoldTuple<A>, (A, A), A>(self);
	}

	[Pure]
	public static bool Contains<EQ, A>(this (A, A) self, A value) where EQ : struct, Eq<A>
	{
		return TypeClass.contains<EQ, FoldTuple<A>, (A, A), A>(self, value);
	}

	[Pure]
	public static R Map<A, B, R>(this (A, B) self, Func<(A, B), R> map)
	{
		return map(self);
	}

	[Pure]
	public static R Map<A, B, R>(this (A, B) self, Func<A, B, R> map)
	{
		return map(self.Item1, self.Item2);
	}

	[Pure]
	public static (R1, R2) BiMap<T1, T2, R1, R2>(this (T1, T2) self, Func<T1, R1> firstMap, Func<T2, R2> secondMap)
	{
		return (firstMap(self.Item1), secondMap(self.Item2));
	}

	[Pure]
	public static (R1, T2) MapFirst<T1, T2, R1>(this (T1, T2) self, Func<T1, R1> firstMap)
	{
		return (firstMap(self.Item1), self.Item2);
	}

	[Pure]
	public static (T1, R2) MapSecond<T1, T2, R2>(this (T1, T2) self, Func<T2, R2> secondMap)
	{
		return (self.Item1, secondMap(self.Item2));
	}

	[Pure]
	public static (R1, R2) Select<T1, T2, R1, R2>(this (T1, T2) self, Func<(T1, T2), (R1, R2)> map)
	{
		return map(self);
	}

	public static Unit Iter<T1, T2>(this (T1, T2) self, Action<T1, T2> func)
	{
		func(self.Item1, self.Item2);
		return Unit.Default;
	}

	public static Unit Iter<T1, T2>(this (T1, T2) self, Action<T1> first, Action<T2> second)
	{
		first(self.Item1);
		second(self.Item2);
		return Unit.Default;
	}

	[Pure]
	public static S Fold<T1, T2, S>(this (T1, T2) self, S state, Func<S, T1, T2, S> fold)
	{
		return fold(state, self.Item1, self.Item2);
	}

	[Pure]
	public static S BiFold<T1, T2, S>(this (T1, T2) self, S state, Func<S, T1, S> firstFold, Func<S, T2, S> secondFold)
	{
		return secondFold(firstFold(state, self.Item1), self.Item2);
	}

	[Pure]
	public static S BiFoldBack<T1, T2, S>(this (T1, T2) self, S state, Func<S, T2, S> firstFold, Func<S, T1, S> secondFold)
	{
		return secondFold(firstFold(state, self.Item2), self.Item1);
	}

	[Pure]
	public static Arr<(C, D)> Traverse<A, B, C, D>(this (Arr<A> ma, Arr<B> mb) tuple, Func<(A a, B b), (C c, D d)> f)
	{
		return ArrExtensions.Select(from a in tuple.ma
			from b in tuple.mb
			select new
			{
				<>h__TransparentIdentifier0 = <>h__TransparentIdentifier0,
				r = f((a, b))
			}, <>h__TransparentIdentifier1 => (<>h__TransparentIdentifier1.r.c, <>h__TransparentIdentifier1.r.d));
	}

	[Pure]
	public static Arr<(C, D)> Traverse<A, B, C, D>(this (Arr<A> ma, Arr<B> mb) tuple, Func<A, B, (C c, D d)> f)
	{
		return ArrExtensions.Select(from a in tuple.ma
			from b in tuple.mb
			select new
			{
				<>h__TransparentIdentifier0 = <>h__TransparentIdentifier0,
				r = f(a, b)
			}, <>h__TransparentIdentifier1 => (<>h__TransparentIdentifier1.r.c, <>h__TransparentIdentifier1.r.d));
	}

	[Pure]
	public static Arr<(A, B)> Sequence<A, B>(this (Arr<A> ma, Arr<B> mb) tuple)
	{
		return from a in tuple.ma
			from b in tuple.mb
			select (a, b);
	}

	[Pure]
	public static Either<L, (C, D)> Traverse<L, A, B, C, D>(this (Either<L, A> ma, Either<L, B> mb) tuple, Func<(A a, B b), (C c, D d)> f)
	{
		Either<L, A> item = tuple.ma;
		return from a in item
			from b in tuple.mb
			let r = f((a, b))
			select (r.c, r.d);
	}

	[Pure]
	public static Either<L, (C, D)> Traverse<L, A, B, C, D>(this (Either<L, A> ma, Either<L, B> mb) tuple, Func<A, B, (C c, D d)> f)
	{
		Either<L, A> item = tuple.ma;
		return from a in item
			from b in tuple.mb
			let r = f(a, b)
			select (r.c, r.d);
	}

	[Pure]
	public static Either<L, (A, B)> Sequence<L, A, B>(this (Either<L, A> ma, Either<L, B> mb) tuple)
	{
		Either<L, A> item = tuple.ma;
		return from a in item
			from b in tuple.mb
			select (a, b);
	}

	[Pure]
	public static EitherUnsafe<L, (C, D)> Traverse<L, A, B, C, D>(this (EitherUnsafe<L, A> ma, EitherUnsafe<L, B> mb) tuple, Func<(A a, B b), (C c, D d)> f)
	{
		EitherUnsafe<L, A> item = tuple.ma;
		return from a in item
			from b in tuple.mb
			let r = f((a, b))
			select (r.c, r.d);
	}

	[Pure]
	public static EitherUnsafe<L, (C, D)> Traverse<L, A, B, C, D>(this (EitherUnsafe<L, A> ma, EitherUnsafe<L, B> mb) tuple, Func<A, B, (C c, D d)> f)
	{
		EitherUnsafe<L, A> item = tuple.ma;
		return from a in item
			from b in tuple.mb
			let r = f(a, b)
			select (r.c, r.d);
	}

	[Pure]
	public static EitherUnsafe<L, (A, B)> Sequence<L, A, B>(this (EitherUnsafe<L, A> ma, EitherUnsafe<L, B> mb) tuple)
	{
		EitherUnsafe<L, A> item = tuple.ma;
		return from a in item
			from b in tuple.mb
			select (a, b);
	}

	[Pure]
	public static EitherAsync<L, (C, D)> Traverse<L, A, B, C, D>(this (EitherAsync<L, A> ma, EitherAsync<L, B> mb) tuple, Func<(A a, B b), (C c, D d)> f)
	{
		return Prelude.apply((A a, B b) => f((a, b)), tuple.ma, tuple.mb);
	}

	[Pure]
	public static EitherAsync<L, (C, D)> Traverse<L, A, B, C, D>(this (EitherAsync<L, A> ma, EitherAsync<L, B> mb) tuple, Func<A, B, (C c, D d)> f)
	{
		return Prelude.apply((A a, B b) => f(a, b), tuple.ma, tuple.mb);
	}

	[Pure]
	public static EitherAsync<L, (A, B)> Sequence<L, A, B>(this (EitherAsync<L, A> ma, EitherAsync<L, B> mb) tuple)
	{
		return Prelude.apply((A a, B b) => (a, b), tuple.ma, tuple.mb);
	}

	[Pure]
	public static LanguageExt.HashSet<(C, D)> Traverse<A, B, C, D>(this (LanguageExt.HashSet<A> ma, LanguageExt.HashSet<B> mb) tuple, Func<(A a, B b), (C c, D d)> f)
	{
		LanguageExt.HashSet<A> item = tuple.ma;
		return from a in item
			from b in tuple.mb
			let r = f((a, b))
			select (r.c, r.d);
	}

	[Pure]
	public static LanguageExt.HashSet<(C, D)> Traverse<A, B, C, D>(this (LanguageExt.HashSet<A> ma, LanguageExt.HashSet<B> mb) tuple, Func<A, B, (C c, D d)> f)
	{
		LanguageExt.HashSet<A> item = tuple.ma;
		return from a in item
			from b in tuple.mb
			let r = f(a, b)
			select (r.c, r.d);
	}

	[Pure]
	public static LanguageExt.HashSet<(A, B)> Sequence<A, B>(this (LanguageExt.HashSet<A> ma, LanguageExt.HashSet<B> mb) tuple)
	{
		LanguageExt.HashSet<A> item = tuple.ma;
		return from a in item
			from b in tuple.mb
			select (a, b);
	}

	[Pure]
	public static Lst<(C, D)> Traverse<A, B, C, D>(this (Lst<A> ma, Lst<B> mb) tuple, Func<(A a, B b), (C c, D d)> f)
	{
		return ListExtensions.Select(from a in tuple.ma
			from b in tuple.mb
			select new
			{
				<>h__TransparentIdentifier0 = <>h__TransparentIdentifier0,
				r = f((a, b))
			}, <>h__TransparentIdentifier1 => (<>h__TransparentIdentifier1.r.c, <>h__TransparentIdentifier1.r.d));
	}

	[Pure]
	public static Lst<(C, D)> Traverse<A, B, C, D>(this (Lst<A> ma, Lst<B> mb) tuple, Func<A, B, (C c, D d)> f)
	{
		return ListExtensions.Select(from a in tuple.ma
			from b in tuple.mb
			select new
			{
				<>h__TransparentIdentifier0 = <>h__TransparentIdentifier0,
				r = f(a, b)
			}, <>h__TransparentIdentifier1 => (<>h__TransparentIdentifier1.r.c, <>h__TransparentIdentifier1.r.d));
	}

	[Pure]
	public static Lst<(A, B)> Sequence<A, B>(this (Lst<A> ma, Lst<B> mb) tuple)
	{
		return from a in tuple.ma
			from b in tuple.mb
			select (a, b);
	}

	[Pure]
	public static Option<(C, D)> Traverse<A, B, C, D>(this (Option<A> ma, Option<B> mb) tuple, Func<(A a, B b), (C c, D d)> f)
	{
		Option<A> item = tuple.ma;
		return from a in item
			from b in tuple.mb
			let r = f((a, b))
			select (r.c, r.d);
	}

	[Pure]
	public static Option<(C, D)> Traverse<A, B, C, D>(this (Option<A> ma, Option<B> mb) tuple, Func<A, B, (C c, D d)> f)
	{
		Option<A> item = tuple.ma;
		return from a in item
			from b in tuple.mb
			let r = f(a, b)
			select (r.c, r.d);
	}

	[Pure]
	public static Option<(A, B)> Sequence<A, B>(this (Option<A> ma, Option<B> mb) tuple)
	{
		Option<A> item = tuple.ma;
		return from a in item
			from b in tuple.mb
			select (a, b);
	}

	[Pure]
	public static OptionUnsafe<(C, D)> Traverse<A, B, C, D>(this (OptionUnsafe<A> ma, OptionUnsafe<B> mb) tuple, Func<(A a, B b), (C c, D d)> f)
	{
		OptionUnsafe<A> item = tuple.ma;
		return from a in item
			from b in tuple.mb
			let r = f((a, b))
			select (r.c, r.d);
	}

	[Pure]
	public static OptionUnsafe<(C, D)> Traverse<A, B, C, D>(this (OptionUnsafe<A> ma, OptionUnsafe<B> mb) tuple, Func<A, B, (C c, D d)> f)
	{
		OptionUnsafe<A> item = tuple.ma;
		return from a in item
			from b in tuple.mb
			let r = f(a, b)
			select (r.c, r.d);
	}

	[Pure]
	public static OptionUnsafe<(A, B)> Sequence<A, B>(this (OptionUnsafe<A> ma, OptionUnsafe<B> mb) tuple)
	{
		OptionUnsafe<A> item = tuple.ma;
		return from a in item
			from b in tuple.mb
			select (a, b);
	}

	[Pure]
	public static OptionAsync<(C, D)> Traverse<A, B, C, D>(this (OptionAsync<A> ma, OptionAsync<B> mb) tuple, Func<(A a, B b), (C c, D d)> f)
	{
		return Prelude.apply((A a, B b) => f((a, b)), tuple.ma, tuple.mb);
	}

	[Pure]
	public static OptionAsync<(C, D)> Traverse<A, B, C, D>(this (OptionAsync<A> ma, OptionAsync<B> mb) tuple, Func<A, B, (C c, D d)> f)
	{
		return Prelude.apply((A a, B b) => f(a, b), tuple.ma, tuple.mb);
	}

	[Pure]
	public static OptionAsync<(A, B)> Sequence<A, B>(this (OptionAsync<A> ma, OptionAsync<B> mb) tuple)
	{
		return Prelude.apply((A a, B b) => (a, b), tuple.ma, tuple.mb);
	}

	[Pure]
	public static Reader<Env, (C, D)> Traverse<Env, A, B, C, D>(this (Reader<Env, A> ma, Reader<Env, B> mb) tuple, Func<(A a, B b), (C c, D d)> f)
	{
		return from a in tuple.ma
			from b in tuple.mb
			let r = f((a, b))
			select (r.c, r.d);
	}

	[Pure]
	public static Reader<Env, (C, D)> Traverse<Env, A, B, C, D>(this (Reader<Env, A> ma, Reader<Env, B> mb) tuple, Func<A, B, (C c, D d)> f)
	{
		return from a in tuple.ma
			from b in tuple.mb
			let r = f(a, b)
			select (r.c, r.d);
	}

	[Pure]
	public static Reader<Env, (A, B)> Sequence<Env, A, B>(this (Reader<Env, A> ma, Reader<Env, B> mb) tuple)
	{
		return from a in tuple.ma
			from b in tuple.mb
			select (a, b);
	}

	[Pure]
	public static Set<(C, D)> Traverse<A, B, C, D>(this (Set<A> ma, Set<B> mb) tuple, Func<(A a, B b), (C c, D d)> f)
	{
		Set<A> item = tuple.ma;
		return from a in item
			from b in tuple.mb
			let r = f((a, b))
			select (r.c, r.d);
	}

	[Pure]
	public static Set<(C, D)> Traverse<A, B, C, D>(this (Set<A> ma, Set<B> mb) tuple, Func<A, B, (C c, D d)> f)
	{
		Set<A> item = tuple.ma;
		return from a in item
			from b in tuple.mb
			let r = f(a, b)
			select (r.c, r.d);
	}

	[Pure]
	public static Set<(A, B)> Sequence<A, B>(this (Set<A> ma, Set<B> mb) tuple)
	{
		Set<A> item = tuple.ma;
		return from a in item
			from b in tuple.mb
			select (a, b);
	}

	[Pure]
	public static State<S, (C, D)> Traverse<S, A, B, C, D>(this (State<S, A> ma, State<S, B> mb) tuple, Func<(A a, B b), (C c, D d)> f)
	{
		return from a in tuple.ma
			from b in tuple.mb
			let r = f((a, b))
			select (r.c, r.d);
	}

	[Pure]
	public static State<S, (C, D)> Traverse<S, A, B, C, D>(this (State<S, A> ma, State<S, B> mb) tuple, Func<A, B, (C c, D d)> f)
	{
		return from a in tuple.ma
			from b in tuple.mb
			let r = f(a, b)
			select (r.c, r.d);
	}

	[Pure]
	public static State<S, (A, B)> Sequence<S, A, B>(this (State<S, A> ma, State<S, B> mb) tuple)
	{
		return from a in tuple.ma
			from b in tuple.mb
			select (a, b);
	}

	[Pure]
	public static Task<(C, D)> Traverse<A, B, C, D>(this (Task<A> ma, Task<B> mb) tuple, Func<(A a, B b), (C c, D d)> f)
	{
		return Prelude.apply((A a, B b) => f((a, b)), tuple.ma, tuple.mb);
	}

	[Pure]
	public static Task<(C, D)> Traverse<A, B, C, D>(this (Task<A> ma, Task<B> mb) tuple, Func<A, B, (C c, D d)> f)
	{
		return Prelude.apply((A a, B b) => f(a, b), tuple.ma, tuple.mb);
	}

	[Pure]
	public static Task<(A, B)> Sequence<A, B>(this (Task<A> ma, Task<B> mb) tuple)
	{
		return Prelude.apply((A a, B b) => (a, b), tuple.ma, tuple.mb);
	}

	[Pure]
	public static Try<(C, D)> Traverse<A, B, C, D>(this (Try<A> ma, Try<B> mb) tuple, Func<(A a, B b), (C c, D d)> f)
	{
		return from a in tuple.ma
			from b in tuple.mb
			let r = f((a, b))
			select (r.c, r.d);
	}

	[Pure]
	public static Try<(C, D)> Traverse<A, B, C, D>(this (Try<A> ma, Try<B> mb) tuple, Func<A, B, (C c, D d)> f)
	{
		return from a in tuple.ma
			from b in tuple.mb
			let r = f(a, b)
			select (r.c, r.d);
	}

	[Pure]
	public static Try<(A, B)> Sequence<A, B>(this (Try<A> ma, Try<B> mb) tuple)
	{
		return from a in tuple.ma
			from b in tuple.mb
			select (a, b);
	}

	[Pure]
	public static TryAsync<(C, D)> Traverse<A, B, C, D>(this (TryAsync<A> ma, TryAsync<B> mb) tuple, Func<(A a, B b), (C c, D d)> f)
	{
		return Prelude.apply((A a, B b) => f((a, b)), tuple.ma, tuple.mb);
	}

	[Pure]
	public static TryAsync<(C, D)> Traverse<A, B, C, D>(this (TryAsync<A> ma, TryAsync<B> mb) tuple, Func<A, B, (C c, D d)> f)
	{
		return Prelude.apply((A a, B b) => f(a, b), tuple.ma, tuple.mb);
	}

	[Pure]
	public static TryAsync<(A, B)> Sequence<A, B>(this (TryAsync<A> ma, TryAsync<B> mb) tuple)
	{
		return Prelude.apply((A a, B b) => (a, b), tuple.ma, tuple.mb);
	}

	[Pure]
	public static TryOption<(C, D)> Traverse<A, B, C, D>(this (TryOption<A> ma, TryOption<B> mb) tuple, Func<(A a, B b), (C c, D d)> f)
	{
		return from a in tuple.ma
			from b in tuple.mb
			let r = f((a, b))
			select (r.c, r.d);
	}

	[Pure]
	public static TryOption<(C, D)> Traverse<A, B, C, D>(this (TryOption<A> ma, TryOption<B> mb) tuple, Func<A, B, (C c, D d)> f)
	{
		return from a in tuple.ma
			from b in tuple.mb
			let r = f(a, b)
			select (r.c, r.d);
	}

	[Pure]
	public static TryOption<(A, B)> Sequence<A, B>(this (TryOption<A> ma, TryOption<B> mb) tuple)
	{
		return from a in tuple.ma
			from b in tuple.mb
			select (a, b);
	}

	[Pure]
	public static TryOptionAsync<(C, D)> Traverse<A, B, C, D>(this (TryOptionAsync<A> ma, TryOptionAsync<B> mb) tuple, Func<(A a, B b), (C c, D d)> f)
	{
		return Prelude.apply((A a, B b) => f((a, b)), tuple.ma, tuple.mb);
	}

	[Pure]
	public static TryOptionAsync<(C, D)> Traverse<A, B, C, D>(this (TryOptionAsync<A> ma, TryOptionAsync<B> mb) tuple, Func<A, B, (C c, D d)> f)
	{
		return Prelude.apply((A a, B b) => f(a, b), tuple.ma, tuple.mb);
	}

	[Pure]
	public static TryOptionAsync<(A, B)> Sequence<A, B>(this (TryOptionAsync<A> ma, TryOptionAsync<B> mb) tuple)
	{
		return Prelude.apply((A a, B b) => (a, b), tuple.ma, tuple.mb);
	}

	[Pure]
	public static Validation<MonoidFail, L, (C, D)> Traverse<MonoidFail, L, A, B, C, D>(this (Validation<MonoidFail, L, A> ma, Validation<MonoidFail, L, B> mb) tuple, Func<(A a, B b), (C c, D d)> f) where MonoidFail : struct, Monoid<L>, Eq<L>
	{
		return tuple.Apply((A a, B b) => f((a, b)));
	}

	[Pure]
	public static Validation<MonoidFail, L, (C, D)> Traverse<MonoidFail, L, A, B, C, D>(this (Validation<MonoidFail, L, A> ma, Validation<MonoidFail, L, B> mb) tuple, Func<A, B, (C c, D d)> f) where MonoidFail : struct, Monoid<L>, Eq<L>
	{
		return tuple.Apply(f);
	}

	[Pure]
	public static Validation<MonoidFail, L, (A, B)> Sequence<MonoidFail, L, A, B>(this (Validation<MonoidFail, L, A> ma, Validation<MonoidFail, L, B> mb) tuple) where MonoidFail : struct, Monoid<L>, Eq<L>
	{
		return tuple.Apply((A a, B b) => (a, b));
	}

	[Pure]
	public static Validation<L, (C, D)> Traverse<L, A, B, C, D>(this (Validation<L, A> ma, Validation<L, B> mb) tuple, Func<(A a, B b), (C c, D d)> f)
	{
		return tuple.Apply((A a, B b) => f((a, b)));
	}

	[Pure]
	public static Validation<L, (C, D)> Traverse<L, A, B, C, D>(this (Validation<L, A> ma, Validation<L, B> mb) tuple, Func<A, B, (C c, D d)> f)
	{
		return tuple.Apply(f);
	}

	[Pure]
	public static Validation<L, (A, B)> Sequence<L, A, B>(this (Validation<L, A> ma, Validation<L, B> mb) tuple)
	{
		return tuple.Apply((A a, B b) => (a, b));
	}
}
public static class ValueTuple3Extensions
{
	[Pure]
	public static (T1, T2, T3, T4) Add<T1, T2, T3, T4>(this (T1, T2, T3) self, T4 fourth)
	{
		return (self.Item1, self.Item2, self.Item3, fourth);
	}

	[Pure]
	public static (A, B, C) Append<SemiA, SemiB, SemiC, A, B, C>(this (A, B, C) a, (A, B, C) b) where SemiA : struct, Semigroup<A> where SemiB : struct, Semigroup<B> where SemiC : struct, Semigroup<C>
	{
		return (default(SemiA).Append(a.Item1, b.Item1), default(SemiB).Append(a.Item2, b.Item2), default(SemiC).Append(a.Item3, b.Item3));
	}

	[Pure]
	public static A Append<SemiA, A>(this (A, A, A) a) where SemiA : struct, Semigroup<A>
	{
		return default(SemiA).Append(a.Item1, default(SemiA).Append(a.Item2, a.Item3));
	}

	[Pure]
	public static (A, B, C) Concat<MonoidA, MonoidB, MonoidC, A, B, C>(this (A, B, C) a, (A, B, C) b) where MonoidA : struct, Monoid<A> where MonoidB : struct, Monoid<B> where MonoidC : struct, Monoid<C>
	{
		return (TypeClass.mconcat<MonoidA, A>(new A[2] { a.Item1, b.Item1 }), TypeClass.mconcat<MonoidB, B>(new B[2] { a.Item2, b.Item2 }), TypeClass.mconcat<MonoidC, C>(new C[2] { a.Item3, b.Item3 }));
	}

	[Pure]
	public static A Concat<MonoidA, A>(this (A, A, A) a) where MonoidA : struct, Monoid<A>
	{
		return TypeClass.mconcat<MonoidA, A>(new A[3] { a.Item1, a.Item2, a.Item3 });
	}

	[Pure]
	public static T1 Head<T1, T2, T3>(this (T1, T2, T3) self)
	{
		return self.Item1;
	}

	[Pure]
	public static T3 Last<T1, T2, T3>(this (T1, T2, T3) self)
	{
		return self.Item3;
	}

	[Pure]
	public static (T2, T3) Tail<T1, T2, T3>(this (T1, T2, T3) self)
	{
		return (self.Item2, self.Item3);
	}

	[Pure]
	public static A Sum<NUM, A>(this (A, A, A) self) where NUM : struct, Num<A>
	{
		return default(NUM).Plus(self.Item1, default(NUM).Plus(self.Item2, self.Item3));
	}

	[Pure]
	public static A Product<NUM, A>(this (A, A, A) self) where NUM : struct, Num<A>
	{
		return default(NUM).Product(self.Item1, default(NUM).Product(self.Item2, self.Item3));
	}

	[Pure]
	public static bool Contains<EQ, A>(this (A, A, A) self, A value) where EQ : struct, Eq<A>
	{
		if (!default(EQ).Equals(self.Item1, value) && !default(EQ).Equals(self.Item2, value))
		{
			return default(EQ).Equals(self.Item3, value);
		}
		return true;
	}

	[Pure]
	public static R Map<A, B, C, R>(this (A, B, C) self, Func<(A, B, C), R> map)
	{
		return map(self);
	}

	[Pure]
	public static R Map<A, B, C, R>(this (A, B, C) self, Func<A, B, C, R> map)
	{
		return map(self.Item1, self.Item2, self.Item3);
	}

	[Pure]
	public static (R1, R2, R3) Map<T1, T2, T3, R1, R2, R3>(this (T1, T2, T3) self, Func<T1, R1> firstMap, Func<T2, R2> secondMap, Func<T3, R3> thirdMap)
	{
		return (firstMap(self.Item1), secondMap(self.Item2), thirdMap(self.Item3));
	}

	[Pure]
	public static (R1, T2, T3) MapFirst<T1, T2, T3, R1>(this (T1, T2, T3) self, Func<T1, R1> firstMap)
	{
		return (firstMap(self.Item1), self.Item2, self.Item3);
	}

	[Pure]
	public static (T1, R2, T3) MapSecond<T1, T2, T3, R2>(this (T1, T2, T3) self, Func<T2, R2> secondMap)
	{
		return (self.Item1, secondMap(self.Item2), self.Item3);
	}

	[Pure]
	public static (T1, T2, R3) MapThird<T1, T2, T3, R3>(this (T1, T2, T3) self, Func<T3, R3> thirdMap)
	{
		return (self.Item1, self.Item2, thirdMap(self.Item3));
	}

	[Pure]
	public static (R1, R2, R3) Select<T1, T2, T3, R1, R2, R3>(this (T1, T2, T3) self, Func<(T1, T2, T3), (R1, R2, R3)> map)
	{
		return map(self);
	}

	public static Unit Iter<T1, T2, T3>(this (T1, T2, T3) self, Action<T1, T2, T3> func)
	{
		func(self.Item1, self.Item2, self.Item3);
		return Unit.Default;
	}

	public static Unit Iter<T1, T2, T3>(this (T1, T2, T3) self, Action<T1> first, Action<T2> second, Action<T3> third)
	{
		first(self.Item1);
		second(self.Item2);
		third(self.Item3);
		return Unit.Default;
	}

	[Pure]
	public static S Fold<T1, T2, T3, S>(this (T1, T2, T3) self, S state, Func<S, T1, T2, T3, S> fold)
	{
		return fold(state, self.Item1, self.Item2, self.Item3);
	}

	[Pure]
	public static S TriFold<T1, T2, T3, S>(this (T1, T2, T3) self, S state, Func<S, T1, S> firstFold, Func<S, T2, S> secondFold, Func<S, T3, S> thirdFold)
	{
		return thirdFold(secondFold(firstFold(state, self.Item1), self.Item2), self.Item3);
	}

	[Pure]
	public static S TriFoldBack<T1, T2, T3, S>(this (T1, T2, T3) self, S state, Func<S, T3, S> firstFold, Func<S, T2, S> secondFold, Func<S, T1, S> thirdFold)
	{
		return thirdFold(secondFold(firstFold(state, self.Item3), self.Item2), self.Item1);
	}
}
public static class ValueTuple4Extensions
{
	[Pure]
	public static (A, B, C, D, E) Add<A, B, C, D, E>(this (A, B, C, D) self, E fifth)
	{
		return (self.Item1, self.Item2, self.Item3, self.Item4, fifth);
	}

	[Pure]
	public static (A, B, C, D) Append<SemiA, SemiB, SemiC, SemiD, A, B, C, D>(this (A, B, C, D) a, (A, B, C, D) b) where SemiA : struct, Semigroup<A> where SemiB : struct, Semigroup<B> where SemiC : struct, Semigroup<C> where SemiD : struct, Semigroup<D>
	{
		return (default(SemiA).Append(a.Item1, b.Item1), default(SemiB).Append(a.Item2, b.Item2), default(SemiC).Append(a.Item3, b.Item3), default(SemiD).Append(a.Item4, b.Item4));
	}

	[Pure]
	public static A Append<SemiA, A>(this (A, A, A, A) a) where SemiA : struct, Semigroup<A>
	{
		return default(SemiA).Append(a.Item1, default(SemiA).Append(a.Item2, default(SemiA).Append(a.Item3, a.Item4)));
	}

	[Pure]
	public static (A, B, C, D) Concat<MonoidA, MonoidB, MonoidC, MonoidD, A, B, C, D>(this (A, B, C, D) a, (A, B, C, D) b) where MonoidA : struct, Monoid<A> where MonoidB : struct, Monoid<B> where MonoidC : struct, Monoid<C> where MonoidD : struct, Monoid<D>
	{
		return (TypeClass.mconcat<MonoidA, A>(new A[2] { a.Item1, b.Item1 }), TypeClass.mconcat<MonoidB, B>(new B[2] { a.Item2, b.Item2 }), TypeClass.mconcat<MonoidC, C>(new C[2] { a.Item3, b.Item3 }), TypeClass.mconcat<MonoidD, D>(new D[2] { a.Item4, b.Item4 }));
	}

	[Pure]
	public static A Concat<MonoidA, A>(this (A, A, A, A) a) where MonoidA : struct, Monoid<A>
	{
		return TypeClass.mconcat<MonoidA, A>(new A[4] { a.Item1, a.Item2, a.Item3, a.Item4 });
	}

	[Pure]
	public static A Head<A, B, C, D>(this (A, B, C, D) self)
	{
		return self.Item1;
	}

	[Pure]
	public static D Last<A, B, C, D>(this (A, B, C, D) self)
	{
		return self.Item4;
	}

	[Pure]
	public static (B, C, D) Tail<A, B, C, D>(this (A, B, C, D) self)
	{
		return (self.Item2, self.Item3, self.Item4);
	}

	[Pure]
	public static A Sum<NUM, A>(this (A, A, A, A) self) where NUM : struct, Num<A>
	{
		return TypeClass.sum<NUM, FoldTuple<A>, (A, A, A, A), A>(self);
	}

	[Pure]
	public static A Product<NUM, A>(this (A, A, A, A) self) where NUM : struct, Num<A>
	{
		return TypeClass.product<NUM, FoldTuple<A>, (A, A, A, A), A>(self);
	}

	[Pure]
	public static bool Contains<EQ, A>(this (A, A, A, A) self, A value) where EQ : struct, Eq<A>
	{
		if (!default(EQ).Equals(self.Item1, value) && !default(EQ).Equals(self.Item2, value) && !default(EQ).Equals(self.Item3, value))
		{
			return default(EQ).Equals(self.Item4, value);
		}
		return true;
	}

	[Pure]
	public static R Map<A, B, C, D, R>(this (A, B, C, D) self, Func<(A, B, C, D), R> map)
	{
		return map(self);
	}

	[Pure]
	public static R Map<A, B, C, D, R>(this (A, B, C, D) self, Func<A, B, C, D, R> map)
	{
		return map(self.Item1, self.Item2, self.Item3, self.Item4);
	}

	[Pure]
	public static (W, X, Y, Z) Map<A, B, C, D, W, X, Y, Z>(this (A, B, C, D) self, Func<A, W> firstMap, Func<B, X> secondMap, Func<C, Y> thirdMap, Func<D, Z> fourthMap)
	{
		return (firstMap(self.Item1), secondMap(self.Item2), thirdMap(self.Item3), fourthMap(self.Item4));
	}

	[Pure]
	public static (R1, B, C, D) MapFirst<A, B, C, D, R1>(this (A, B, C, D) self, Func<A, R1> firstMap)
	{
		return (firstMap(self.Item1), self.Item2, self.Item3, self.Item4);
	}

	[Pure]
	public static (A, R2, C, D) MapSecond<A, B, C, D, R2>(this (A, B, C, D) self, Func<B, R2> secondMap)
	{
		return (self.Item1, secondMap(self.Item2), self.Item3, self.Item4);
	}

	[Pure]
	public static (A, B, R3, D) MapThird<A, B, C, D, R3>(this (A, B, C, D) self, Func<C, R3> thirdMap)
	{
		return (self.Item1, self.Item2, thirdMap(self.Item3), self.Item4);
	}

	[Pure]
	public static (A, B, C, R4) MapFourth<A, B, C, D, R4>(this (A, B, C, D) self, Func<D, R4> fourthMap)
	{
		return (self.Item1, self.Item2, self.Item3, fourthMap(self.Item4));
	}

	[Pure]
	public static (W, X, Y, Z) Select<A, B, C, D, W, X, Y, Z>(this (A, B, C, D) self, Func<(A, B, C, D), (W, X, Y, Z)> map)
	{
		return map(self);
	}

	public static Unit Iter<A, B, C, D>(this (A, B, C, D) self, Action<A, B, C, D> func)
	{
		func(self.Item1, self.Item2, self.Item3, self.Item4);
		return Unit.Default;
	}

	public static Unit Iter<A, B, C, D>(this (A, B, C, D) self, Action<A> first, Action<B> second, Action<C> third, Action<D> fourth)
	{
		first(self.Item1);
		second(self.Item2);
		third(self.Item3);
		fourth(self.Item4);
		return Unit.Default;
	}

	[Pure]
	public static S Fold<A, B, C, D, S>(this (A, B, C, D) self, S state, Func<S, A, B, C, D, S> fold)
	{
		return fold(state, self.Item1, self.Item2, self.Item3, self.Item4);
	}

	[Pure]
	public static S QuadFold<A, B, C, D, S>(this (A, B, C, D) self, S state, Func<S, A, S> firstFold, Func<S, B, S> secondFold, Func<S, C, S> thirdFold, Func<S, D, S> fourthFold)
	{
		return fourthFold(thirdFold(secondFold(firstFold(state, self.Item1), self.Item2), self.Item3), self.Item4);
	}

	[Pure]
	public static S QuadFoldBack<A, B, C, D, S>(this (A, B, C, D) self, S state, Func<S, D, S> firstFold, Func<S, C, S> secondFold, Func<S, B, S> thirdFold, Func<S, A, S> fourthFold)
	{
		return fourthFold(thirdFold(secondFold(firstFold(state, self.Item4), self.Item3), self.Item2), self.Item1);
	}
}
public static class ValueTuple5Extensions
{
	[Pure]
	public static (A, B, C, D, E, F) Add<A, B, C, D, E, F>(this (A, B, C, D, E) self, F sixth)
	{
		return (self.Item1, self.Item2, self.Item3, self.Item4, self.Item5, sixth);
	}

	[Pure]
	public static (A, B, C, D, E) Append<SemiA, SemiB, SemiC, SemiD, SemiE, A, B, C, D, E>(this (A, B, C, D, E) a, (A, B, C, D, E) b) where SemiA : struct, Semigroup<A> where SemiB : struct, Semigroup<B> where SemiC : struct, Semigroup<C> where SemiD : struct, Semigroup<D> where SemiE : struct, Semigroup<E>
	{
		return (default(SemiA).Append(a.Item1, b.Item1), default(SemiB).Append(a.Item2, b.Item2), default(SemiC).Append(a.Item3, b.Item3), default(SemiD).Append(a.Item4, b.Item4), default(SemiE).Append(a.Item5, b.Item5));
	}

	[Pure]
	public static A Append<SemiA, A>(this (A, A, A, A, A) a) where SemiA : struct, Semigroup<A>
	{
		return default(SemiA).Append(a.Item1, default(SemiA).Append(a.Item2, default(SemiA).Append(a.Item3, default(SemiA).Append(a.Item4, a.Item5))));
	}

	[Pure]
	public static (A, B, C, D, E) Concat<MonoidA, MonoidB, MonoidC, MonoidD, MonoidE, A, B, C, D, E>(this (A, B, C, D, E) a, (A, B, C, D, E) b) where MonoidA : struct, Monoid<A> where MonoidB : struct, Monoid<B> where MonoidC : struct, Monoid<C> where MonoidD : struct, Monoid<D> where MonoidE : struct, Monoid<E>
	{
		return (TypeClass.mconcat<MonoidA, A>(new A[2] { a.Item1, b.Item1 }), TypeClass.mconcat<MonoidB, B>(new B[2] { a.Item2, b.Item2 }), TypeClass.mconcat<MonoidC, C>(new C[2] { a.Item3, b.Item3 }), TypeClass.mconcat<MonoidD, D>(new D[2] { a.Item4, b.Item4 }), TypeClass.mconcat<MonoidE, E>(new E[2] { a.Item5, b.Item5 }));
	}

	[Pure]
	public static A Concat<MonoidA, A>(this (A, A, A, A, A) a) where MonoidA : struct, Monoid<A>
	{
		return TypeClass.mconcat<MonoidA, A>(new A[5] { a.Item1, a.Item2, a.Item3, a.Item4, a.Item5 });
	}

	[Pure]
	public static A Head<A, B, C, D, E>(this (A, B, C, D, E) self)
	{
		return self.Item1;
	}

	[Pure]
	public static E Last<A, B, C, D, E>(this (A, B, C, D, E) self)
	{
		return self.Item5;
	}

	[Pure]
	public static (B, C, D, E) Tail<A, B, C, D, E>(this (A, B, C, D, E) self)
	{
		return (self.Item2, self.Item3, self.Item4, self.Item5);
	}

	[Pure]
	public static A Sum<NUM, A>(this (A, A, A, A, A) self) where NUM : struct, Num<A>
	{
		return TypeClass.sum<NUM, FoldTuple<A>, (A, A, A, A, A), A>(self);
	}

	[Pure]
	public static A Product<NUM, A>(this (A, A, A, A, A) self) where NUM : struct, Num<A>
	{
		return TypeClass.product<NUM, FoldTuple<A>, (A, A, A, A, A), A>(self);
	}

	[Pure]
	public static bool Contains<EQ, A>(this (A, A, A, A, A) self, A value) where EQ : struct, Eq<A>
	{
		if (!default(EQ).Equals(self.Item1, value) && !default(EQ).Equals(self.Item2, value) && !default(EQ).Equals(self.Item3, value) && !default(EQ).Equals(self.Item4, value))
		{
			return default(EQ).Equals(self.Item5, value);
		}
		return true;
	}

	[Pure]
	public static R Map<A, B, C, D, E, R>(this (A, B, C, D, E) self, Func<(A, B, C, D, E), R> map)
	{
		return map(self);
	}

	[Pure]
	public static R Map<A, B, C, D, E, R>(this (A, B, C, D, E) self, Func<A, B, C, D, E, R> map)
	{
		return map(self.Item1, self.Item2, self.Item3, self.Item4, self.Item5);
	}

	[Pure]
	public static (V, W, X, Y, Z) Map<A, B, C, D, E, V, W, X, Y, Z>(this (A, B, C, D, E) self, Func<A, V> firstMap, Func<B, W> secondMap, Func<C, X> thirdMap, Func<D, Y> fourthMap, Func<E, Z> fifthMap)
	{
		return (firstMap(self.Item1), secondMap(self.Item2), thirdMap(self.Item3), fourthMap(self.Item4), fifthMap(self.Item5));
	}

	[Pure]
	public static (R1, B, C, D, E) MapFirst<A, B, C, D, E, R1>(this (A, B, C, D, E) self, Func<A, R1> firstMap)
	{
		return (firstMap(self.Item1), self.Item2, self.Item3, self.Item4, self.Item5);
	}

	[Pure]
	public static (A, R2, C, D, E) MapSecond<A, B, C, D, E, R2>(this (A, B, C, D, E) self, Func<B, R2> secondMap)
	{
		return (self.Item1, secondMap(self.Item2), self.Item3, self.Item4, self.Item5);
	}

	[Pure]
	public static (A, B, R3, D, E) MapThird<A, B, C, D, E, R3>(this (A, B, C, D, E) self, Func<C, R3> thirdMap)
	{
		return (self.Item1, self.Item2, thirdMap(self.Item3), self.Item4, self.Item5);
	}

	[Pure]
	public static (A, B, C, R4, E) MapFourth<A, B, C, D, E, R4>(this (A, B, C, D, E) self, Func<D, R4> fourthMap)
	{
		return (self.Item1, self.Item2, self.Item3, fourthMap(self.Item4), self.Item5);
	}

	[Pure]
	public static (A, B, C, D, R5) MapFifth<A, B, C, D, E, R5>(this (A, B, C, D, E) self, Func<E, R5> fifthMap)
	{
		return (self.Item1, self.Item2, self.Item3, self.Item4, fifthMap(self.Item5));
	}

	[Pure]
	public static (V, W, X, Y, Z) Select<A, B, C, D, E, V, W, X, Y, Z>(this (A, B, C, D, E) self, Func<(A, B, C, D, E), (V, W, X, Y, Z)> map)
	{
		return map(self);
	}

	public static Unit Iter<A, B, C, D, E>(this (A, B, C, D, E) self, Action<A, B, C, D, E> func)
	{
		func(self.Item1, self.Item2, self.Item3, self.Item4, self.Item5);
		return Unit.Default;
	}

	public static Unit Iter<A, B, C, D, E>(this (A, B, C, D, E) self, Action<A> first, Action<B> second, Action<C> third, Action<D> fourth, Action<E> fifth)
	{
		first(self.Item1);
		second(self.Item2);
		third(self.Item3);
		fourth(self.Item4);
		fifth(self.Item5);
		return Unit.Default;
	}

	[Pure]
	public static S Fold<A, B, C, D, E, S>(this (A, B, C, D, E) self, S state, Func<S, A, B, C, D, E, S> fold)
	{
		return fold(state, self.Item1, self.Item2, self.Item3, self.Item4, self.Item5);
	}

	[Pure]
	public static S QuintFold<A, B, C, D, E, S>(this (A, B, C, D, E) self, S state, Func<S, A, S> firstFold, Func<S, B, S> secondFold, Func<S, C, S> thirdFold, Func<S, D, S> fourthFold, Func<S, E, S> fifthFold)
	{
		return fifthFold(fourthFold(thirdFold(secondFold(firstFold(state, self.Item1), self.Item2), self.Item3), self.Item4), self.Item5);
	}

	[Pure]
	public static S QuintFoldBack<A, B, C, D, E, S>(this (A, B, C, D, E) self, S state, Func<S, E, S> firstFold, Func<S, D, S> secondFold, Func<S, C, S> thirdFold, Func<S, B, S> fourthFold, Func<S, A, S> fifthFold)
	{
		return fifthFold(fourthFold(thirdFold(secondFold(firstFold(state, self.Item5), self.Item4), self.Item3), self.Item2), self.Item1);
	}
}
public static class ValueTuple6Extensions
{
	[Pure]
	public static (A, B, C, D, E, F, G) Add<A, B, C, D, E, F, G>(this (A, B, C, D, E, F) self, G seventh)
	{
		return (self.Item1, self.Item2, self.Item3, self.Item4, self.Item5, self.Item6, seventh);
	}

	[Pure]
	public static (A, B, C, D, E, F) Append<SemiA, SemiB, SemiC, SemiD, SemiE, SemiF, A, B, C, D, E, F>(this (A, B, C, D, E, F) a, (A, B, C, D, E, F) b) where SemiA : struct, Semigroup<A> where SemiB : struct, Semigroup<B> where SemiC : struct, Semigroup<C> where SemiD : struct, Semigroup<D> where SemiE : struct, Semigroup<E> where SemiF : struct, Semigroup<F>
	{
		return (default(SemiA).Append(a.Item1, b.Item1), default(SemiB).Append(a.Item2, b.Item2), default(SemiC).Append(a.Item3, b.Item3), default(SemiD).Append(a.Item4, b.Item4), default(SemiE).Append(a.Item5, b.Item5), default(SemiF).Append(a.Item6, b.Item6));
	}

	[Pure]
	public static A Append<SemiA, A>(this (A, A, A, A, A, A) a) where SemiA : struct, Semigroup<A>
	{
		return default(SemiA).Append(a.Item1, default(SemiA).Append(a.Item2, default(SemiA).Append(a.Item3, default(SemiA).Append(a.Item4, default(SemiA).Append(a.Item5, a.Item6)))));
	}

	[Pure]
	public static (A, B, C, D, E, F) Concat<MonoidA, MonoidB, MonoidC, MonoidD, MonoidE, MonoidF, A, B, C, D, E, F>(this (A, B, C, D, E, F) a, (A, B, C, D, E, F) b) where MonoidA : struct, Monoid<A> where MonoidB : struct, Monoid<B> where MonoidC : struct, Monoid<C> where MonoidD : struct, Monoid<D> where MonoidE : struct, Monoid<E> where MonoidF : struct, Monoid<F>
	{
		return (TypeClass.mconcat<MonoidA, A>(new A[2] { a.Item1, b.Item1 }), TypeClass.mconcat<MonoidB, B>(new B[2] { a.Item2, b.Item2 }), TypeClass.mconcat<MonoidC, C>(new C[2] { a.Item3, b.Item3 }), TypeClass.mconcat<MonoidD, D>(new D[2] { a.Item4, b.Item4 }), TypeClass.mconcat<MonoidE, E>(new E[2] { a.Item5, b.Item5 }), TypeClass.mconcat<MonoidF, F>(new F[2] { a.Item6, b.Item6 }));
	}

	[Pure]
	public static A Concat<MonoidA, A>(this (A, A, A, A, A, A) a) where MonoidA : struct, Monoid<A>
	{
		return TypeClass.mconcat<MonoidA, A>(new A[6] { a.Item1, a.Item2, a.Item3, a.Item4, a.Item5, a.Item6 });
	}

	[Pure]
	public static A Head<A, B, C, D, E, F>(this (A, B, C, D, E, F) self)
	{
		return self.Item1;
	}

	[Pure]
	public static F Last<A, B, C, D, E, F>(this (A, B, C, D, E, F) self)
	{
		return self.Item6;
	}

	[Pure]
	public static (B, C, D, E, F) Tail<A, B, C, D, E, F>(this (A, B, C, D, E, F) self)
	{
		return (self.Item2, self.Item3, self.Item4, self.Item5, self.Item6);
	}

	[Pure]
	public static A Sum<NUM, A>(this (A, A, A, A, A, A) self) where NUM : struct, Num<A>
	{
		return TypeClass.sum<NUM, FoldTuple<A>, (A, A, A, A, A, A), A>(self);
	}

	[Pure]
	public static A Product<NUM, A>(this (A, A, A, A, A, A) self) where NUM : struct, Num<A>
	{
		return TypeClass.product<NUM, FoldTuple<A>, (A, A, A, A, A, A), A>(self);
	}

	[Pure]
	public static bool Contains<EQ, A>(this (A, A, A, A, A, A) self, A value) where EQ : struct, Eq<A>
	{
		if (!default(EQ).Equals(self.Item1, value) && !default(EQ).Equals(self.Item2, value) && !default(EQ).Equals(self.Item3, value) && !default(EQ).Equals(self.Item4, value) && !default(EQ).Equals(self.Item5, value))
		{
			return default(EQ).Equals(self.Item6, value);
		}
		return true;
	}

	[Pure]
	public static R Map<A, B, C, D, E, F, R>(this (A, B, C, D, E, F) self, Func<(A, B, C, D, E, F), R> map)
	{
		return map(self);
	}

	[Pure]
	public static R Map<A, B, C, D, E, F, R>(this (A, B, C, D, E, F) self, Func<A, B, C, D, E, F, R> map)
	{
		return map(self.Item1, self.Item2, self.Item3, self.Item4, self.Item5, self.Item6);
	}

	[Pure]
	public static (U, V, W, X, Y, Z) Map<A, B, C, D, E, F, U, V, W, X, Y, Z>(this (A, B, C, D, E, F) self, Func<A, U> firstMap, Func<B, V> secondMap, Func<C, W> thirdMap, Func<D, X> fourthMap, Func<E, Y> fifthMap, Func<F, Z> sixthMap)
	{
		return (firstMap(self.Item1), secondMap(self.Item2), thirdMap(self.Item3), fourthMap(self.Item4), fifthMap(self.Item5), sixthMap(self.Item6));
	}

	[Pure]
	public static (R1, B, C, D, E, F) MapFirst<A, B, C, D, E, F, R1>(this (A, B, C, D, E, F) self, Func<A, R1> firstMap)
	{
		return (firstMap(self.Item1), self.Item2, self.Item3, self.Item4, self.Item5, self.Item6);
	}

	[Pure]
	public static (A, R2, C, D, E, F) MapSecond<A, B, C, D, E, F, R2>(this (A, B, C, D, E, F) self, Func<B, R2> secondMap)
	{
		return (self.Item1, secondMap(self.Item2), self.Item3, self.Item4, self.Item5, self.Item6);
	}

	[Pure]
	public static (A, B, R3, D, E, F) MapThird<A, B, C, D, E, F, R3>(this (A, B, C, D, E, F) self, Func<C, R3> thirdMap)
	{
		return (self.Item1, self.Item2, thirdMap(self.Item3), self.Item4, self.Item5, self.Item6);
	}

	[Pure]
	public static (A, B, C, R4, E, F) MapFourth<A, B, C, D, E, F, R4>(this (A, B, C, D, E, F) self, Func<D, R4> fourthMap)
	{
		return (self.Item1, self.Item2, self.Item3, fourthMap(self.Item4), self.Item5, self.Item6);
	}

	[Pure]
	public static (A, B, C, D, R5, F) MapFifth<A, B, C, D, E, F, R5>(this (A, B, C, D, E, F) self, Func<E, R5> fifthMap)
	{
		return (self.Item1, self.Item2, self.Item3, self.Item4, fifthMap(self.Item5), self.Item6);
	}

	[Pure]
	public static (A, B, C, D, E, R6) MapSixth<A, B, C, D, E, F, R6>(this (A, B, C, D, E, F) self, Func<F, R6> sixthMap)
	{
		return (self.Item1, self.Item2, self.Item3, self.Item4, self.Item5, sixthMap(self.Item6));
	}

	[Pure]
	public static (U, V, W, X, Y, Z) Select<A, B, C, D, E, F, U, V, W, X, Y, Z>(this (A, B, C, D, E, F) self, Func<(A, B, C, D, E, F), (U, V, W, X, Y, Z)> map)
	{
		return map(self);
	}

	public static Unit Iter<A, B, C, D, E, F>(this (A, B, C, D, E, F) self, Action<A, B, C, D, E, F> func)
	{
		func(self.Item1, self.Item2, self.Item3, self.Item4, self.Item5, self.Item6);
		return Unit.Default;
	}

	public static Unit Iter<A, B, C, D, E, F>(this (A, B, C, D, E, F) self, Action<A> first, Action<B> second, Action<C> third, Action<D> fourth, Action<E> fifth, Action<F> sixth)
	{
		first(self.Item1);
		second(self.Item2);
		third(self.Item3);
		fourth(self.Item4);
		fifth(self.Item5);
		sixth(self.Item6);
		return Unit.Default;
	}

	[Pure]
	public static S Fold<A, B, C, D, E, F, S>(this (A, B, C, D, E, F) self, S state, Func<S, A, B, C, D, E, F, S> fold)
	{
		return fold(state, self.Item1, self.Item2, self.Item3, self.Item4, self.Item5, self.Item6);
	}

	[Pure]
	public static S SextFold<A, B, C, D, E, F, S>(this (A, B, C, D, E, F) self, S state, Func<S, A, S> firstFold, Func<S, B, S> secondFold, Func<S, C, S> thirdFold, Func<S, D, S> fourthFold, Func<S, E, S> fifthFold, Func<S, F, S> sixthFold)
	{
		return sixthFold(fifthFold(fourthFold(thirdFold(secondFold(firstFold(state, self.Item1), self.Item2), self.Item3), self.Item4), self.Item5), self.Item6);
	}

	[Pure]
	public static S SextFoldBack<A, B, C, D, E, F, S>(this (A, B, C, D, E, F) self, S state, Func<S, F, S> firstFold, Func<S, E, S> secondFold, Func<S, D, S> thirdFold, Func<S, C, S> fourthFold, Func<S, B, S> fifthFold, Func<S, A, S> sixthFold)
	{
		return sixthFold(fifthFold(fourthFold(thirdFold(secondFold(firstFold(state, self.Item6), self.Item5), self.Item4), self.Item3), self.Item2), self.Item1);
	}
}
public static class ValueTuple7Extensions
{
	[Pure]
	public static (A, B, C, D, E, F, G, H) Add<A, B, C, D, E, F, G, H>(this (A, B, C, D, E, F, G) self, H eighth)
	{
		return (self.Item1, self.Item2, self.Item3, self.Item4, self.Item5, self.Item6, self.Item7, eighth);
	}

	[Pure]
	public static (A, B, C, D, E, F, G) Append<SemiA, SemiB, SemiC, SemiD, SemiE, SemiF, SemiG, A, B, C, D, E, F, G>(this (A, B, C, D, E, F, G) a, (A, B, C, D, E, F, G) b) where SemiA : struct, Semigroup<A> where SemiB : struct, Semigroup<B> where SemiC : struct, Semigroup<C> where SemiD : struct, Semigroup<D> where SemiE : struct, Semigroup<E> where SemiF : struct, Semigroup<F> where SemiG : struct, Semigroup<G>
	{
		return (default(SemiA).Append(a.Item1, b.Item1), default(SemiB).Append(a.Item2, b.Item2), default(SemiC).Append(a.Item3, b.Item3), default(SemiD).Append(a.Item4, b.Item4), default(SemiE).Append(a.Item5, b.Item5), default(SemiF).Append(a.Item6, b.Item6), default(SemiG).Append(a.Item7, b.Item7));
	}

	[Pure]
	public static A Append<SemiA, A>(this (A, A, A, A, A, A, A) a) where SemiA : struct, Semigroup<A>
	{
		return default(SemiA).Append(a.Item1, default(SemiA).Append(a.Item2, default(SemiA).Append(a.Item3, default(SemiA).Append(a.Item4, default(SemiA).Append(a.Item5, default(SemiA).Append(a.Item6, a.Item7))))));
	}

	[Pure]
	public static (A, B, C, D, E, F, G) Concat<MonoidA, MonoidB, MonoidC, MonoidD, MonoidE, MonoidF, MonoidG, A, B, C, D, E, F, G>(this (A, B, C, D, E, F, G) a, (A, B, C, D, E, F, G) b) where MonoidA : struct, Monoid<A> where MonoidB : struct, Monoid<B> where MonoidC : struct, Monoid<C> where MonoidD : struct, Monoid<D> where MonoidE : struct, Monoid<E> where MonoidF : struct, Monoid<F> where MonoidG : struct, Monoid<G>
	{
		return (TypeClass.mconcat<MonoidA, A>(new A[2] { a.Item1, b.Item1 }), TypeClass.mconcat<MonoidB, B>(new B[2] { a.Item2, b.Item2 }), TypeClass.mconcat<MonoidC, C>(new C[2] { a.Item3, b.Item3 }), TypeClass.mconcat<MonoidD, D>(new D[2] { a.Item4, b.Item4 }), TypeClass.mconcat<MonoidE, E>(new E[2] { a.Item5, b.Item5 }), TypeClass.mconcat<MonoidF, F>(new F[2] { a.Item6, b.Item6 }), TypeClass.mconcat<MonoidG, G>(new G[2] { a.Item7, b.Item7 }));
	}

	[Pure]
	public static A Concat<MonoidA, A>(this (A, A, A, A, A, A, A) a) where MonoidA : struct, Monoid<A>
	{
		return TypeClass.mconcat<MonoidA, A>(new A[7] { a.Item1, a.Item2, a.Item3, a.Item4, a.Item5, a.Item6, a.Item7 });
	}

	[Pure]
	public static A Head<A, B, C, D, E, F, G>(this (A, B, C, D, E, F, G) self)
	{
		return self.Item1;
	}

	[Pure]
	public static G Last<A, B, C, D, E, F, G>(this (A, B, C, D, E, F, G) self)
	{
		return self.Item7;
	}

	[Pure]
	public static (B, C, D, E, F, G) Tail<A, B, C, D, E, F, G>(this (A, B, C, D, E, F, G) self)
	{
		return (self.Item2, self.Item3, self.Item4, self.Item5, self.Item6, self.Item7);
	}

	[Pure]
	public static A Sum<NUM, A>(this (A, A, A, A, A, A, A) self) where NUM : struct, Num<A>
	{
		return TypeClass.sum<NUM, FoldTuple<A>, (A, A, A, A, A, A, A), A>(self);
	}

	[Pure]
	public static A Product<NUM, A>(this (A, A, A, A, A, A, A) self) where NUM : struct, Num<A>
	{
		return TypeClass.product<NUM, FoldTuple<A>, (A, A, A, A, A, A, A), A>(self);
	}

	[Pure]
	public static bool Contains<EQ, A>(this (A, A, A, A, A, A, A) self, A value) where EQ : struct, Eq<A>
	{
		if (!default(EQ).Equals(self.Item1, value) && !default(EQ).Equals(self.Item2, value) && !default(EQ).Equals(self.Item3, value) && !default(EQ).Equals(self.Item4, value) && !default(EQ).Equals(self.Item5, value) && !default(EQ).Equals(self.Item6, value))
		{
			return default(EQ).Equals(self.Item7, value);
		}
		return true;
	}

	[Pure]
	public static R Map<A, B, C, D, E, F, G, R>(this (A, B, C, D, E, F, G) self, Func<(A, B, C, D, E, F, G), R> map)
	{
		return map(self);
	}

	[Pure]
	public static R Map<A, B, C, D, E, F, G, R>(this (A, B, C, D, E, F, G) self, Func<A, B, C, D, E, F, G, R> map)
	{
		return map(self.Item1, self.Item2, self.Item3, self.Item4, self.Item5, self.Item6, self.Item7);
	}

	[Pure]
	public static (T, U, V, W, X, Y, Z) Map<A, B, C, D, E, F, G, T, U, V, W, X, Y, Z>(this (A, B, C, D, E, F, G) self, Func<A, T> firstMap, Func<B, U> secondMap, Func<C, V> thirdMap, Func<D, W> fourthMap, Func<E, X> fifthMap, Func<F, Y> sixthMap, Func<G, Z> seventhMap)
	{
		return (firstMap(self.Item1), secondMap(self.Item2), thirdMap(self.Item3), fourthMap(self.Item4), fifthMap(self.Item5), sixthMap(self.Item6), seventhMap(self.Item7));
	}

	[Pure]
	public static (R1, B, C, D, E, F, G) MapFirst<A, B, C, D, E, F, G, R1>(this (A, B, C, D, E, F, G) self, Func<A, R1> firstMap)
	{
		return (firstMap(self.Item1), self.Item2, self.Item3, self.Item4, self.Item5, self.Item6, self.Item7);
	}

	[Pure]
	public static (A, R2, C, D, E, F, G) MapSecond<A, B, C, D, E, F, G, R2>(this (A, B, C, D, E, F, G) self, Func<B, R2> secondMap)
	{
		return (self.Item1, secondMap(self.Item2), self.Item3, self.Item4, self.Item5, self.Item6, self.Item7);
	}

	[Pure]
	public static (A, B, R3, D, E, F, G) MapThird<A, B, C, D, E, F, G, R3>(this (A, B, C, D, E, F, G) self, Func<C, R3> thirdMap)
	{
		return (self.Item1, self.Item2, thirdMap(self.Item3), self.Item4, self.Item5, self.Item6, self.Item7);
	}

	[Pure]
	public static (A, B, C, R4, E, F, G) MapFourth<A, B, C, D, E, F, G, R4>(this (A, B, C, D, E, F, G) self, Func<D, R4> fourthMap)
	{
		return (self.Item1, self.Item2, self.Item3, fourthMap(self.Item4), self.Item5, self.Item6, self.Item7);
	}

	[Pure]
	public static (A, B, C, D, R5, F, G) MapFifth<A, B, C, D, E, F, G, R5>(this (A, B, C, D, E, F, G) self, Func<E, R5> fifthMap)
	{
		return (self.Item1, self.Item2, self.Item3, self.Item4, fifthMap(self.Item5), self.Item6, self.Item7);
	}

	[Pure]
	public static (A, B, C, D, E, R6, G) MapSixth<A, B, C, D, E, F, G, R6>(this (A, B, C, D, E, F, G) self, Func<F, R6> sixthMap)
	{
		return (self.Item1, self.Item2, self.Item3, self.Item4, self.Item5, sixthMap(self.Item6), self.Item7);
	}

	[Pure]
	public static (A, B, C, D, E, F, R7) MapSeventh<A, B, C, D, E, F, G, R7>(this (A, B, C, D, E, F, G) self, Func<G, R7> seventhMap)
	{
		return (self.Item1, self.Item2, self.Item3, self.Item4, self.Item5, self.Item6, seventhMap(self.Item7));
	}

	[Pure]
	public static (U, V, W, X, Y, Z) Select<A, B, C, D, E, F, G, U, V, W, X, Y, Z>(this (A, B, C, D, E, F, G) self, Func<(A, B, C, D, E, F, G), (U, V, W, X, Y, Z)> map)
	{
		return map(self);
	}

	public static Unit Iter<A, B, C, D, E, F, G>(this (A, B, C, D, E, F, G) self, Action<A, B, C, D, E, F, G> func)
	{
		func(self.Item1, self.Item2, self.Item3, self.Item4, self.Item5, self.Item6, self.Item7);
		return Unit.Default;
	}

	public static Unit Iter<A, B, C, D, E, F, G>(this (A, B, C, D, E, F, G) self, Action<A> first, Action<B> second, Action<C> third, Action<D> fourth, Action<E> fifth, Action<F> sixth, Action<G> seventh)
	{
		first(self.Item1);
		second(self.Item2);
		third(self.Item3);
		fourth(self.Item4);
		fifth(self.Item5);
		sixth(self.Item6);
		seventh(self.Item7);
		return Unit.Default;
	}

	[Pure]
	public static S Fold<A, B, C, D, E, F, G, S>(this (A, B, C, D, E, F, G) self, S state, Func<S, A, B, C, D, E, F, G, S> fold)
	{
		return fold(state, self.Item1, self.Item2, self.Item3, self.Item4, self.Item5, self.Item6, self.Item7);
	}

	[Pure]
	public static S SeptFold<A, B, C, D, E, F, G, S>(this (A, B, C, D, E, F, G) self, S state, Func<S, A, S> firstFold, Func<S, B, S> secondFold, Func<S, C, S> thirdFold, Func<S, D, S> fourthFold, Func<S, E, S> fifthFold, Func<S, F, S> sixthFold, Func<S, G, S> seventhFold)
	{
		return seventhFold(sixthFold(fifthFold(fourthFold(thirdFold(secondFold(firstFold(state, self.Item1), self.Item2), self.Item3), self.Item4), self.Item5), self.Item6), self.Item7);
	}

	[Pure]
	public static S SeptFoldBack<A, B, C, D, E, F, G, S>(this (A, B, C, D, E, F, G) self, S state, Func<S, G, S> firstFold, Func<S, F, S> secondFold, Func<S, E, S> thirdFold, Func<S, D, S> fourthFold, Func<S, C, S> fifthFold, Func<S, B, S> sixthFold, Func<S, A, S> seventhFold)
	{
		return seventhFold(sixthFold(fifthFold(fourthFold(thirdFold(secondFold(firstFold(state, self.Item7), self.Item6), self.Item5), self.Item4), self.Item3), self.Item2), self.Item1);
	}
}
public static class QueryExtensions
{
	public static T Head<T>(this IQueryable<T> list)
	{
		return Query.head(list);
	}

	public static Option<T> HeadOrNone<T>(this IQueryable<T> list)
	{
		return Query.headOrNone(list);
	}

	public static Validation<S, T> HeadOrInvalid<S, T>(this IQueryable<T> list, S fail)
	{
		return Query.headOrInvalid(list, fail);
	}

	public static Either<S, T> HeadOrLeft<S, T>(this IQueryable<T> list, S left)
	{
		return Query.headOrLeft(list, left);
	}

	public static IQueryable<T> Tail<T>(this IQueryable<T> list)
	{
		return Query.tail(list);
	}

	public static IQueryable<R> Map<T, R>(this IQueryable<T> list, Expression<Func<T, R>> map)
	{
		return Query.map(list, map);
	}

	public static IQueryable<R> Map<T, R>(this IQueryable<T> list, Expression<Func<int, T, R>> map)
	{
		return Query.map(list, map);
	}

	public static IQueryable<T> Filter<T>(this IQueryable<T> list, Expression<Func<T, bool>> predicate)
	{
		return Query.filter(list, predicate);
	}

	public static IQueryable<U> Choose<T, U>(this IQueryable<T> list, Expression<Func<T, Option<U>>> selector)
	{
		return Query.choose(list, selector);
	}

	public static IQueryable<U> Choose<T, U>(this IQueryable<T> list, Expression<Func<int, T, Option<U>>> selector)
	{
		return Query.choose(list, selector);
	}

	public static IQueryable<R> Collect<T, R>(this IQueryable<T> list, Expression<Func<T, IEnumerable<R>>> map)
	{
		return Query.collect(list, map);
	}

	public static IQueryable<T> Rev<T>(this IQueryable<T> list)
	{
		return Query.rev(list);
	}

	public static IQueryable<T> Append<T>(this IQueryable<T> lhs, IQueryable<T> rhs)
	{
		return Query.append(lhs, rhs);
	}

	public static S Fold<S, T>(this IQueryable<T> list, S state, Expression<Func<S, T, S>> folder)
	{
		return Query.fold(list, state, folder);
	}

	public static S FoldBack<S, T>(this IQueryable<T> list, S state, Expression<Func<S, T, S>> folder)
	{
		return Query.foldBack(list, state, folder);
	}

	public static T Reduce<T>(this IQueryable<T> list, Expression<Func<T, T, T>> reducer)
	{
		return Query.reduce(list, reducer);
	}

	public static T ReduceBack<T>(this IQueryable<T> list, Expression<Func<T, T, T>> reducer)
	{
		return Query.reduceBack(list, reducer);
	}

	public static Lst<T> Freeze<T>(this IQueryable<T> list)
	{
		return Query.freeze(list);
	}

	public static IQueryable<V> Zip<T, U, V>(this IQueryable<T> list, IEnumerable<U> other, Expression<Func<T, U, V>> zipper)
	{
		return Query.zip(list, other, zipper);
	}

	public static int Length<T>(this IQueryable<T> list)
	{
		return Query.length(list);
	}

	public static bool ForAll<T>(this IQueryable<T> list, Expression<Func<T, bool>> pred)
	{
		return Query.forall(list, pred);
	}

	public static IQueryable<T> Distinct<T>(this IQueryable<T> list)
	{
		return Query.distinct(list);
	}

	public static bool Exists<T>(this IQueryable<T> list, Expression<Func<T, bool>> pred)
	{
		return Query.exists(list, pred);
	}
}
public static class ArrExtensions
{
	[Pure]
	public static A[] Flatten<A>(this A[][] ma)
	{
		return ma.Bind(Prelude.identity).ToArray();
	}

	[Pure]
	public static Arr<A> Flatten<A>(this Arr<Arr<A>> ma)
	{
		return ma.Bind<A>(Prelude.identity);
	}

	[Pure]
	public static TAccumulate Aggregate<TSource, TAccumulate>(this Arr<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func)
	{
		return source.Value.Aggregate(seed, func);
	}

	[Pure]
	public static TResult Aggregate<TSource, TAccumulate, TResult>(this Arr<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func, Func<TAccumulate, TResult> resultSelector)
	{
		return source.Value.Aggregate(seed, func, resultSelector);
	}

	[Pure]
	public static TSource Aggregate<TSource>(this Arr<TSource> source, Func<TSource, TSource, TSource> func)
	{
		return source.Value.Aggregate(func);
	}

	[Pure]
	public static bool All<TSource>(this Arr<TSource> source, Func<TSource, bool> predicate)
	{
		return source.Value.All(predicate);
	}

	[Pure]
	public static bool Any<TSource>(this Arr<TSource> source)
	{
		return source.Value.Any();
	}

	[Pure]
	public static bool Any<TSource>(this Arr<TSource> source, Func<TSource, bool> predicate)
	{
		return source.Value.Any(predicate);
	}

	[Pure]
	public static IEnumerable<TSource> AsEnumerable<TSource>(this Arr<TSource> source)
	{
		return source.Value.AsEnumerable();
	}

	[Pure]
	public static IQueryable<TElement> AsQueryable<TElement>(this Arr<TElement> source)
	{
		return source.Value.AsQueryable().AsQueryable();
	}

	[Pure]
	public static decimal Average(this Arr<decimal> source)
	{
		return source.Value.Average();
	}

	[Pure]
	public static decimal Average<TSource>(this Arr<TSource> source, Func<TSource, decimal> selector)
	{
		return source.Value.Average(selector);
	}

	[Pure]
	public static decimal? Average(this Arr<decimal?> source)
	{
		return source.Value.Average();
	}

	[Pure]
	public static decimal? Average<TSource>(this Arr<TSource> source, Func<TSource, decimal?> selector)
	{
		return source.Value.Average(selector);
	}

	[Pure]
	public static double Average(this Arr<double> source)
	{
		return source.Value.Average();
	}

	[Pure]
	public static double Average(this Arr<int> source)
	{
		return source.Value.Average();
	}

	[Pure]
	public static double Average(this Arr<long> source)
	{
		return source.Value.Average();
	}

	[Pure]
	public static double Average<TSource>(this Arr<TSource> source, Func<TSource, double> selector)
	{
		return source.Value.Average(selector);
	}

	[Pure]
	public static double Average<TSource>(this Arr<TSource> source, Func<TSource, int> selector)
	{
		return source.Value.Average(selector);
	}

	[Pure]
	public static double Average<TSource>(this Arr<TSource> source, Func<TSource, long> selector)
	{
		return source.Value.Average(selector);
	}

	[Pure]
	public static double? Average(this Arr<double?> source)
	{
		return source.Value.Average();
	}

	[Pure]
	public static double? Average(this Arr<int?> source)
	{
		return source.Value.Average();
	}

	[Pure]
	public static double? Average(this Arr<long?> source)
	{
		return source.Value.Average();
	}

	[Pure]
	public static double? Average<TSource>(this Arr<TSource> source, Func<TSource, double?> selector)
	{
		return source.Value.Average(selector);
	}

	[Pure]
	public static double? Average<TSource>(this Arr<TSource> source, Func<TSource, int?> selector)
	{
		return source.Value.Average(selector);
	}

	[Pure]
	public static double? Average<TSource>(this Arr<TSource> source, Func<TSource, long?> selector)
	{
		return source.Value.Average(selector);
	}

	[Pure]
	public static float Average(this Arr<float> source)
	{
		return source.Value.Average();
	}

	[Pure]
	public static float Average<TSource>(this Arr<TSource> source, Func<TSource, float> selector)
	{
		return source.Value.Average(selector);
	}

	[Pure]
	public static float? Average(this Arr<float?> source)
	{
		return source.Value.Average();
	}

	[Pure]
	public static float? Average<TSource>(this Arr<TSource> source, Func<TSource, float?> selector)
	{
		return source.Value.Average(selector);
	}

	[Pure]
	public static IEnumerable<TSource> Concat<TSource>(this Arr<TSource> first, IEnumerable<TSource> second)
	{
		return first.Value.Concat(second);
	}

	[Pure]
	public static bool Contains<TSource>(this Arr<TSource> source, TSource value)
	{
		return source.Value.Contains(value);
	}

	[Pure]
	public static bool Contains<TSource>(this Arr<TSource> source, TSource value, IEqualityComparer<TSource> comparer)
	{
		return source.Value.Contains(value, comparer);
	}

	[Pure]
	public static int Count<TSource>(this Arr<TSource> source)
	{
		return source.Value.Count();
	}

	[Pure]
	public static int Count<TSource>(this Arr<TSource> source, Func<TSource, bool> predicate)
	{
		return source.Value.Count(predicate);
	}

	[Pure]
	public static IEnumerable<TSource> DefaultIfEmpty<TSource>(this Arr<TSource> source)
	{
		return source.Value.DefaultIfEmpty();
	}

	[Pure]
	public static IEnumerable<TSource> DefaultIfEmpty<TSource>(this Arr<TSource> source, TSource defaultValue)
	{
		return source.Value.DefaultIfEmpty(defaultValue);
	}

	[Pure]
	public static IEnumerable<TSource> Distinct<TSource>(this Arr<TSource> source)
	{
		return source.Value.Distinct();
	}

	[Pure]
	public static IEnumerable<TSource> Distinct<TSource>(this Arr<TSource> source, IEqualityComparer<TSource> comparer)
	{
		return source.Value.Distinct(comparer);
	}

	[Pure]
	public static TSource ElementAt<TSource>(this Arr<TSource> source, int index)
	{
		return source.Value.ElementAt(index);
	}

	[Pure]
	public static TSource ElementAtOrDefault<TSource>(this Arr<TSource> source, int index)
	{
		return source.Value.ElementAtOrDefault(index);
	}

	[Pure]
	public static IEnumerable<TSource> Except<TSource>(this Arr<TSource> first, IEnumerable<TSource> second)
	{
		return first.Value.Except(second);
	}

	[Pure]
	public static IEnumerable<TSource> Except<TSource>(this Arr<TSource> first, IEnumerable<TSource> second, IEquali