// @generated by gentuples.ts
package moe.nea.pcj;

@SuppressWarnings("unused")
public interface Tuple {
	class Tuple0 implements Tuple {
		public <R> R applyTo(Func0<R> func) {
			return func.apply();
		}

		public static <R> Result<Tuple0, R> collect(Tuple0 tuple) {
			return
					Result.ok(new Tuple0())
					;
		}

		public Tuple0 map() {
			return new Tuple0();
		}

		public Tuple0 join(Tuple0 other) {
			return new Tuple0();
		}

		public <E0> Tuple1<E0> join(Tuple1<E0> other) {
			return new Tuple1<>(other.element0);
		}

		public <E0, E1> Tuple2<E0, E1> join(Tuple2<E0, E1> other) {
			return new Tuple2<>(other.element0, other.element1);
		}

		public <E0, E1, E2> Tuple3<E0, E1, E2> join(Tuple3<E0, E1, E2> other) {
			return new Tuple3<>(other.element0, other.element1, other.element2);
		}

		public <E0, E1, E2, E3> Tuple4<E0, E1, E2, E3> join(Tuple4<E0, E1, E2, E3> other) {
			return new Tuple4<>(other.element0, other.element1, other.element2, other.element3);
		}

		public <E0, E1, E2, E3, E4> Tuple5<E0, E1, E2, E3, E4> join(Tuple5<E0, E1, E2, E3, E4> other) {
			return new Tuple5<>(other.element0, other.element1, other.element2, other.element3, other.element4);
		}

		public <E0, E1, E2, E3, E4, E5> Tuple6<E0, E1, E2, E3, E4, E5> join(Tuple6<E0, E1, E2, E3, E4, E5> other) {
			return new Tuple6<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5);
		}

		public <E0, E1, E2, E3, E4, E5, E6> Tuple7<E0, E1, E2, E3, E4, E5, E6> join(Tuple7<E0, E1, E2, E3, E4, E5, E6> other) {
			return new Tuple7<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6);
		}

		public <E0, E1, E2, E3, E4, E5, E6, E7> Tuple8<E0, E1, E2, E3, E4, E5, E6, E7> join(Tuple8<E0, E1, E2, E3, E4, E5, E6, E7> other) {
			return new Tuple8<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7);
		}

		public <E0, E1, E2, E3, E4, E5, E6, E7, E8> Tuple9<E0, E1, E2, E3, E4, E5, E6, E7, E8> join(Tuple9<E0, E1, E2, E3, E4, E5, E6, E7, E8> other) {
			return new Tuple9<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8);
		}

		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> Tuple10<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> join(Tuple10<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> other) {
			return new Tuple10<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9);
		}

		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> Tuple11<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> join(Tuple11<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> other) {
			return new Tuple11<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10);
		}

		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> Tuple12<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> join(Tuple12<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> other) {
			return new Tuple12<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10, other.element11);
		}

		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12> Tuple13<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12> join(Tuple13<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12> other) {
			return new Tuple13<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10, other.element11, other.element12);
		}

		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12, E13> Tuple14<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12, E13> join(Tuple14<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12, E13> other) {
			return new Tuple14<>(other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10, other.element11, other.element12, other.element13);
		}
	}

	@FunctionalInterface
	interface Func0<R> {
		R apply();
	}

	record Tuple1<T0>(T0 element0) {
		public <R> R applyTo(Func1<R, T0> func) {
			return func.apply(this.element0);
		}

		public static <R, T0> Result<Tuple1<T0>, R> collect(Tuple1<Result<T0, R>> tuple) {
			return
					tuple.element0.flatMap(element0 ->
							                       Result.ok(new Tuple1<>(element0))
					)
					;
		}

		public <E0> Tuple1<E0> map(Func1<E0, T0> map0) {
			return new Tuple1<>(map0.apply(this.element0));
		}

		public Tuple1<T0> join(Tuple0 other) {
			return new Tuple1<>(this.element0);
		}

		public <E0> Tuple2<T0, E0> join(Tuple1<E0> other) {
			return new Tuple2<>(this.element0, other.element0);
		}

		public <E0, E1> Tuple3<T0, E0, E1> join(Tuple2<E0, E1> other) {
			return new Tuple3<>(this.element0, other.element0, other.element1);
		}

		public <E0, E1, E2> Tuple4<T0, E0, E1, E2> join(Tuple3<E0, E1, E2> other) {
			return new Tuple4<>(this.element0, other.element0, other.element1, other.element2);
		}

		public <E0, E1, E2, E3> Tuple5<T0, E0, E1, E2, E3> join(Tuple4<E0, E1, E2, E3> other) {
			return new Tuple5<>(this.element0, other.element0, other.element1, other.element2, other.element3);
		}

		public <E0, E1, E2, E3, E4> Tuple6<T0, E0, E1, E2, E3, E4> join(Tuple5<E0, E1, E2, E3, E4> other) {
			return new Tuple6<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4);
		}

		public <E0, E1, E2, E3, E4, E5> Tuple7<T0, E0, E1, E2, E3, E4, E5> join(Tuple6<E0, E1, E2, E3, E4, E5> other) {
			return new Tuple7<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5);
		}

		public <E0, E1, E2, E3, E4, E5, E6> Tuple8<T0, E0, E1, E2, E3, E4, E5, E6> join(Tuple7<E0, E1, E2, E3, E4, E5, E6> other) {
			return new Tuple8<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6);
		}

		public <E0, E1, E2, E3, E4, E5, E6, E7> Tuple9<T0, E0, E1, E2, E3, E4, E5, E6, E7> join(Tuple8<E0, E1, E2, E3, E4, E5, E6, E7> other) {
			return new Tuple9<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7);
		}

		public <E0, E1, E2, E3, E4, E5, E6, E7, E8> Tuple10<T0, E0, E1, E2, E3, E4, E5, E6, E7, E8> join(Tuple9<E0, E1, E2, E3, E4, E5, E6, E7, E8> other) {
			return new Tuple10<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8);
		}

		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> Tuple11<T0, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> join(Tuple10<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> other) {
			return new Tuple11<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9);
		}

		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> Tuple12<T0, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> join(Tuple11<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> other) {
			return new Tuple12<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10);
		}

		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> Tuple13<T0, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> join(Tuple12<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> other) {
			return new Tuple13<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10, other.element11);
		}

		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12> Tuple14<T0, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12> join(Tuple13<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12> other) {
			return new Tuple14<>(this.element0, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10, other.element11, other.element12);
		}
	}

	@FunctionalInterface
	interface Func1<R, T0> {
		R apply(T0 arg0);
	}

	record Tuple2<T0, T1>(T0 element0, T1 element1) {
		public <R> R applyTo(Func2<R, T0, T1> func) {
			return func.apply(this.element0, this.element1);
		}

		public static <R, T0, T1> Result<Tuple2<T0, T1>, R> collect(Tuple2<Result<T0, R>, Result<T1, R>> tuple) {
			return
					tuple.element0.flatMap(element0 ->
							                       tuple.element1.flatMap(element1 ->
									                                              Result.ok(new Tuple2<>(element0, element1))
							                       )
					)
					;
		}

		public <E0, E1> Tuple2<E0, E1> map(Func1<E0, T0> map0, Func1<E1, T1> map1) {
			return new Tuple2<>(map0.apply(this.element0), map1.apply(this.element1));
		}

		public Tuple2<T0, T1> join(Tuple0 other) {
			return new Tuple2<>(this.element0, this.element1);
		}

		public <E0> Tuple3<T0, T1, E0> join(Tuple1<E0> other) {
			return new Tuple3<>(this.element0, this.element1, other.element0);
		}

		public <E0, E1> Tuple4<T0, T1, E0, E1> join(Tuple2<E0, E1> other) {
			return new Tuple4<>(this.element0, this.element1, other.element0, other.element1);
		}

		public <E0, E1, E2> Tuple5<T0, T1, E0, E1, E2> join(Tuple3<E0, E1, E2> other) {
			return new Tuple5<>(this.element0, this.element1, other.element0, other.element1, other.element2);
		}

		public <E0, E1, E2, E3> Tuple6<T0, T1, E0, E1, E2, E3> join(Tuple4<E0, E1, E2, E3> other) {
			return new Tuple6<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3);
		}

		public <E0, E1, E2, E3, E4> Tuple7<T0, T1, E0, E1, E2, E3, E4> join(Tuple5<E0, E1, E2, E3, E4> other) {
			return new Tuple7<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3, other.element4);
		}

		public <E0, E1, E2, E3, E4, E5> Tuple8<T0, T1, E0, E1, E2, E3, E4, E5> join(Tuple6<E0, E1, E2, E3, E4, E5> other) {
			return new Tuple8<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5);
		}

		public <E0, E1, E2, E3, E4, E5, E6> Tuple9<T0, T1, E0, E1, E2, E3, E4, E5, E6> join(Tuple7<E0, E1, E2, E3, E4, E5, E6> other) {
			return new Tuple9<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6);
		}

		public <E0, E1, E2, E3, E4, E5, E6, E7> Tuple10<T0, T1, E0, E1, E2, E3, E4, E5, E6, E7> join(Tuple8<E0, E1, E2, E3, E4, E5, E6, E7> other) {
			return new Tuple10<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7);
		}

		public <E0, E1, E2, E3, E4, E5, E6, E7, E8> Tuple11<T0, T1, E0, E1, E2, E3, E4, E5, E6, E7, E8> join(Tuple9<E0, E1, E2, E3, E4, E5, E6, E7, E8> other) {
			return new Tuple11<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8);
		}

		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> Tuple12<T0, T1, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> join(Tuple10<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> other) {
			return new Tuple12<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9);
		}

		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> Tuple13<T0, T1, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> join(Tuple11<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> other) {
			return new Tuple13<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10);
		}

		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> Tuple14<T0, T1, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> join(Tuple12<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> other) {
			return new Tuple14<>(this.element0, this.element1, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10, other.element11);
		}
	}

	@FunctionalInterface
	interface Func2<R, T0, T1> {
		R apply(T0 arg0, T1 arg1);
	}

	record Tuple3<T0, T1, T2>(T0 element0, T1 element1, T2 element2) {
		public <R> R applyTo(Func3<R, T0, T1, T2> func) {
			return func.apply(this.element0, this.element1, this.element2);
		}

		public static <R, T0, T1, T2> Result<Tuple3<T0, T1, T2>, R> collect(Tuple3<Result<T0, R>, Result<T1, R>, Result<T2, R>> tuple) {
			return
					tuple.element0.flatMap(element0 ->
							                       tuple.element1.flatMap(element1 ->
									                                              tuple.element2.flatMap(element2 ->
											                                                                     Result.ok(new Tuple3<>(element0, element1, element2))
									                                              )
							                       )
					)
					;
		}

		public <E0, E1, E2> Tuple3<E0, E1, E2> map(Func1<E0, T0> map0, Func1<E1, T1> map1, Func1<E2, T2> map2) {
			return new Tuple3<>(map0.apply(this.element0), map1.apply(this.element1), map2.apply(this.element2));
		}

		public Tuple3<T0, T1, T2> join(Tuple0 other) {
			return new Tuple3<>(this.element0, this.element1, this.element2);
		}

		public <E0> Tuple4<T0, T1, T2, E0> join(Tuple1<E0> other) {
			return new Tuple4<>(this.element0, this.element1, this.element2, other.element0);
		}

		public <E0, E1> Tuple5<T0, T1, T2, E0, E1> join(Tuple2<E0, E1> other) {
			return new Tuple5<>(this.element0, this.element1, this.element2, other.element0, other.element1);
		}

		public <E0, E1, E2> Tuple6<T0, T1, T2, E0, E1, E2> join(Tuple3<E0, E1, E2> other) {
			return new Tuple6<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2);
		}

		public <E0, E1, E2, E3> Tuple7<T0, T1, T2, E0, E1, E2, E3> join(Tuple4<E0, E1, E2, E3> other) {
			return new Tuple7<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2, other.element3);
		}

		public <E0, E1, E2, E3, E4> Tuple8<T0, T1, T2, E0, E1, E2, E3, E4> join(Tuple5<E0, E1, E2, E3, E4> other) {
			return new Tuple8<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2, other.element3, other.element4);
		}

		public <E0, E1, E2, E3, E4, E5> Tuple9<T0, T1, T2, E0, E1, E2, E3, E4, E5> join(Tuple6<E0, E1, E2, E3, E4, E5> other) {
			return new Tuple9<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5);
		}

		public <E0, E1, E2, E3, E4, E5, E6> Tuple10<T0, T1, T2, E0, E1, E2, E3, E4, E5, E6> join(Tuple7<E0, E1, E2, E3, E4, E5, E6> other) {
			return new Tuple10<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6);
		}

		public <E0, E1, E2, E3, E4, E5, E6, E7> Tuple11<T0, T1, T2, E0, E1, E2, E3, E4, E5, E6, E7> join(Tuple8<E0, E1, E2, E3, E4, E5, E6, E7> other) {
			return new Tuple11<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7);
		}

		public <E0, E1, E2, E3, E4, E5, E6, E7, E8> Tuple12<T0, T1, T2, E0, E1, E2, E3, E4, E5, E6, E7, E8> join(Tuple9<E0, E1, E2, E3, E4, E5, E6, E7, E8> other) {
			return new Tuple12<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8);
		}

		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> Tuple13<T0, T1, T2, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> join(Tuple10<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> other) {
			return new Tuple13<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9);
		}

		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> Tuple14<T0, T1, T2, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> join(Tuple11<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> other) {
			return new Tuple14<>(this.element0, this.element1, this.element2, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9, other.element10);
		}
	}

	@FunctionalInterface
	interface Func3<R, T0, T1, T2> {
		R apply(T0 arg0, T1 arg1, T2 arg2);
	}

	record Tuple4<T0, T1, T2, T3>(T0 element0, T1 element1, T2 element2, T3 element3) {
		public <R> R applyTo(Func4<R, T0, T1, T2, T3> func) {
			return func.apply(this.element0, this.element1, this.element2, this.element3);
		}

		public static <R, T0, T1, T2, T3> Result<Tuple4<T0, T1, T2, T3>, R> collect(Tuple4<Result<T0, R>, Result<T1, R>, Result<T2, R>, Result<T3, R>> tuple) {
			return
					tuple.element0.flatMap(element0 ->
							                       tuple.element1.flatMap(element1 ->
									                                              tuple.element2.flatMap(element2 ->
											                                                                     tuple.element3.flatMap(element3 ->
													                                                                                            Result.ok(new Tuple4<>(element0, element1, element2, element3))
											                                                                     )
									                                              )
							                       )
					)
					;
		}

		public <E0, E1, E2, E3> Tuple4<E0, E1, E2, E3> map(Func1<E0, T0> map0, Func1<E1, T1> map1, Func1<E2, T2> map2, Func1<E3, T3> map3) {
			return new Tuple4<>(map0.apply(this.element0), map1.apply(this.element1), map2.apply(this.element2), map3.apply(this.element3));
		}

		public Tuple4<T0, T1, T2, T3> join(Tuple0 other) {
			return new Tuple4<>(this.element0, this.element1, this.element2, this.element3);
		}

		public <E0> Tuple5<T0, T1, T2, T3, E0> join(Tuple1<E0> other) {
			return new Tuple5<>(this.element0, this.element1, this.element2, this.element3, other.element0);
		}

		public <E0, E1> Tuple6<T0, T1, T2, T3, E0, E1> join(Tuple2<E0, E1> other) {
			return new Tuple6<>(this.element0, this.element1, this.element2, this.element3, other.element0, other.element1);
		}

		public <E0, E1, E2> Tuple7<T0, T1, T2, T3, E0, E1, E2> join(Tuple3<E0, E1, E2> other) {
			return new Tuple7<>(this.element0, this.element1, this.element2, this.element3, other.element0, other.element1, other.element2);
		}

		public <E0, E1, E2, E3> Tuple8<T0, T1, T2, T3, E0, E1, E2, E3> join(Tuple4<E0, E1, E2, E3> other) {
			return new Tuple8<>(this.element0, this.element1, this.element2, this.element3, other.element0, other.element1, other.element2, other.element3);
		}

		public <E0, E1, E2, E3, E4> Tuple9<T0, T1, T2, T3, E0, E1, E2, E3, E4> join(Tuple5<E0, E1, E2, E3, E4> other) {
			return new Tuple9<>(this.element0, this.element1, this.element2, this.element3, other.element0, other.element1, other.element2, other.element3, other.element4);
		}

		public <E0, E1, E2, E3, E4, E5> Tuple10<T0, T1, T2, T3, E0, E1, E2, E3, E4, E5> join(Tuple6<E0, E1, E2, E3, E4, E5> other) {
			return new Tuple10<>(this.element0, this.element1, this.element2, this.element3, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5);
		}

		public <E0, E1, E2, E3, E4, E5, E6> Tuple11<T0, T1, T2, T3, E0, E1, E2, E3, E4, E5, E6> join(Tuple7<E0, E1, E2, E3, E4, E5, E6> other) {
			return new Tuple11<>(this.element0, this.element1, this.element2, this.element3, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6);
		}

		public <E0, E1, E2, E3, E4, E5, E6, E7> Tuple12<T0, T1, T2, T3, E0, E1, E2, E3, E4, E5, E6, E7> join(Tuple8<E0, E1, E2, E3, E4, E5, E6, E7> other) {
			return new Tuple12<>(this.element0, this.element1, this.element2, this.element3, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7);
		}

		public <E0, E1, E2, E3, E4, E5, E6, E7, E8> Tuple13<T0, T1, T2, T3, E0, E1, E2, E3, E4, E5, E6, E7, E8> join(Tuple9<E0, E1, E2, E3, E4, E5, E6, E7, E8> other) {
			return new Tuple13<>(this.element0, this.element1, this.element2, this.element3, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8);
		}

		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> Tuple14<T0, T1, T2, T3, E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> join(Tuple10<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> other) {
			return new Tuple14<>(this.element0, this.element1, this.element2, this.element3, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8, other.element9);
		}
	}

	@FunctionalInterface
	interface Func4<R, T0, T1, T2, T3> {
		R apply(T0 arg0, T1 arg1, T2 arg2, T3 arg3);
	}

	record Tuple5<T0, T1, T2, T3, T4>(T0 element0, T1 element1, T2 element2, T3 element3, T4 element4) {
		public <R> R applyTo(Func5<R, T0, T1, T2, T3, T4> func) {
			return func.apply(this.element0, this.element1, this.element2, this.element3, this.element4);
		}

		public static <R, T0, T1, T2, T3, T4> Result<Tuple5<T0, T1, T2, T3, T4>, R> collect(Tuple5<Result<T0, R>, Result<T1, R>, Result<T2, R>, Result<T3, R>, Result<T4, R>> tuple) {
			return
					tuple.element0.flatMap(element0 ->
							                       tuple.element1.flatMap(element1 ->
									                                              tuple.element2.flatMap(element2 ->
											                                                                     tuple.element3.flatMap(element3 ->
													                                                                                            tuple.element4.flatMap(element4 ->
															                                                                                                                   Result.ok(new Tuple5<>(element0, element1, element2, element3, element4))
													                                                                                            )
											                                                                     )
									                                              )
							                       )
					)
					;
		}

		public <E0, E1, E2, E3, E4> Tuple5<E0, E1, E2, E3, E4> map(Func1<E0, T0> map0, Func1<E1, T1> map1, Func1<E2, T2> map2, Func1<E3, T3> map3, Func1<E4, T4> map4) {
			return new Tuple5<>(map0.apply(this.element0), map1.apply(this.element1), map2.apply(this.element2), map3.apply(this.element3), map4.apply(this.element4));
		}

		public Tuple5<T0, T1, T2, T3, T4> join(Tuple0 other) {
			return new Tuple5<>(this.element0, this.element1, this.element2, this.element3, this.element4);
		}

		public <E0> Tuple6<T0, T1, T2, T3, T4, E0> join(Tuple1<E0> other) {
			return new Tuple6<>(this.element0, this.element1, this.element2, this.element3, this.element4, other.element0);
		}

		public <E0, E1> Tuple7<T0, T1, T2, T3, T4, E0, E1> join(Tuple2<E0, E1> other) {
			return new Tuple7<>(this.element0, this.element1, this.element2, this.element3, this.element4, other.element0, other.element1);
		}

		public <E0, E1, E2> Tuple8<T0, T1, T2, T3, T4, E0, E1, E2> join(Tuple3<E0, E1, E2> other) {
			return new Tuple8<>(this.element0, this.element1, this.element2, this.element3, this.element4, other.element0, other.element1, other.element2);
		}

		public <E0, E1, E2, E3> Tuple9<T0, T1, T2, T3, T4, E0, E1, E2, E3> join(Tuple4<E0, E1, E2, E3> other) {
			return new Tuple9<>(this.element0, this.element1, this.element2, this.element3, this.element4, other.element0, other.element1, other.element2, other.element3);
		}

		public <E0, E1, E2, E3, E4> Tuple10<T0, T1, T2, T3, T4, E0, E1, E2, E3, E4> join(Tuple5<E0, E1, E2, E3, E4> other) {
			return new Tuple10<>(this.element0, this.element1, this.element2, this.element3, this.element4, other.element0, other.element1, other.element2, other.element3, other.element4);
		}

		public <E0, E1, E2, E3, E4, E5> Tuple11<T0, T1, T2, T3, T4, E0, E1, E2, E3, E4, E5> join(Tuple6<E0, E1, E2, E3, E4, E5> other) {
			return new Tuple11<>(this.element0, this.element1, this.element2, this.element3, this.element4, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5);
		}

		public <E0, E1, E2, E3, E4, E5, E6> Tuple12<T0, T1, T2, T3, T4, E0, E1, E2, E3, E4, E5, E6> join(Tuple7<E0, E1, E2, E3, E4, E5, E6> other) {
			return new Tuple12<>(this.element0, this.element1, this.element2, this.element3, this.element4, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6);
		}

		public <E0, E1, E2, E3, E4, E5, E6, E7> Tuple13<T0, T1, T2, T3, T4, E0, E1, E2, E3, E4, E5, E6, E7> join(Tuple8<E0, E1, E2, E3, E4, E5, E6, E7> other) {
			return new Tuple13<>(this.element0, this.element1, this.element2, this.element3, this.element4, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7);
		}

		public <E0, E1, E2, E3, E4, E5, E6, E7, E8> Tuple14<T0, T1, T2, T3, T4, E0, E1, E2, E3, E4, E5, E6, E7, E8> join(Tuple9<E0, E1, E2, E3, E4, E5, E6, E7, E8> other) {
			return new Tuple14<>(this.element0, this.element1, this.element2, this.element3, this.element4, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7, other.element8);
		}
	}

	@FunctionalInterface
	interface Func5<R, T0, T1, T2, T3, T4> {
		R apply(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4);
	}

	record Tuple6<T0, T1, T2, T3, T4, T5>(T0 element0, T1 element1, T2 element2, T3 element3, T4 element4,
	                                      T5 element5) {
		public <R> R applyTo(Func6<R, T0, T1, T2, T3, T4, T5> func) {
			return func.apply(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5);
		}

		public static <R, T0, T1, T2, T3, T4, T5> Result<Tuple6<T0, T1, T2, T3, T4, T5>, R> collect(Tuple6<Result<T0, R>, Result<T1, R>, Result<T2, R>, Result<T3, R>, Result<T4, R>, Result<T5, R>> tuple) {
			return
					tuple.element0.flatMap(element0 ->
							                       tuple.element1.flatMap(element1 ->
									                                              tuple.element2.flatMap(element2 ->
											                                                                     tuple.element3.flatMap(element3 ->
													                                                                                            tuple.element4.flatMap(element4 ->
															                                                                                                                   tuple.element5.flatMap(element5 ->
																	                                                                                                                                          Result.ok(new Tuple6<>(element0, element1, element2, element3, element4, element5))
															                                                                                                                   )
													                                                                                            )
											                                                                     )
									                                              )
							                       )
					)
					;
		}

		public <E0, E1, E2, E3, E4, E5> Tuple6<E0, E1, E2, E3, E4, E5> map(Func1<E0, T0> map0, Func1<E1, T1> map1, Func1<E2, T2> map2, Func1<E3, T3> map3, Func1<E4, T4> map4, Func1<E5, T5> map5) {
			return new Tuple6<>(map0.apply(this.element0), map1.apply(this.element1), map2.apply(this.element2), map3.apply(this.element3), map4.apply(this.element4), map5.apply(this.element5));
		}

		public Tuple6<T0, T1, T2, T3, T4, T5> join(Tuple0 other) {
			return new Tuple6<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5);
		}

		public <E0> Tuple7<T0, T1, T2, T3, T4, T5, E0> join(Tuple1<E0> other) {
			return new Tuple7<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, other.element0);
		}

		public <E0, E1> Tuple8<T0, T1, T2, T3, T4, T5, E0, E1> join(Tuple2<E0, E1> other) {
			return new Tuple8<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, other.element0, other.element1);
		}

		public <E0, E1, E2> Tuple9<T0, T1, T2, T3, T4, T5, E0, E1, E2> join(Tuple3<E0, E1, E2> other) {
			return new Tuple9<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, other.element0, other.element1, other.element2);
		}

		public <E0, E1, E2, E3> Tuple10<T0, T1, T2, T3, T4, T5, E0, E1, E2, E3> join(Tuple4<E0, E1, E2, E3> other) {
			return new Tuple10<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, other.element0, other.element1, other.element2, other.element3);
		}

		public <E0, E1, E2, E3, E4> Tuple11<T0, T1, T2, T3, T4, T5, E0, E1, E2, E3, E4> join(Tuple5<E0, E1, E2, E3, E4> other) {
			return new Tuple11<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, other.element0, other.element1, other.element2, other.element3, other.element4);
		}

		public <E0, E1, E2, E3, E4, E5> Tuple12<T0, T1, T2, T3, T4, T5, E0, E1, E2, E3, E4, E5> join(Tuple6<E0, E1, E2, E3, E4, E5> other) {
			return new Tuple12<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5);
		}

		public <E0, E1, E2, E3, E4, E5, E6> Tuple13<T0, T1, T2, T3, T4, T5, E0, E1, E2, E3, E4, E5, E6> join(Tuple7<E0, E1, E2, E3, E4, E5, E6> other) {
			return new Tuple13<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6);
		}

		public <E0, E1, E2, E3, E4, E5, E6, E7> Tuple14<T0, T1, T2, T3, T4, T5, E0, E1, E2, E3, E4, E5, E6, E7> join(Tuple8<E0, E1, E2, E3, E4, E5, E6, E7> other) {
			return new Tuple14<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6, other.element7);
		}
	}

	@FunctionalInterface
	interface Func6<R, T0, T1, T2, T3, T4, T5> {
		R apply(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5);
	}

	record Tuple7<T0, T1, T2, T3, T4, T5, T6>(T0 element0, T1 element1, T2 element2, T3 element3, T4 element4,
	                                          T5 element5, T6 element6) {
		public <R> R applyTo(Func7<R, T0, T1, T2, T3, T4, T5, T6> func) {
			return func.apply(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6);
		}

		public static <R, T0, T1, T2, T3, T4, T5, T6> Result<Tuple7<T0, T1, T2, T3, T4, T5, T6>, R> collect(Tuple7<Result<T0, R>, Result<T1, R>, Result<T2, R>, Result<T3, R>, Result<T4, R>, Result<T5, R>, Result<T6, R>> tuple) {
			return
					tuple.element0.flatMap(element0 ->
							                       tuple.element1.flatMap(element1 ->
									                                              tuple.element2.flatMap(element2 ->
											                                                                     tuple.element3.flatMap(element3 ->
													                                                                                            tuple.element4.flatMap(element4 ->
															                                                                                                                   tuple.element5.flatMap(element5 ->
																	                                                                                                                                          tuple.element6.flatMap(element6 ->
																			                                                                                                                                                                 Result.ok(new Tuple7<>(element0, element1, element2, element3, element4, element5, element6))
																	                                                                                                                                          )
															                                                                                                                   )
													                                                                                            )
											                                                                     )
									                                              )
							                       )
					)
					;
		}

		public <E0, E1, E2, E3, E4, E5, E6> Tuple7<E0, E1, E2, E3, E4, E5, E6> map(Func1<E0, T0> map0, Func1<E1, T1> map1, Func1<E2, T2> map2, Func1<E3, T3> map3, Func1<E4, T4> map4, Func1<E5, T5> map5, Func1<E6, T6> map6) {
			return new Tuple7<>(map0.apply(this.element0), map1.apply(this.element1), map2.apply(this.element2), map3.apply(this.element3), map4.apply(this.element4), map5.apply(this.element5), map6.apply(this.element6));
		}

		public Tuple7<T0, T1, T2, T3, T4, T5, T6> join(Tuple0 other) {
			return new Tuple7<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6);
		}

		public <E0> Tuple8<T0, T1, T2, T3, T4, T5, T6, E0> join(Tuple1<E0> other) {
			return new Tuple8<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, other.element0);
		}

		public <E0, E1> Tuple9<T0, T1, T2, T3, T4, T5, T6, E0, E1> join(Tuple2<E0, E1> other) {
			return new Tuple9<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, other.element0, other.element1);
		}

		public <E0, E1, E2> Tuple10<T0, T1, T2, T3, T4, T5, T6, E0, E1, E2> join(Tuple3<E0, E1, E2> other) {
			return new Tuple10<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, other.element0, other.element1, other.element2);
		}

		public <E0, E1, E2, E3> Tuple11<T0, T1, T2, T3, T4, T5, T6, E0, E1, E2, E3> join(Tuple4<E0, E1, E2, E3> other) {
			return new Tuple11<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, other.element0, other.element1, other.element2, other.element3);
		}

		public <E0, E1, E2, E3, E4> Tuple12<T0, T1, T2, T3, T4, T5, T6, E0, E1, E2, E3, E4> join(Tuple5<E0, E1, E2, E3, E4> other) {
			return new Tuple12<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, other.element0, other.element1, other.element2, other.element3, other.element4);
		}

		public <E0, E1, E2, E3, E4, E5> Tuple13<T0, T1, T2, T3, T4, T5, T6, E0, E1, E2, E3, E4, E5> join(Tuple6<E0, E1, E2, E3, E4, E5> other) {
			return new Tuple13<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5);
		}

		public <E0, E1, E2, E3, E4, E5, E6> Tuple14<T0, T1, T2, T3, T4, T5, T6, E0, E1, E2, E3, E4, E5, E6> join(Tuple7<E0, E1, E2, E3, E4, E5, E6> other) {
			return new Tuple14<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5, other.element6);
		}
	}

	@FunctionalInterface
	interface Func7<R, T0, T1, T2, T3, T4, T5, T6> {
		R apply(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6);
	}

	record Tuple8<T0, T1, T2, T3, T4, T5, T6, T7>(T0 element0, T1 element1, T2 element2, T3 element3, T4 element4,
	                                              T5 element5, T6 element6, T7 element7) {
		public <R> R applyTo(Func8<R, T0, T1, T2, T3, T4, T5, T6, T7> func) {
			return func.apply(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7);
		}

		public static <R, T0, T1, T2, T3, T4, T5, T6, T7> Result<Tuple8<T0, T1, T2, T3, T4, T5, T6, T7>, R> collect(Tuple8<Result<T0, R>, Result<T1, R>, Result<T2, R>, Result<T3, R>, Result<T4, R>, Result<T5, R>, Result<T6, R>, Result<T7, R>> tuple) {
			return
					tuple.element0.flatMap(element0 ->
							                       tuple.element1.flatMap(element1 ->
									                                              tuple.element2.flatMap(element2 ->
											                                                                     tuple.element3.flatMap(element3 ->
													                                                                                            tuple.element4.flatMap(element4 ->
															                                                                                                                   tuple.element5.flatMap(element5 ->
																	                                                                                                                                          tuple.element6.flatMap(element6 ->
																			                                                                                                                                                                 tuple.element7.flatMap(element7 ->
																					                                                                                                                                                                                        Result.ok(new Tuple8<>(element0, element1, element2, element3, element4, element5, element6, element7))
																			                                                                                                                                                                 )
																	                                                                                                                                          )
															                                                                                                                   )
													                                                                                            )
											                                                                     )
									                                              )
							                       )
					)
					;
		}

		public <E0, E1, E2, E3, E4, E5, E6, E7> Tuple8<E0, E1, E2, E3, E4, E5, E6, E7> map(Func1<E0, T0> map0, Func1<E1, T1> map1, Func1<E2, T2> map2, Func1<E3, T3> map3, Func1<E4, T4> map4, Func1<E5, T5> map5, Func1<E6, T6> map6, Func1<E7, T7> map7) {
			return new Tuple8<>(map0.apply(this.element0), map1.apply(this.element1), map2.apply(this.element2), map3.apply(this.element3), map4.apply(this.element4), map5.apply(this.element5), map6.apply(this.element6), map7.apply(this.element7));
		}

		public Tuple8<T0, T1, T2, T3, T4, T5, T6, T7> join(Tuple0 other) {
			return new Tuple8<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7);
		}

		public <E0> Tuple9<T0, T1, T2, T3, T4, T5, T6, T7, E0> join(Tuple1<E0> other) {
			return new Tuple9<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, other.element0);
		}

		public <E0, E1> Tuple10<T0, T1, T2, T3, T4, T5, T6, T7, E0, E1> join(Tuple2<E0, E1> other) {
			return new Tuple10<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, other.element0, other.element1);
		}

		public <E0, E1, E2> Tuple11<T0, T1, T2, T3, T4, T5, T6, T7, E0, E1, E2> join(Tuple3<E0, E1, E2> other) {
			return new Tuple11<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, other.element0, other.element1, other.element2);
		}

		public <E0, E1, E2, E3> Tuple12<T0, T1, T2, T3, T4, T5, T6, T7, E0, E1, E2, E3> join(Tuple4<E0, E1, E2, E3> other) {
			return new Tuple12<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, other.element0, other.element1, other.element2, other.element3);
		}

		public <E0, E1, E2, E3, E4> Tuple13<T0, T1, T2, T3, T4, T5, T6, T7, E0, E1, E2, E3, E4> join(Tuple5<E0, E1, E2, E3, E4> other) {
			return new Tuple13<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, other.element0, other.element1, other.element2, other.element3, other.element4);
		}

		public <E0, E1, E2, E3, E4, E5> Tuple14<T0, T1, T2, T3, T4, T5, T6, T7, E0, E1, E2, E3, E4, E5> join(Tuple6<E0, E1, E2, E3, E4, E5> other) {
			return new Tuple14<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, other.element0, other.element1, other.element2, other.element3, other.element4, other.element5);
		}
	}

	@FunctionalInterface
	interface Func8<R, T0, T1, T2, T3, T4, T5, T6, T7> {
		R apply(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7);
	}

	record Tuple9<T0, T1, T2, T3, T4, T5, T6, T7, T8>(T0 element0, T1 element1, T2 element2, T3 element3, T4 element4,
	                                                  T5 element5, T6 element6, T7 element7, T8 element8) {
		public <R> R applyTo(Func9<R, T0, T1, T2, T3, T4, T5, T6, T7, T8> func) {
			return func.apply(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8);
		}

		public static <R, T0, T1, T2, T3, T4, T5, T6, T7, T8> Result<Tuple9<T0, T1, T2, T3, T4, T5, T6, T7, T8>, R> collect(Tuple9<Result<T0, R>, Result<T1, R>, Result<T2, R>, Result<T3, R>, Result<T4, R>, Result<T5, R>, Result<T6, R>, Result<T7, R>, Result<T8, R>> tuple) {
			return
					tuple.element0.flatMap(element0 ->
							                       tuple.element1.flatMap(element1 ->
									                                              tuple.element2.flatMap(element2 ->
											                                                                     tuple.element3.flatMap(element3 ->
													                                                                                            tuple.element4.flatMap(element4 ->
															                                                                                                                   tuple.element5.flatMap(element5 ->
																	                                                                                                                                          tuple.element6.flatMap(element6 ->
																			                                                                                                                                                                 tuple.element7.flatMap(element7 ->
																					                                                                                                                                                                                        tuple.element8.flatMap(element8 ->
																							                                                                                                                                                                                                               Result.ok(new Tuple9<>(element0, element1, element2, element3, element4, element5, element6, element7, element8))
																					                                                                                                                                                                                        )
																			                                                                                                                                                                 )
																	                                                                                                                                          )
															                                                                                                                   )
													                                                                                            )
											                                                                     )
									                                              )
							                       )
					)
					;
		}

		public <E0, E1, E2, E3, E4, E5, E6, E7, E8> Tuple9<E0, E1, E2, E3, E4, E5, E6, E7, E8> map(Func1<E0, T0> map0, Func1<E1, T1> map1, Func1<E2, T2> map2, Func1<E3, T3> map3, Func1<E4, T4> map4, Func1<E5, T5> map5, Func1<E6, T6> map6, Func1<E7, T7> map7, Func1<E8, T8> map8) {
			return new Tuple9<>(map0.apply(this.element0), map1.apply(this.element1), map2.apply(this.element2), map3.apply(this.element3), map4.apply(this.element4), map5.apply(this.element5), map6.apply(this.element6), map7.apply(this.element7), map8.apply(this.element8));
		}

		public Tuple9<T0, T1, T2, T3, T4, T5, T6, T7, T8> join(Tuple0 other) {
			return new Tuple9<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8);
		}

		public <E0> Tuple10<T0, T1, T2, T3, T4, T5, T6, T7, T8, E0> join(Tuple1<E0> other) {
			return new Tuple10<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, other.element0);
		}

		public <E0, E1> Tuple11<T0, T1, T2, T3, T4, T5, T6, T7, T8, E0, E1> join(Tuple2<E0, E1> other) {
			return new Tuple11<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, other.element0, other.element1);
		}

		public <E0, E1, E2> Tuple12<T0, T1, T2, T3, T4, T5, T6, T7, T8, E0, E1, E2> join(Tuple3<E0, E1, E2> other) {
			return new Tuple12<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, other.element0, other.element1, other.element2);
		}

		public <E0, E1, E2, E3> Tuple13<T0, T1, T2, T3, T4, T5, T6, T7, T8, E0, E1, E2, E3> join(Tuple4<E0, E1, E2, E3> other) {
			return new Tuple13<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, other.element0, other.element1, other.element2, other.element3);
		}

		public <E0, E1, E2, E3, E4> Tuple14<T0, T1, T2, T3, T4, T5, T6, T7, T8, E0, E1, E2, E3, E4> join(Tuple5<E0, E1, E2, E3, E4> other) {
			return new Tuple14<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, other.element0, other.element1, other.element2, other.element3, other.element4);
		}
	}

	@FunctionalInterface
	interface Func9<R, T0, T1, T2, T3, T4, T5, T6, T7, T8> {
		R apply(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8);
	}

	record Tuple10<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>(T0 element0, T1 element1, T2 element2, T3 element3,
	                                                       T4 element4, T5 element5, T6 element6, T7 element7,
	                                                       T8 element8, T9 element9) {
		public <R> R applyTo(Func10<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> func) {
			return func.apply(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9);
		}

		public static <R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Result<Tuple10<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>, R> collect(Tuple10<Result<T0, R>, Result<T1, R>, Result<T2, R>, Result<T3, R>, Result<T4, R>, Result<T5, R>, Result<T6, R>, Result<T7, R>, Result<T8, R>, Result<T9, R>> tuple) {
			return
					tuple.element0.flatMap(element0 ->
							                       tuple.element1.flatMap(element1 ->
									                                              tuple.element2.flatMap(element2 ->
											                                                                     tuple.element3.flatMap(element3 ->
													                                                                                            tuple.element4.flatMap(element4 ->
															                                                                                                                   tuple.element5.flatMap(element5 ->
																	                                                                                                                                          tuple.element6.flatMap(element6 ->
																			                                                                                                                                                                 tuple.element7.flatMap(element7 ->
																					                                                                                                                                                                                        tuple.element8.flatMap(element8 ->
																							                                                                                                                                                                                                               tuple.element9.flatMap(element9 ->
																									                                                                                                                                                                                                                                      Result.ok(new Tuple10<>(element0, element1, element2, element3, element4, element5, element6, element7, element8, element9))
																							                                                                                                                                                                                                               )
																					                                                                                                                                                                                        )
																			                                                                                                                                                                 )
																	                                                                                                                                          )
															                                                                                                                   )
													                                                                                            )
											                                                                     )
									                                              )
							                       )
					)
					;
		}

		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> Tuple10<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9> map(Func1<E0, T0> map0, Func1<E1, T1> map1, Func1<E2, T2> map2, Func1<E3, T3> map3, Func1<E4, T4> map4, Func1<E5, T5> map5, Func1<E6, T6> map6, Func1<E7, T7> map7, Func1<E8, T8> map8, Func1<E9, T9> map9) {
			return new Tuple10<>(map0.apply(this.element0), map1.apply(this.element1), map2.apply(this.element2), map3.apply(this.element3), map4.apply(this.element4), map5.apply(this.element5), map6.apply(this.element6), map7.apply(this.element7), map8.apply(this.element8), map9.apply(this.element9));
		}

		public Tuple10<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> join(Tuple0 other) {
			return new Tuple10<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9);
		}

		public <E0> Tuple11<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, E0> join(Tuple1<E0> other) {
			return new Tuple11<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, other.element0);
		}

		public <E0, E1> Tuple12<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, E0, E1> join(Tuple2<E0, E1> other) {
			return new Tuple12<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, other.element0, other.element1);
		}

		public <E0, E1, E2> Tuple13<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, E0, E1, E2> join(Tuple3<E0, E1, E2> other) {
			return new Tuple13<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, other.element0, other.element1, other.element2);
		}

		public <E0, E1, E2, E3> Tuple14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, E0, E1, E2, E3> join(Tuple4<E0, E1, E2, E3> other) {
			return new Tuple14<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, other.element0, other.element1, other.element2, other.element3);
		}
	}

	@FunctionalInterface
	interface Func10<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> {
		R apply(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9);
	}

	record Tuple11<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(T0 element0, T1 element1, T2 element2, T3 element3,
	                                                            T4 element4, T5 element5, T6 element6, T7 element7,
	                                                            T8 element8, T9 element9, T10 element10) {
		public <R> R applyTo(Func11<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> func) {
			return func.apply(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, this.element10);
		}

		public static <R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Result<Tuple11<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>, R> collect(Tuple11<Result<T0, R>, Result<T1, R>, Result<T2, R>, Result<T3, R>, Result<T4, R>, Result<T5, R>, Result<T6, R>, Result<T7, R>, Result<T8, R>, Result<T9, R>, Result<T10, R>> tuple) {
			return
					tuple.element0.flatMap(element0 ->
							                       tuple.element1.flatMap(element1 ->
									                                              tuple.element2.flatMap(element2 ->
											                                                                     tuple.element3.flatMap(element3 ->
													                                                                                            tuple.element4.flatMap(element4 ->
															                                                                                                                   tuple.element5.flatMap(element5 ->
																	                                                                                                                                          tuple.element6.flatMap(element6 ->
																			                                                                                                                                                                 tuple.element7.flatMap(element7 ->
																					                                                                                                                                                                                        tuple.element8.flatMap(element8 ->
																							                                                                                                                                                                                                               tuple.element9.flatMap(element9 ->
																									                                                                                                                                                                                                                                      tuple.element10.flatMap(element10 ->
																											                                                                                                                                                                                                                                                              Result.ok(new Tuple11<>(element0, element1, element2, element3, element4, element5, element6, element7, element8, element9, element10))
																									                                                                                                                                                                                                                                      )
																							                                                                                                                                                                                                               )
																					                                                                                                                                                                                        )
																			                                                                                                                                                                 )
																	                                                                                                                                          )
															                                                                                                                   )
													                                                                                            )
											                                                                     )
									                                              )
							                       )
					)
					;
		}

		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> Tuple11<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10> map(Func1<E0, T0> map0, Func1<E1, T1> map1, Func1<E2, T2> map2, Func1<E3, T3> map3, Func1<E4, T4> map4, Func1<E5, T5> map5, Func1<E6, T6> map6, Func1<E7, T7> map7, Func1<E8, T8> map8, Func1<E9, T9> map9, Func1<E10, T10> map10) {
			return new Tuple11<>(map0.apply(this.element0), map1.apply(this.element1), map2.apply(this.element2), map3.apply(this.element3), map4.apply(this.element4), map5.apply(this.element5), map6.apply(this.element6), map7.apply(this.element7), map8.apply(this.element8), map9.apply(this.element9), map10.apply(this.element10));
		}

		public Tuple11<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> join(Tuple0 other) {
			return new Tuple11<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, this.element10);
		}

		public <E0> Tuple12<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, E0> join(Tuple1<E0> other) {
			return new Tuple12<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, this.element10, other.element0);
		}

		public <E0, E1> Tuple13<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, E0, E1> join(Tuple2<E0, E1> other) {
			return new Tuple13<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, this.element10, other.element0, other.element1);
		}

		public <E0, E1, E2> Tuple14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, E0, E1, E2> join(Tuple3<E0, E1, E2> other) {
			return new Tuple14<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, this.element10, other.element0, other.element1, other.element2);
		}
	}

	@FunctionalInterface
	interface Func11<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> {
		R apply(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10);
	}

	record Tuple12<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(T0 element0, T1 element1, T2 element2, T3 element3,
	                                                                 T4 element4, T5 element5, T6 element6, T7 element7,
	                                                                 T8 element8, T9 element9, T10 element10,
	                                                                 T11 element11) {
		public <R> R applyTo(Func12<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> func) {
			return func.apply(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, this.element10, this.element11);
		}

		public static <R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Result<Tuple12<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>, R> collect(Tuple12<Result<T0, R>, Result<T1, R>, Result<T2, R>, Result<T3, R>, Result<T4, R>, Result<T5, R>, Result<T6, R>, Result<T7, R>, Result<T8, R>, Result<T9, R>, Result<T10, R>, Result<T11, R>> tuple) {
			return
					tuple.element0.flatMap(element0 ->
							                       tuple.element1.flatMap(element1 ->
									                                              tuple.element2.flatMap(element2 ->
											                                                                     tuple.element3.flatMap(element3 ->
													                                                                                            tuple.element4.flatMap(element4 ->
															                                                                                                                   tuple.element5.flatMap(element5 ->
																	                                                                                                                                          tuple.element6.flatMap(element6 ->
																			                                                                                                                                                                 tuple.element7.flatMap(element7 ->
																					                                                                                                                                                                                        tuple.element8.flatMap(element8 ->
																							                                                                                                                                                                                                               tuple.element9.flatMap(element9 ->
																									                                                                                                                                                                                                                                      tuple.element10.flatMap(element10 ->
																											                                                                                                                                                                                                                                                              tuple.element11.flatMap(element11 ->
																													                                                                                                                                                                                                                                                                                      Result.ok(new Tuple12<>(element0, element1, element2, element3, element4, element5, element6, element7, element8, element9, element10, element11))
																											                                                                                                                                                                                                                                                              )
																									                                                                                                                                                                                                                                      )
																							                                                                                                                                                                                                               )
																					                                                                                                                                                                                        )
																			                                                                                                                                                                 )
																	                                                                                                                                          )
															                                                                                                                   )
													                                                                                            )
											                                                                     )
									                                              )
							                       )
					)
					;
		}

		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> Tuple12<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11> map(Func1<E0, T0> map0, Func1<E1, T1> map1, Func1<E2, T2> map2, Func1<E3, T3> map3, Func1<E4, T4> map4, Func1<E5, T5> map5, Func1<E6, T6> map6, Func1<E7, T7> map7, Func1<E8, T8> map8, Func1<E9, T9> map9, Func1<E10, T10> map10, Func1<E11, T11> map11) {
			return new Tuple12<>(map0.apply(this.element0), map1.apply(this.element1), map2.apply(this.element2), map3.apply(this.element3), map4.apply(this.element4), map5.apply(this.element5), map6.apply(this.element6), map7.apply(this.element7), map8.apply(this.element8), map9.apply(this.element9), map10.apply(this.element10), map11.apply(this.element11));
		}

		public Tuple12<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> join(Tuple0 other) {
			return new Tuple12<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, this.element10, this.element11);
		}

		public <E0> Tuple13<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, E0> join(Tuple1<E0> other) {
			return new Tuple13<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, this.element10, this.element11, other.element0);
		}

		public <E0, E1> Tuple14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, E0, E1> join(Tuple2<E0, E1> other) {
			return new Tuple14<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, this.element10, this.element11, other.element0, other.element1);
		}
	}

	@FunctionalInterface
	interface Func12<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> {
		R apply(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11);
	}

	record Tuple13<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(T0 element0, T1 element1, T2 element2,
	                                                                      T3 element3, T4 element4, T5 element5,
	                                                                      T6 element6, T7 element7, T8 element8,
	                                                                      T9 element9, T10 element10, T11 element11,
	                                                                      T12 element12) {
		public <R> R applyTo(Func13<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> func) {
			return func.apply(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, this.element10, this.element11, this.element12);
		}

		public static <R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Result<Tuple13<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>, R> collect(Tuple13<Result<T0, R>, Result<T1, R>, Result<T2, R>, Result<T3, R>, Result<T4, R>, Result<T5, R>, Result<T6, R>, Result<T7, R>, Result<T8, R>, Result<T9, R>, Result<T10, R>, Result<T11, R>, Result<T12, R>> tuple) {
			return
					tuple.element0.flatMap(element0 ->
							                       tuple.element1.flatMap(element1 ->
									                                              tuple.element2.flatMap(element2 ->
											                                                                     tuple.element3.flatMap(element3 ->
													                                                                                            tuple.element4.flatMap(element4 ->
															                                                                                                                   tuple.element5.flatMap(element5 ->
																	                                                                                                                                          tuple.element6.flatMap(element6 ->
																			                                                                                                                                                                 tuple.element7.flatMap(element7 ->
																					                                                                                                                                                                                        tuple.element8.flatMap(element8 ->
																							                                                                                                                                                                                                               tuple.element9.flatMap(element9 ->
																									                                                                                                                                                                                                                                      tuple.element10.flatMap(element10 ->
																											                                                                                                                                                                                                                                                              tuple.element11.flatMap(element11 ->
																													                                                                                                                                                                                                                                                                                      tuple.element12.flatMap(element12 ->
																															                                                                                                                                                                                                                                                                                                              Result.ok(new Tuple13<>(element0, element1, element2, element3, element4, element5, element6, element7, element8, element9, element10, element11, element12))
																													                                                                                                                                                                                                                                                                                      )
																											                                                                                                                                                                                                                                                              )
																									                                                                                                                                                                                                                                      )
																							                                                                                                                                                                                                               )
																					                                                                                                                                                                                        )
																			                                                                                                                                                                 )
																	                                                                                                                                          )
															                                                                                                                   )
													                                                                                            )
											                                                                     )
									                                              )
							                       )
					)
					;
		}

		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12> Tuple13<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12> map(Func1<E0, T0> map0, Func1<E1, T1> map1, Func1<E2, T2> map2, Func1<E3, T3> map3, Func1<E4, T4> map4, Func1<E5, T5> map5, Func1<E6, T6> map6, Func1<E7, T7> map7, Func1<E8, T8> map8, Func1<E9, T9> map9, Func1<E10, T10> map10, Func1<E11, T11> map11, Func1<E12, T12> map12) {
			return new Tuple13<>(map0.apply(this.element0), map1.apply(this.element1), map2.apply(this.element2), map3.apply(this.element3), map4.apply(this.element4), map5.apply(this.element5), map6.apply(this.element6), map7.apply(this.element7), map8.apply(this.element8), map9.apply(this.element9), map10.apply(this.element10), map11.apply(this.element11), map12.apply(this.element12));
		}

		public Tuple13<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> join(Tuple0 other) {
			return new Tuple13<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, this.element10, this.element11, this.element12);
		}

		public <E0> Tuple14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, E0> join(Tuple1<E0> other) {
			return new Tuple14<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, this.element10, this.element11, this.element12, other.element0);
		}
	}

	@FunctionalInterface
	interface Func13<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> {
		R apply(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12);
	}

	record Tuple14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(T0 element0, T1 element1, T2 element2,
	                                                                           T3 element3, T4 element4, T5 element5,
	                                                                           T6 element6, T7 element7, T8 element8,
	                                                                           T9 element9, T10 element10,
	                                                                           T11 element11, T12 element12,
	                                                                           T13 element13) {
		public <R> R applyTo(Func14<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> func) {
			return func.apply(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, this.element10, this.element11, this.element12, this.element13);
		}

		public static <R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Result<Tuple14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>, R> collect(Tuple14<Result<T0, R>, Result<T1, R>, Result<T2, R>, Result<T3, R>, Result<T4, R>, Result<T5, R>, Result<T6, R>, Result<T7, R>, Result<T8, R>, Result<T9, R>, Result<T10, R>, Result<T11, R>, Result<T12, R>, Result<T13, R>> tuple) {
			return
					tuple.element0.flatMap(element0 ->
							                       tuple.element1.flatMap(element1 ->
									                                              tuple.element2.flatMap(element2 ->
											                                                                     tuple.element3.flatMap(element3 ->
													                                                                                            tuple.element4.flatMap(element4 ->
															                                                                                                                   tuple.element5.flatMap(element5 ->
																	                                                                                                                                          tuple.element6.flatMap(element6 ->
																			                                                                                                                                                                 tuple.element7.flatMap(element7 ->
																					                                                                                                                                                                                        tuple.element8.flatMap(element8 ->
																							                                                                                                                                                                                                               tuple.element9.flatMap(element9 ->
																									                                                                                                                                                                                                                                      tuple.element10.flatMap(element10 ->
																											                                                                                                                                                                                                                                                              tuple.element11.flatMap(element11 ->
																													                                                                                                                                                                                                                                                                                      tuple.element12.flatMap(element12 ->
																															                                                                                                                                                                                                                                                                                                              tuple.element13.flatMap(element13 ->
																																	                                                                                                                                                                                                                                                                                                                                      Result.ok(new Tuple14<>(element0, element1, element2, element3, element4, element5, element6, element7, element8, element9, element10, element11, element12, element13))
																															                                                                                                                                                                                                                                                                                                              )
																													                                                                                                                                                                                                                                                                                      )
																											                                                                                                                                                                                                                                                              )
																									                                                                                                                                                                                                                                      )
																							                                                                                                                                                                                                               )
																					                                                                                                                                                                                        )
																			                                                                                                                                                                 )
																	                                                                                                                                          )
															                                                                                                                   )
													                                                                                            )
											                                                                     )
									                                              )
							                       )
					)
					;
		}

		public <E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12, E13> Tuple14<E0, E1, E2, E3, E4, E5, E6, E7, E8, E9, E10, E11, E12, E13> map(Func1<E0, T0> map0, Func1<E1, T1> map1, Func1<E2, T2> map2, Func1<E3, T3> map3, Func1<E4, T4> map4, Func1<E5, T5> map5, Func1<E6, T6> map6, Func1<E7, T7> map7, Func1<E8, T8> map8, Func1<E9, T9> map9, Func1<E10, T10> map10, Func1<E11, T11> map11, Func1<E12, T12> map12, Func1<E13, T13> map13) {
			return new Tuple14<>(map0.apply(this.element0), map1.apply(this.element1), map2.apply(this.element2), map3.apply(this.element3), map4.apply(this.element4), map5.apply(this.element5), map6.apply(this.element6), map7.apply(this.element7), map8.apply(this.element8), map9.apply(this.element9), map10.apply(this.element10), map11.apply(this.element11), map12.apply(this.element12), map13.apply(this.element13));
		}

		public Tuple14<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> join(Tuple0 other) {
			return new Tuple14<>(this.element0, this.element1, this.element2, this.element3, this.element4, this.element5, this.element6, this.element7, this.element8, this.element9, this.element10, this.element11, this.element12, this.element13);
		}
	}

	@FunctionalInterface
	interface Func14<R, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> {
		R apply(T0 arg0, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13);
	}
}