de.caff.generics.tuple

## Class Tuple6<T1,T2,T3,T4,T5,T6>

- java.lang.Object
- - de.caff.generics.tuple.ITuple6.Base<T1,T2,T3,T4,T5,T6>
  - - de.caff.generics.tuple.Tuple6<T1,T2,T3,T4,T5,T6>

- Type Parameters:
    `T1` - type of first element
    `T2` - type of second element
    `T3` - type of third element
    `T4` - type of fourth element
    `T5` - type of fifth element
    `T6` - type of sixth element
  All Implemented Interfaces:
    ITuple6<T1,T2,T3,T4,T5,T6>, java.io.Serializable

      public class Tuple6<T1,T2,T3,T4,T5,T6>
      extends ITuple6.Base<T1,T2,T3,T4,T5,T6>
      implements java.io.Serializable

  Immutable tuple with 6 non-null elements. If you want to iterate over a tuple or access its elements by index (note that both is only possible for a common super type of the tuple's types) `Indexable.viewTuple(ITuple6)` will come to help. Note that this class is automatically created by `tools.TupleClassCreator` (not yet public).
  Since:
    November 17, 2021
  Author:
    Rammi
  See Also:
    `NTuple6`, Serialized Form

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from interface de.caff.generics.tuple.ITuple6

      `ITuple6.Base<T1,T2,T3,T4,T5,T6>`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `Tuple6(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5, T6 e6)` Constructor.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `T1` | `_1()` Get the first element.
    `Tuple2<T1,T2>` | `_12()` Create a new 2-tuple from this one where the elements are ordered: 1st, 2nd.
    `Tuple3<T1,T2,T3>` | `_123()` Create a new 3-tuple from this one where the elements are ordered: 1st, 2nd, 3rd.
    `Tuple4<T1,T2,T3,T4>` | `_1234()` Create a new 4-tuple from this one where the elements are ordered: 1st, 2nd, 3rd, 4th.
    `Tuple5<T1,T2,T3,T4,T5>` | `_12345()` Create a new 5-tuple from this one where the elements are ordered: 1st, 2nd, 3rd, 4th, 5th.
    `Tuple5<T1,T2,T3,T4,T6>` | `_12346()` Create a new 5-tuple from this one where the elements are ordered: 1st, 2nd, 3rd, 4th, 6th.
    `Tuple4<T1,T2,T3,T5>` | `_1235()` Create a new 4-tuple from this one where the elements are ordered: 1st, 2nd, 3rd, 5th.
    `Tuple5<T1,T2,T3,T5,T6>` | `_12356()` Create a new 5-tuple from this one where the elements are ordered: 1st, 2nd, 3rd, 5th, 6th.
    `Tuple4<T1,T2,T3,T6>` | `_1236()` Create a new 4-tuple from this one where the elements are ordered: 1st, 2nd, 3rd, 6th.
    `Tuple3<T1,T2,T4>` | `_124()` Create a new 3-tuple from this one where the elements are ordered: 1st, 2nd, 4th.
    `Tuple4<T1,T2,T4,T5>` | `_1245()` Create a new 4-tuple from this one where the elements are ordered: 1st, 2nd, 4th, 5th.
    `Tuple5<T1,T2,T4,T5,T6>` | `_12456()` Create a new 5-tuple from this one where the elements are ordered: 1st, 2nd, 4th, 5th, 6th.
    `Tuple4<T1,T2,T4,T6>` | `_1246()` Create a new 4-tuple from this one where the elements are ordered: 1st, 2nd, 4th, 6th.
    `Tuple3<T1,T2,T5>` | `_125()` Create a new 3-tuple from this one where the elements are ordered: 1st, 2nd, 5th.
    `Tuple4<T1,T2,T5,T6>` | `_1256()` Create a new 4-tuple from this one where the elements are ordered: 1st, 2nd, 5th, 6th.
    `Tuple3<T1,T2,T6>` | `_126()` Create a new 3-tuple from this one where the elements are ordered: 1st, 2nd, 6th.
    `Tuple2<T1,T3>` | `_13()` Create a new 2-tuple from this one where the elements are ordered: 1st, 3rd.
    `Tuple3<T1,T3,T2>` | `_132()` Create a new 3-tuple from this one where the elements are ordered: 1st, 3rd, 2nd.
    `Tuple3<T1,T3,T4>` | `_134()` Create a new 3-tuple from this one where the elements are ordered: 1st, 3rd, 4th.
    `Tuple4<T1,T3,T4,T5>` | `_1345()` Create a new 4-tuple from this one where the elements are ordered: 1st, 3rd, 4th, 5th.
    `Tuple5<T1,T3,T4,T5,T6>` | `_13456()` Create a new 5-tuple from this one where the elements are ordered: 1st, 3rd, 4th, 5th, 6th.
    `Tuple4<T1,T3,T4,T6>` | `_1346()` Create a new 4-tuple from this one where the elements are ordered: 1st, 3rd, 4th, 6th.
    `Tuple3<T1,T3,T5>` | `_135()` Create a new 3-tuple from this one where the elements are ordered: 1st, 3rd, 5th.
    `Tuple4<T1,T3,T5,T6>` | `_1356()` Create a new 4-tuple from this one where the elements are ordered: 1st, 3rd, 5th, 6th.
    `Tuple3<T1,T3,T6>` | `_136()` Create a new 3-tuple from this one where the elements are ordered: 1st, 3rd, 6th.
    `Tuple2<T1,T4>` | `_14()` Create a new 2-tuple from this one where the elements are ordered: 1st, 4th.
    `Tuple3<T1,T4,T2>` | `_142()` Create a new 3-tuple from this one where the elements are ordered: 1st, 4th, 2nd.
    `Tuple3<T1,T4,T3>` | `_143()` Create a new 3-tuple from this one where the elements are ordered: 1st, 4th, 3rd.
    `Tuple3<T1,T4,T5>` | `_145()` Create a new 3-tuple from this one where the elements are ordered: 1st, 4th, 5th.
    `Tuple4<T1,T4,T5,T6>` | `_1456()` Create a new 4-tuple from this one where the elements are ordered: 1st, 4th, 5th, 6th.
    `Tuple3<T1,T4,T6>` | `_146()` Create a new 3-tuple from this one where the elements are ordered: 1st, 4th, 6th.
    `Tuple2<T1,T5>` | `_15()` Create a new 2-tuple from this one where the elements are ordered: 1st, 5th.
    `Tuple3<T1,T5,T2>` | `_152()` Create a new 3-tuple from this one where the elements are ordered: 1st, 5th, 2nd.
    `Tuple3<T1,T5,T3>` | `_153()` Create a new 3-tuple from this one where the elements are ordered: 1st, 5th, 3rd.
    `Tuple3<T1,T5,T4>` | `_154()` Create a new 3-tuple from this one where the elements are ordered: 1st, 5th, 4th.
    `Tuple3<T1,T5,T6>` | `_156()` Create a new 3-tuple from this one where the elements are ordered: 1st, 5th, 6th.
    `Tuple2<T1,T6>` | `_16()` Create a new 2-tuple from this one where the elements are ordered: 1st, 6th.
    `Tuple3<T1,T6,T2>` | `_162()` Create a new 3-tuple from this one where the elements are ordered: 1st, 6th, 2nd.
    `Tuple3<T1,T6,T3>` | `_163()` Create a new 3-tuple from this one where the elements are ordered: 1st, 6th, 3rd.
    `Tuple3<T1,T6,T4>` | `_164()` Create a new 3-tuple from this one where the elements are ordered: 1st, 6th, 4th.
    `Tuple3<T1,T6,T5>` | `_165()` Create a new 3-tuple from this one where the elements are ordered: 1st, 6th, 5th.
    `T2` | `_2()` Get the second element.
    `Tuple2<T2,T1>` | `_21()` Create a new 2-tuple from this one where the elements are ordered: 2nd, 1st.
    `Tuple3<T2,T1,T3>` | `_213()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 1st, 3rd.
    `Tuple3<T2,T1,T4>` | `_214()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 1st, 4th.
    `Tuple3<T2,T1,T5>` | `_215()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 1st, 5th.
    `Tuple3<T2,T1,T6>` | `_216()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 1st, 6th.
    `Tuple2<T2,T3>` | `_23()` Create a new 2-tuple from this one where the elements are ordered: 2nd, 3rd.
    `Tuple3<T2,T3,T1>` | `_231()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 3rd, 1st.
    `Tuple3<T2,T3,T4>` | `_234()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 3rd, 4th.
    `Tuple4<T2,T3,T4,T5>` | `_2345()` Create a new 4-tuple from this one where the elements are ordered: 2nd, 3rd, 4th, 5th.
    `Tuple5<T2,T3,T4,T5,T6>` | `_23456()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 3rd, 4th, 5th, 6th.
    `Tuple4<T2,T3,T4,T6>` | `_2346()` Create a new 4-tuple from this one where the elements are ordered: 2nd, 3rd, 4th, 6th.
    `Tuple3<T2,T3,T5>` | `_235()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 3rd, 5th.
    `Tuple4<T2,T3,T5,T6>` | `_2356()` Create a new 4-tuple from this one where the elements are ordered: 2nd, 3rd, 5th, 6th.
    `Tuple3<T2,T3,T6>` | `_236()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 3rd, 6th.
    `Tuple2<T2,T4>` | `_24()` Create a new 2-tuple from this one where the elements are ordered: 2nd, 4th.
    `Tuple3<T2,T4,T1>` | `_241()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 4th, 1st.
    `Tuple3<T2,T4,T3>` | `_243()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 4th, 3rd.
    `Tuple3<T2,T4,T5>` | `_245()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 4th, 5th.
    `Tuple4<T2,T4,T5,T6>` | `_2456()` Create a new 4-tuple from this one where the elements are ordered: 2nd, 4th, 5th, 6th.
    `Tuple3<T2,T4,T6>` | `_246()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 4th, 6th.
    `Tuple2<T2,T5>` | `_25()` Create a new 2-tuple from this one where the elements are ordered: 2nd, 5th.
    `Tuple3<T2,T5,T1>` | `_251()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 5th, 1st.
    `Tuple3<T2,T5,T3>` | `_253()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 5th, 3rd.
    `Tuple3<T2,T5,T4>` | `_254()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 5th, 4th.
    `Tuple3<T2,T5,T6>` | `_256()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 5th, 6th.
    `Tuple2<T2,T6>` | `_26()` Create a new 2-tuple from this one where the elements are ordered: 2nd, 6th.
    `Tuple3<T2,T6,T1>` | `_261()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 6th, 1st.
    `Tuple3<T2,T6,T3>` | `_263()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 6th, 3rd.
    `Tuple3<T2,T6,T4>` | `_264()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 6th, 4th.
    `Tuple3<T2,T6,T5>` | `_265()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 6th, 5th.
    `T3` | `_3()` Get the third element.
    `Tuple2<T3,T1>` | `_31()` Create a new 2-tuple from this one where the elements are ordered: 3rd, 1st.
    `Tuple3<T3,T1,T2>` | `_312()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 1st, 2nd.
    `Tuple3<T3,T1,T4>` | `_314()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 1st, 4th.
    `Tuple3<T3,T1,T5>` | `_315()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 1st, 5th.
    `Tuple3<T3,T1,T6>` | `_316()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 1st, 6th.
    `Tuple2<T3,T2>` | `_32()` Create a new 2-tuple from this one where the elements are ordered: 3rd, 2nd.
    `Tuple3<T3,T2,T1>` | `_321()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 2nd, 1st.
    `Tuple3<T3,T2,T4>` | `_324()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 2nd, 4th.
    `Tuple3<T3,T2,T5>` | `_325()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 2nd, 5th.
    `Tuple3<T3,T2,T6>` | `_326()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 2nd, 6th.
    `Tuple2<T3,T4>` | `_34()` Create a new 2-tuple from this one where the elements are ordered: 3rd, 4th.
    `Tuple3<T3,T4,T1>` | `_341()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 4th, 1st.
    `Tuple3<T3,T4,T2>` | `_342()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 4th, 2nd.
    `Tuple3<T3,T4,T5>` | `_345()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 4th, 5th.
    `Tuple4<T3,T4,T5,T6>` | `_3456()` Create a new 4-tuple from this one where the elements are ordered: 3rd, 4th, 5th, 6th.
    `Tuple3<T3,T4,T6>` | `_346()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 4th, 6th.
    `Tuple2<T3,T5>` | `_35()` Create a new 2-tuple from this one where the elements are ordered: 3rd, 5th.
    `Tuple3<T3,T5,T1>` | `_351()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 5th, 1st.
    `Tuple3<T3,T5,T2>` | `_352()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 5th, 2nd.
    `Tuple3<T3,T5,T4>` | `_354()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 5th, 4th.
    `Tuple3<T3,T5,T6>` | `_356()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 5th, 6th.
    `Tuple2<T3,T6>` | `_36()` Create a new 2-tuple from this one where the elements are ordered: 3rd, 6th.
    `Tuple3<T3,T6,T1>` | `_361()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 6th, 1st.
    `Tuple3<T3,T6,T2>` | `_362()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 6th, 2nd.
    `Tuple3<T3,T6,T4>` | `_364()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 6th, 4th.
    `Tuple3<T3,T6,T5>` | `_365()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 6th, 5th.
    `T4` | `_4()` Get the fourth element.
    `Tuple2<T4,T1>` | `_41()` Create a new 2-tuple from this one where the elements are ordered: 4th, 1st.
    `Tuple3<T4,T1,T2>` | `_412()` Create a new 3-tuple from this one where the elements are ordered: 4th, 1st, 2nd.
    `Tuple3<T4,T1,T3>` | `_413()` Create a new 3-tuple from this one where the elements are ordered: 4th, 1st, 3rd.
    `Tuple3<T4,T1,T5>` | `_415()` Create a new 3-tuple from this one where the elements are ordered: 4th, 1st, 5th.
    `Tuple3<T4,T1,T6>` | `_416()` Create a new 3-tuple from this one where the elements are ordered: 4th, 1st, 6th.
    `Tuple2<T4,T2>` | `_42()` Create a new 2-tuple from this one where the elements are ordered: 4th, 2nd.
    `Tuple3<T4,T2,T1>` | `_421()` Create a new 3-tuple from this one where the elements are ordered: 4th, 2nd, 1st.
    `Tuple3<T4,T2,T3>` | `_423()` Create a new 3-tuple from this one where the elements are ordered: 4th, 2nd, 3rd.
    `Tuple3<T4,T2,T5>` | `_425()` Create a new 3-tuple from this one where the elements are ordered: 4th, 2nd, 5th.
    `Tuple3<T4,T2,T6>` | `_426()` Create a new 3-tuple from this one where the elements are ordered: 4th, 2nd, 6th.
    `Tuple2<T4,T3>` | `_43()` Create a new 2-tuple from this one where the elements are ordered: 4th, 3rd.
    `Tuple3<T4,T3,T1>` | `_431()` Create a new 3-tuple from this one where the elements are ordered: 4th, 3rd, 1st.
    `Tuple3<T4,T3,T2>` | `_432()` Create a new 3-tuple from this one where the elements are ordered: 4th, 3rd, 2nd.
    `Tuple3<T4,T3,T5>` | `_435()` Create a new 3-tuple from this one where the elements are ordered: 4th, 3rd, 5th.
    `Tuple3<T4,T3,T6>` | `_436()` Create a new 3-tuple from this one where the elements are ordered: 4th, 3rd, 6th.
    `Tuple2<T4,T5>` | `_45()` Create a new 2-tuple from this one where the elements are ordered: 4th, 5th.
    `Tuple3<T4,T5,T1>` | `_451()` Create a new 3-tuple from this one where the elements are ordered: 4th, 5th, 1st.
    `Tuple3<T4,T5,T2>` | `_452()` Create a new 3-tuple from this one where the elements are ordered: 4th, 5th, 2nd.
    `Tuple3<T4,T5,T3>` | `_453()` Create a new 3-tuple from this one where the elements are ordered: 4th, 5th, 3rd.
    `Tuple3<T4,T5,T6>` | `_456()` Create a new 3-tuple from this one where the elements are ordered: 4th, 5th, 6th.
    `Tuple2<T4,T6>` | `_46()` Create a new 2-tuple from this one where the elements are ordered: 4th, 6th.
    `Tuple3<T4,T6,T1>` | `_461()` Create a new 3-tuple from this one where the elements are ordered: 4th, 6th, 1st.
    `Tuple3<T4,T6,T2>` | `_462()` Create a new 3-tuple from this one where the elements are ordered: 4th, 6th, 2nd.
    `Tuple3<T4,T6,T3>` | `_463()` Create a new 3-tuple from this one where the elements are ordered: 4th, 6th, 3rd.
    `Tuple3<T4,T6,T5>` | `_465()` Create a new 3-tuple from this one where the elements are ordered: 4th, 6th, 5th.
    `T5` | `_5()` Get the fifth element.
    `Tuple2<T5,T1>` | `_51()` Create a new 2-tuple from this one where the elements are ordered: 5th, 1st.
    `Tuple3<T5,T1,T2>` | `_512()` Create a new 3-tuple from this one where the elements are ordered: 5th, 1st, 2nd.
    `Tuple3<T5,T1,T3>` | `_513()` Create a new 3-tuple from this one where the elements are ordered: 5th, 1st, 3rd.
    `Tuple3<T5,T1,T4>` | `_514()` Create a new 3-tuple from this one where the elements are ordered: 5th, 1st, 4th.
    `Tuple3<T5,T1,T6>` | `_516()` Create a new 3-tuple from this one where the elements are ordered: 5th, 1st, 6th.
    `Tuple2<T5,T2>` | `_52()` Create a new 2-tuple from this one where the elements are ordered: 5th, 2nd.
    `Tuple3<T5,T2,T1>` | `_521()` Create a new 3-tuple from this one where the elements are ordered: 5th, 2nd, 1st.
    `Tuple3<T5,T2,T3>` | `_523()` Create a new 3-tuple from this one where the elements are ordered: 5th, 2nd, 3rd.
    `Tuple3<T5,T2,T4>` | `_524()` Create a new 3-tuple from this one where the elements are ordered: 5th, 2nd, 4th.
    `Tuple3<T5,T2,T6>` | `_526()` Create a new 3-tuple from this one where the elements are ordered: 5th, 2nd, 6th.
    `Tuple2<T5,T3>` | `_53()` Create a new 2-tuple from this one where the elements are ordered: 5th, 3rd.
    `Tuple3<T5,T3,T1>` | `_531()` Create a new 3-tuple from this one where the elements are ordered: 5th, 3rd, 1st.
    `Tuple3<T5,T3,T2>` | `_532()` Create a new 3-tuple from this one where the elements are ordered: 5th, 3rd, 2nd.
    `Tuple3<T5,T3,T4>` | `_534()` Create a new 3-tuple from this one where the elements are ordered: 5th, 3rd, 4th.
    `Tuple3<T5,T3,T6>` | `_536()` Create a new 3-tuple from this one where the elements are ordered: 5th, 3rd, 6th.
    `Tuple2<T5,T4>` | `_54()` Create a new 2-tuple from this one where the elements are ordered: 5th, 4th.
    `Tuple3<T5,T4,T1>` | `_541()` Create a new 3-tuple from this one where the elements are ordered: 5th, 4th, 1st.
    `Tuple3<T5,T4,T2>` | `_542()` Create a new 3-tuple from this one where the elements are ordered: 5th, 4th, 2nd.
    `Tuple3<T5,T4,T3>` | `_543()` Create a new 3-tuple from this one where the elements are ordered: 5th, 4th, 3rd.
    `Tuple3<T5,T4,T6>` | `_546()` Create a new 3-tuple from this one where the elements are ordered: 5th, 4th, 6th.
    `Tuple2<T5,T6>` | `_56()` Create a new 2-tuple from this one where the elements are ordered: 5th, 6th.
    `Tuple3<T5,T6,T1>` | `_561()` Create a new 3-tuple from this one where the elements are ordered: 5th, 6th, 1st.
    `Tuple3<T5,T6,T2>` | `_562()` Create a new 3-tuple from this one where the elements are ordered: 5th, 6th, 2nd.
    `Tuple3<T5,T6,T3>` | `_563()` Create a new 3-tuple from this one where the elements are ordered: 5th, 6th, 3rd.
    `Tuple3<T5,T6,T4>` | `_564()` Create a new 3-tuple from this one where the elements are ordered: 5th, 6th, 4th.
    `T6` | `_6()` Get the sixth element.
    `Tuple2<T6,T1>` | `_61()` Create a new 2-tuple from this one where the elements are ordered: 6th, 1st.
    `Tuple3<T6,T1,T2>` | `_612()` Create a new 3-tuple from this one where the elements are ordered: 6th, 1st, 2nd.
    `Tuple3<T6,T1,T3>` | `_613()` Create a new 3-tuple from this one where the elements are ordered: 6th, 1st, 3rd.
    `Tuple3<T6,T1,T4>` | `_614()` Create a new 3-tuple from this one where the elements are ordered: 6th, 1st, 4th.
    `Tuple3<T6,T1,T5>` | `_615()` Create a new 3-tuple from this one where the elements are ordered: 6th, 1st, 5th.
    `Tuple2<T6,T2>` | `_62()` Create a new 2-tuple from this one where the elements are ordered: 6th, 2nd.
    `Tuple3<T6,T2,T1>` | `_621()` Create a new 3-tuple from this one where the elements are ordered: 6th, 2nd, 1st.
    `Tuple3<T6,T2,T3>` | `_623()` Create a new 3-tuple from this one where the elements are ordered: 6th, 2nd, 3rd.
    `Tuple3<T6,T2,T4>` | `_624()` Create a new 3-tuple from this one where the elements are ordered: 6th, 2nd, 4th.
    `Tuple3<T6,T2,T5>` | `_625()` Create a new 3-tuple from this one where the elements are ordered: 6th, 2nd, 5th.
    `Tuple2<T6,T3>` | `_63()` Create a new 2-tuple from this one where the elements are ordered: 6th, 3rd.
    `Tuple3<T6,T3,T1>` | `_631()` Create a new 3-tuple from this one where the elements are ordered: 6th, 3rd, 1st.
    `Tuple3<T6,T3,T2>` | `_632()` Create a new 3-tuple from this one where the elements are ordered: 6th, 3rd, 2nd.
    `Tuple3<T6,T3,T4>` | `_634()` Create a new 3-tuple from this one where the elements are ordered: 6th, 3rd, 4th.
    `Tuple3<T6,T3,T5>` | `_635()` Create a new 3-tuple from this one where the elements are ordered: 6th, 3rd, 5th.
    `Tuple2<T6,T4>` | `_64()` Create a new 2-tuple from this one where the elements are ordered: 6th, 4th.
    `Tuple3<T6,T4,T1>` | `_641()` Create a new 3-tuple from this one where the elements are ordered: 6th, 4th, 1st.
    `Tuple3<T6,T4,T2>` | `_642()` Create a new 3-tuple from this one where the elements are ordered: 6th, 4th, 2nd.
    `Tuple3<T6,T4,T3>` | `_643()` Create a new 3-tuple from this one where the elements are ordered: 6th, 4th, 3rd.
    `Tuple3<T6,T4,T5>` | `_645()` Create a new 3-tuple from this one where the elements are ordered: 6th, 4th, 5th.
    `Tuple2<T6,T5>` | `_65()` Create a new 2-tuple from this one where the elements are ordered: 6th, 5th.
    `Tuple3<T6,T5,T1>` | `_651()` Create a new 3-tuple from this one where the elements are ordered: 6th, 5th, 1st.
    `Tuple3<T6,T5,T2>` | `_652()` Create a new 3-tuple from this one where the elements are ordered: 6th, 5th, 2nd.
    `Tuple3<T6,T5,T3>` | `_653()` Create a new 3-tuple from this one where the elements are ordered: 6th, 5th, 3rd.
    `Tuple3<T6,T5,T4>` | `_654()` Create a new 3-tuple from this one where the elements are ordered: 6th, 5th, 4th.
    `Tuple6<T1,T2,T3,T4,T5,T6>` | `frozenNotNull()` Convert this into an object of a concrete tuple implementation.
    `<T> Tuple7<T,T1,T2,T3,T4,T5,T6>` | `i1(T e1)` Create a 7-tuple from this 6-tuple by inserting a new first element.
    `<T> Tuple7<T1,T,T2,T3,T4,T5,T6>` | `i2(T e2)` Create a 7-tuple from this 6-tuple by inserting a new second element.
    `<T> Tuple7<T1,T2,T,T3,T4,T5,T6>` | `i3(T e3)` Create a 7-tuple from this 6-tuple by inserting a new third element.
    `<T> Tuple7<T1,T2,T3,T,T4,T5,T6>` | `i4(T e4)` Create a 7-tuple from this 6-tuple by inserting a new fourth element.
    `<T> Tuple7<T1,T2,T3,T4,T,T5,T6>` | `i5(T e5)` Create a 7-tuple from this 6-tuple by inserting a new fifth element.
    `<T> Tuple7<T1,T2,T3,T4,T5,T,T6>` | `i6(T e6)` Create a 7-tuple from this 6-tuple by inserting a new sixth element.
    `<T> Tuple7<T1,T2,T3,T4,T5,T6,T>` | `i7(T e7)` Create a 7-tuple from this 6-tuple by adding a new seventh element.
    `java.lang.String` | `toString()`
    `<E1> Tuple6<E1,T2,T3,T4,T5,T6>` | `x1(E1 e1)` Create a 6-tuple from this one where the first element is exchanged.
    `<E1,E2> Tuple6<E1,E2,T3,T4,T5,T6>` | `x12(E1 e1, E2 e2)` Create a 6-tuple from this one where the first and second elements are exchanged.
    `<E1,E2,E3> Tuple6<E1,E2,E3,T4,T5,T6>` | `x123(E1 e1, E2 e2, E3 e3)` Create a 6-tuple from this one where the first, second, and thirdelements are exchanged.
    `<E1,E2,E3,E4> Tuple6<E1,E2,E3,E4,T5,T6>` | `x1234(E1 e1, E2 e2, E3 e3, E4 e4)` Create a 6-tuple from this one where the first, second, third, and fourthelements are exchanged.
    `<E1,E2,E3,E4,E5> Tuple6<E1,E2,E3,E4,E5,T6>` | `x12345(E1 e1, E2 e2, E3 e3, E4 e4, E5 e5)` Create a 6-tuple from this one where the first, second, third, fourth, and fifthelements are exchanged.
    `<E1,E2,E3,E4,E6> Tuple6<E1,E2,E3,E4,T5,E6>` | `x12346(E1 e1, E2 e2, E3 e3, E4 e4, E6 e6)` Create a 6-tuple from this one where the first, second, third, fourth, and sixthelements are exchanged.
    `<E1,E2,E3,E5> Tuple6<E1,E2,E3,T4,E5,T6>` | `x1235(E1 e1, E2 e2, E3 e3, E5 e5)` Create a 6-tuple from this one where the first, second, third, and fifthelements are exchanged.
    `<E1,E2,E3,E5,E6> Tuple6<E1,E2,E3,T4,E5,E6>` | `x12356(E1 e1, E2 e2, E3 e3, E5 e5, E6 e6)` Create a 6-tuple from this one where the first, second, third, fifth, and sixthelements are exchanged.
    `<E1,E2,E3,E6> Tuple6<E1,E2,E3,T4,T5,E6>` | `x1236(E1 e1, E2 e2, E3 e3, E6 e6)` Create a 6-tuple from this one where the first, second, third, and sixthelements are exchanged.
    `<E1,E2,E4> Tuple6<E1,E2,T3,E4,T5,T6>` | `x124(E1 e1, E2 e2, E4 e4)` Create a 6-tuple from this one where the first, second, and fourthelements are exchanged.
    `<E1,E2,E4,E5> Tuple6<E1,E2,T3,E4,E5,T6>` | `x1245(E1 e1, E2 e2, E4 e4, E5 e5)` Create a 6-tuple from this one where the first, second, fourth, and fifthelements are exchanged.
    `<E1,E2,E4,E5,E6> Tuple6<E1,E2,T3,E4,E5,E6>` | `x12456(E1 e1, E2 e2, E4 e4, E5 e5, E6 e6)` Create a 6-tuple from this one where the first, second, fourth, fifth, and sixthelements are exchanged.
    `<E1,E2,E4,E6> Tuple6<E1,E2,T3,E4,T5,E6>` | `x1246(E1 e1, E2 e2, E4 e4, E6 e6)` Create a 6-tuple from this one where the first, second, fourth, and sixthelements are exchanged.
    `<E1,E2,E5> Tuple6<E1,E2,T3,T4,E5,T6>` | `x125(E1 e1, E2 e2, E5 e5)` Create a 6-tuple from this one where the first, second, and fifthelements are exchanged.
    `<E1,E2,E5,E6> Tuple6<E1,E2,T3,T4,E5,E6>` | `x1256(E1 e1, E2 e2, E5 e5, E6 e6)` Create a 6-tuple from this one where the first, second, fifth, and sixthelements are exchanged.
    `<E1,E2,E6> Tuple6<E1,E2,T3,T4,T5,E6>` | `x126(E1 e1, E2 e2, E6 e6)` Create a 6-tuple from this one where the first, second, and sixthelements are exchanged.
    `<E1,E3> Tuple6<E1,T2,E3,T4,T5,T6>` | `x13(E1 e1, E3 e3)` Create a 6-tuple from this one where the first and third elements are exchanged.
    `<E1,E3,E4> Tuple6<E1,T2,E3,E4,T5,T6>` | `x134(E1 e1, E3 e3, E4 e4)` Create a 6-tuple from this one where the first, third, and fourthelements are exchanged.
    `<E1,E3,E4,E5> Tuple6<E1,T2,E3,E4,E5,T6>` | `x1345(E1 e1, E3 e3, E4 e4, E5 e5)` Create a 6-tuple from this one where the first, third, fourth, and fifthelements are exchanged.
    `<E1,E3,E4,E5,E6> Tuple6<E1,T2,E3,E4,E5,E6>` | `x13456(E1 e1, E3 e3, E4 e4, E5 e5, E6 e6)` Create a 6-tuple from this one where the first, third, fourth, fifth, and sixthelements are exchanged.
    `<E1,E3,E4,E6> Tuple6<E1,T2,E3,E4,T5,E6>` | `x1346(E1 e1, E3 e3, E4 e4, E6 e6)` Create a 6-tuple from this one where the first, third, fourth, and sixthelements are exchanged.
    `<E1,E3,E5> Tuple6<E1,T2,E3,T4,E5,T6>` | `x135(E1 e1, E3 e3, E5 e5)` Create a 6-tuple from this one where the first, third, and fifthelements are exchanged.
    `<E1,E3,E5,E6> Tuple6<E1,T2,E3,T4,E5,E6>` | `x1356(E1 e1, E3 e3, E5 e5, E6 e6)` Create a 6-tuple from this one where the first, third, fifth, and sixthelements are exchanged.
    `<E1,E3,E6> Tuple6<E1,T2,E3,T4,T5,E6>` | `x136(E1 e1, E3 e3, E6 e6)` Create a 6-tuple from this one where the first, third, and sixthelements are exchanged.
    `<E1,E4> Tuple6<E1,T2,T3,E4,T5,T6>` | `x14(E1 e1, E4 e4)` Create a 6-tuple from this one where the first and fourth elements are exchanged.
    `<E1,E4,E5> Tuple6<E1,T2,T3,E4,E5,T6>` | `x145(E1 e1, E4 e4, E5 e5)` Create a 6-tuple from this one where the first, fourth, and fifthelements are exchanged.
    `<E1,E4,E5,E6> Tuple6<E1,T2,T3,E4,E5,E6>` | `x1456(E1 e1, E4 e4, E5 e5, E6 e6)` Create a 6-tuple from this one where the first, fourth, fifth, and sixthelements are exchanged.
    `<E1,E4,E6> Tuple6<E1,T2,T3,E4,T5,E6>` | `x146(E1 e1, E4 e4, E6 e6)` Create a 6-tuple from this one where the first, fourth, and sixthelements are exchanged.
    `<E1,E5> Tuple6<E1,T2,T3,T4,E5,T6>` | `x15(E1 e1, E5 e5)` Create a 6-tuple from this one where the first and fifth elements are exchanged.
    `<E1,E5,E6> Tuple6<E1,T2,T3,T4,E5,E6>` | `x156(E1 e1, E5 e5, E6 e6)` Create a 6-tuple from this one where the first, fifth, and sixthelements are exchanged.
    `<E1,E6> Tuple6<E1,T2,T3,T4,T5,E6>` | `x16(E1 e1, E6 e6)` Create a 6-tuple from this one where the first and sixth elements are exchanged.
    `<E2> Tuple6<T1,E2,T3,T4,T5,T6>` | `x2(E2 e2)` Create a 6-tuple from this one where the second element is exchanged.
    `<E2,E3> Tuple6<T1,E2,E3,T4,T5,T6>` | `x23(E2 e2, E3 e3)` Create a 6-tuple from this one where the second and third elements are exchanged.
    `<E2,E3,E4> Tuple6<T1,E2,E3,E4,T5,T6>` | `x234(E2 e2, E3 e3, E4 e4)` Create a 6-tuple from this one where the second, third, and fourthelements are exchanged.
    `<E2,E3,E4,E5> Tuple6<T1,E2,E3,E4,E5,T6>` | `x2345(E2 e2, E3 e3, E4 e4, E5 e5)` Create a 6-tuple from this one where the second, third, fourth, and fifthelements are exchanged.
    `<E2,E3,E4,E5,E6> Tuple6<T1,E2,E3,E4,E5,E6>` | `x23456(E2 e2, E3 e3, E4 e4, E5 e5, E6 e6)` Create a 6-tuple from this one where the second, third, fourth, fifth, and sixthelements are exchanged.
    `<E2,E3,E4,E6> Tuple6<T1,E2,E3,E4,T5,E6>` | `x2346(E2 e2, E3 e3, E4 e4, E6 e6)` Create a 6-tuple from this one where the second, third, fourth, and sixthelements are exchanged.
    `<E2,E3,E5> Tuple6<T1,E2,E3,T4,E5,T6>` | `x235(E2 e2, E3 e3, E5 e5)` Create a 6-tuple from this one where the second, third, and fifthelements are exchanged.
    `<E2,E3,E5,E6> Tuple6<T1,E2,E3,T4,E5,E6>` | `x2356(E2 e2, E3 e3, E5 e5, E6 e6)` Create a 6-tuple from this one where the second, third, fifth, and sixthelements are exchanged.
    `<E2,E3,E6> Tuple6<T1,E2,E3,T4,T5,E6>` | `x236(E2 e2, E3 e3, E6 e6)` Create a 6-tuple from this one where the second, third, and sixthelements are exchanged.
    `<E2,E4> Tuple6<T1,E2,T3,E4,T5,T6>` | `x24(E2 e2, E4 e4)` Create a 6-tuple from this one where the second and fourth elements are exchanged.
    `<E2,E4,E5> Tuple6<T1,E2,T3,E4,E5,T6>` | `x245(E2 e2, E4 e4, E5 e5)` Create a 6-tuple from this one where the second, fourth, and fifthelements are exchanged.
    `<E2,E4,E5,E6> Tuple6<T1,E2,T3,E4,E5,E6>` | `x2456(E2 e2, E4 e4, E5 e5, E6 e6)` Create a 6-tuple from this one where the second, fourth, fifth, and sixthelements are exchanged.
    `<E2,E4,E6> Tuple6<T1,E2,T3,E4,T5,E6>` | `x246(E2 e2, E4 e4, E6 e6)` Create a 6-tuple from this one where the second, fourth, and sixthelements are exchanged.
    `<E2,E5> Tuple6<T1,E2,T3,T4,E5,T6>` | `x25(E2 e2, E5 e5)` Create a 6-tuple from this one where the second and fifth elements are exchanged.
    `<E2,E5,E6> Tuple6<T1,E2,T3,T4,E5,E6>` | `x256(E2 e2, E5 e5, E6 e6)` Create a 6-tuple from this one where the second, fifth, and sixthelements are exchanged.
    `<E2,E6> Tuple6<T1,E2,T3,T4,T5,E6>` | `x26(E2 e2, E6 e6)` Create a 6-tuple from this one where the second and sixth elements are exchanged.
    `<E3> Tuple6<T1,T2,E3,T4,T5,T6>` | `x3(E3 e3)` Create a 6-tuple from this one where the third element is exchanged.
    `<E3,E4> Tuple6<T1,T2,E3,E4,T5,T6>` | `x34(E3 e3, E4 e4)` Create a 6-tuple from this one where the third and fourth elements are exchanged.
    `<E3,E4,E5> Tuple6<T1,T2,E3,E4,E5,T6>` | `x345(E3 e3, E4 e4, E5 e5)` Create a 6-tuple from this one where the third, fourth, and fifthelements are exchanged.
    `<E3,E4,E5,E6> Tuple6<T1,T2,E3,E4,E5,E6>` | `x3456(E3 e3, E4 e4, E5 e5, E6 e6)` Create a 6-tuple from this one where the third, fourth, fifth, and sixthelements are exchanged.
    `<E3,E4,E6> Tuple6<T1,T2,E3,E4,T5,E6>` | `x346(E3 e3, E4 e4, E6 e6)` Create a 6-tuple from this one where the third, fourth, and sixthelements are exchanged.
    `<E3,E5> Tuple6<T1,T2,E3,T4,E5,T6>` | `x35(E3 e3, E5 e5)` Create a 6-tuple from this one where the third and fifth elements are exchanged.
    `<E3,E5,E6> Tuple6<T1,T2,E3,T4,E5,E6>` | `x356(E3 e3, E5 e5, E6 e6)` Create a 6-tuple from this one where the third, fifth, and sixthelements are exchanged.
    `<E3,E6> Tuple6<T1,T2,E3,T4,T5,E6>` | `x36(E3 e3, E6 e6)` Create a 6-tuple from this one where the third and sixth elements are exchanged.
    `<E4> Tuple6<T1,T2,T3,E4,T5,T6>` | `x4(E4 e4)` Create a 6-tuple from this one where the fourth element is exchanged.
    `<E4,E5> Tuple6<T1,T2,T3,E4,E5,T6>` | `x45(E4 e4, E5 e5)` Create a 6-tuple from this one where the fourth and fifth elements are exchanged.
    `<E4,E5,E6> Tuple6<T1,T2,T3,E4,E5,E6>` | `x456(E4 e4, E5 e5, E6 e6)` Create a 6-tuple from this one where the fourth, fifth, and sixthelements are exchanged.
    `<E4,E6> Tuple6<T1,T2,T3,E4,T5,E6>` | `x46(E4 e4, E6 e6)` Create a 6-tuple from this one where the fourth and sixth elements are exchanged.
    `<E5> Tuple6<T1,T2,T3,T4,E5,T6>` | `x5(E5 e5)` Create a 6-tuple from this one where the fifth element is exchanged.
    `<E5,E6> Tuple6<T1,T2,T3,T4,E5,E6>` | `x56(E5 e5, E6 e6)` Create a 6-tuple from this one where the fifth and sixth elements are exchanged.
    `<E6> Tuple6<T1,T2,T3,T4,T5,E6>` | `x6(E6 e6)` Create a 6-tuple from this one where the sixth element is exchanged.

    - ### Methods inherited from class de.caff.generics.tuple.ITuple6.Base

      `asBase, equals, hashCode`

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

    - ### Methods inherited from interface de.caff.generics.tuple.ITuple6

      `concat1, concat2, concat3, concat4, concat5, concat6, concat7, concat8, concatPred1, concatPred2, concatPred3, concatPred4, concatPred5, concatPred6, concatPred7, concatPred8, concatProc1, concatProc2, concatProc3, concatProc4, concatProc5, concatProc6, concatProc7, concatProc8, equals, frozen, hash, invoke, sendTo, testBy, toString, toString, view`

- - ### Constructor Detail

    - #### Tuple6

          public Tuple6(@NotNull
                        T1 e1,
                        @NotNull
                        T2 e2,
                        @NotNull
                        T3 e3,
                        @NotNull
                        T4 e4,
                        @NotNull
                        T5 e5,
                        @NotNull
                        T6 e6)

      Constructor.
      Parameters:
        `e1` - first element
        `e2` - second element
        `e3` - third element
        `e4` - fourth element
        `e5` - fifth element
        `e6` - sixth element

  - ### Method Detail

    - #### _1

          @NotNull
          public T1 _1()

      Description copied from interface: `ITuple6`
      Get the first element.
      Specified by:
        `_1` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        first element

    - #### _2

          @NotNull
          public T2 _2()

      Description copied from interface: `ITuple6`
      Get the second element.
      Specified by:
        `_2` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        second element

    - #### _3

          @NotNull
          public T3 _3()

      Description copied from interface: `ITuple6`
      Get the third element.
      Specified by:
        `_3` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        third element

    - #### _4

          @NotNull
          public T4 _4()

      Description copied from interface: `ITuple6`
      Get the fourth element.
      Specified by:
        `_4` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        fourth element

    - #### _5

          @NotNull
          public T5 _5()

      Description copied from interface: `ITuple6`
      Get the fifth element.
      Specified by:
        `_5` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        fifth element

    - #### _6

          @NotNull
          public T6 _6()

      Description copied from interface: `ITuple6`
      Get the sixth element.
      Specified by:
        `_6` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        sixth element

    - #### _12345

          @NotNull
          public Tuple5<T1,T2,T3,T4,T5> _12345()

      Description copied from interface: `ITuple6`
      Create a new 5-tuple from this one where the elements are ordered: 1st, 2nd, 3rd, 4th, 5th.
      Specified by:
        `_12345` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _12346

          @NotNull
          public Tuple5<T1,T2,T3,T4,T6> _12346()

      Description copied from interface: `ITuple6`
      Create a new 5-tuple from this one where the elements are ordered: 1st, 2nd, 3rd, 4th, 6th.
      Specified by:
        `_12346` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _12356

          @NotNull
          public Tuple5<T1,T2,T3,T5,T6> _12356()

      Description copied from interface: `ITuple6`
      Create a new 5-tuple from this one where the elements are ordered: 1st, 2nd, 3rd, 5th, 6th.
      Specified by:
        `_12356` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _12456

          @NotNull
          public Tuple5<T1,T2,T4,T5,T6> _12456()

      Description copied from interface: `ITuple6`
      Create a new 5-tuple from this one where the elements are ordered: 1st, 2nd, 4th, 5th, 6th.
      Specified by:
        `_12456` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _13456

          @NotNull
          public Tuple5<T1,T3,T4,T5,T6> _13456()

      Description copied from interface: `ITuple6`
      Create a new 5-tuple from this one where the elements are ordered: 1st, 3rd, 4th, 5th, 6th.
      Specified by:
        `_13456` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _23456

          @NotNull
          public Tuple5<T2,T3,T4,T5,T6> _23456()

      Description copied from interface: `ITuple6`
      Create a new 5-tuple from this one where the elements are ordered: 2nd, 3rd, 4th, 5th, 6th.
      Specified by:
        `_23456` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _1234

          @NotNull
          public Tuple4<T1,T2,T3,T4> _1234()

      Description copied from interface: `ITuple6`
      Create a new 4-tuple from this one where the elements are ordered: 1st, 2nd, 3rd, 4th.
      Specified by:
        `_1234` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _1235

          @NotNull
          public Tuple4<T1,T2,T3,T5> _1235()

      Description copied from interface: `ITuple6`
      Create a new 4-tuple from this one where the elements are ordered: 1st, 2nd, 3rd, 5th.
      Specified by:
        `_1235` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _1245

          @NotNull
          public Tuple4<T1,T2,T4,T5> _1245()

      Description copied from interface: `ITuple6`
      Create a new 4-tuple from this one where the elements are ordered: 1st, 2nd, 4th, 5th.
      Specified by:
        `_1245` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _1345

          @NotNull
          public Tuple4<T1,T3,T4,T5> _1345()

      Description copied from interface: `ITuple6`
      Create a new 4-tuple from this one where the elements are ordered: 1st, 3rd, 4th, 5th.
      Specified by:
        `_1345` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _2345

          @NotNull
          public Tuple4<T2,T3,T4,T5> _2345()

      Description copied from interface: `ITuple6`
      Create a new 4-tuple from this one where the elements are ordered: 2nd, 3rd, 4th, 5th.
      Specified by:
        `_2345` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _1236

          @NotNull
          public Tuple4<T1,T2,T3,T6> _1236()

      Description copied from interface: `ITuple6`
      Create a new 4-tuple from this one where the elements are ordered: 1st, 2nd, 3rd, 6th.
      Specified by:
        `_1236` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _1246

          @NotNull
          public Tuple4<T1,T2,T4,T6> _1246()

      Description copied from interface: `ITuple6`
      Create a new 4-tuple from this one where the elements are ordered: 1st, 2nd, 4th, 6th.
      Specified by:
        `_1246` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _1346

          @NotNull
          public Tuple4<T1,T3,T4,T6> _1346()

      Description copied from interface: `ITuple6`
      Create a new 4-tuple from this one where the elements are ordered: 1st, 3rd, 4th, 6th.
      Specified by:
        `_1346` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _2346

          @NotNull
          public Tuple4<T2,T3,T4,T6> _2346()

      Description copied from interface: `ITuple6`
      Create a new 4-tuple from this one where the elements are ordered: 2nd, 3rd, 4th, 6th.
      Specified by:
        `_2346` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _1256

          @NotNull
          public Tuple4<T1,T2,T5,T6> _1256()

      Description copied from interface: `ITuple6`
      Create a new 4-tuple from this one where the elements are ordered: 1st, 2nd, 5th, 6th.
      Specified by:
        `_1256` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _1356

          @NotNull
          public Tuple4<T1,T3,T5,T6> _1356()

      Description copied from interface: `ITuple6`
      Create a new 4-tuple from this one where the elements are ordered: 1st, 3rd, 5th, 6th.
      Specified by:
        `_1356` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _2356

          @NotNull
          public Tuple4<T2,T3,T5,T6> _2356()

      Description copied from interface: `ITuple6`
      Create a new 4-tuple from this one where the elements are ordered: 2nd, 3rd, 5th, 6th.
      Specified by:
        `_2356` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _1456

          @NotNull
          public Tuple4<T1,T4,T5,T6> _1456()

      Description copied from interface: `ITuple6`
      Create a new 4-tuple from this one where the elements are ordered: 1st, 4th, 5th, 6th.
      Specified by:
        `_1456` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _2456

          @NotNull
          public Tuple4<T2,T4,T5,T6> _2456()

      Description copied from interface: `ITuple6`
      Create a new 4-tuple from this one where the elements are ordered: 2nd, 4th, 5th, 6th.
      Specified by:
        `_2456` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _3456

          @NotNull
          public Tuple4<T3,T4,T5,T6> _3456()

      Description copied from interface: `ITuple6`
      Create a new 4-tuple from this one where the elements are ordered: 3rd, 4th, 5th, 6th.
      Specified by:
        `_3456` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _123

          @NotNull
          public Tuple3<T1,T2,T3> _123()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 1st, 2nd, 3rd.
      Specified by:
        `_123` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _132

          @NotNull
          public Tuple3<T1,T3,T2> _132()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 1st, 3rd, 2nd.
      Specified by:
        `_132` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _312

          @NotNull
          public Tuple3<T3,T1,T2> _312()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 3rd, 1st, 2nd.
      Specified by:
        `_312` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _321

          @NotNull
          public Tuple3<T3,T2,T1> _321()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 3rd, 2nd, 1st.
      Specified by:
        `_321` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _231

          @NotNull
          public Tuple3<T2,T3,T1> _231()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 2nd, 3rd, 1st.
      Specified by:
        `_231` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _213

          @NotNull
          public Tuple3<T2,T1,T3> _213()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 2nd, 1st, 3rd.
      Specified by:
        `_213` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _124

          @NotNull
          public Tuple3<T1,T2,T4> _124()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 1st, 2nd, 4th.
      Specified by:
        `_124` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _142

          @NotNull
          public Tuple3<T1,T4,T2> _142()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 1st, 4th, 2nd.
      Specified by:
        `_142` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _412

          @NotNull
          public Tuple3<T4,T1,T2> _412()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 4th, 1st, 2nd.
      Specified by:
        `_412` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _421

          @NotNull
          public Tuple3<T4,T2,T1> _421()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 4th, 2nd, 1st.
      Specified by:
        `_421` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _241

          @NotNull
          public Tuple3<T2,T4,T1> _241()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 2nd, 4th, 1st.
      Specified by:
        `_241` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _214

          @NotNull
          public Tuple3<T2,T1,T4> _214()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 2nd, 1st, 4th.
      Specified by:
        `_214` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _134

          @NotNull
          public Tuple3<T1,T3,T4> _134()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 1st, 3rd, 4th.
      Specified by:
        `_134` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _143

          @NotNull
          public Tuple3<T1,T4,T3> _143()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 1st, 4th, 3rd.
      Specified by:
        `_143` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _413

          @NotNull
          public Tuple3<T4,T1,T3> _413()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 4th, 1st, 3rd.
      Specified by:
        `_413` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _431

          @NotNull
          public Tuple3<T4,T3,T1> _431()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 4th, 3rd, 1st.
      Specified by:
        `_431` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _341

          @NotNull
          public Tuple3<T3,T4,T1> _341()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 3rd, 4th, 1st.
      Specified by:
        `_341` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _314

          @NotNull
          public Tuple3<T3,T1,T4> _314()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 3rd, 1st, 4th.
      Specified by:
        `_314` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _234

          @NotNull
          public Tuple3<T2,T3,T4> _234()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 2nd, 3rd, 4th.
      Specified by:
        `_234` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _243

          @NotNull
          public Tuple3<T2,T4,T3> _243()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 2nd, 4th, 3rd.
      Specified by:
        `_243` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _423

          @NotNull
          public Tuple3<T4,T2,T3> _423()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 4th, 2nd, 3rd.
      Specified by:
        `_423` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _432

          @NotNull
          public Tuple3<T4,T3,T2> _432()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 4th, 3rd, 2nd.
      Specified by:
        `_432` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _342

          @NotNull
          public Tuple3<T3,T4,T2> _342()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 3rd, 4th, 2nd.
      Specified by:
        `_342` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _324

          @NotNull
          public Tuple3<T3,T2,T4> _324()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 3rd, 2nd, 4th.
      Specified by:
        `_324` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _125

          @NotNull
          public Tuple3<T1,T2,T5> _125()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 1st, 2nd, 5th.
      Specified by:
        `_125` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _152

          @NotNull
          public Tuple3<T1,T5,T2> _152()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 1st, 5th, 2nd.
      Specified by:
        `_152` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _512

          @NotNull
          public Tuple3<T5,T1,T2> _512()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 5th, 1st, 2nd.
      Specified by:
        `_512` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _521

          @NotNull
          public Tuple3<T5,T2,T1> _521()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 5th, 2nd, 1st.
      Specified by:
        `_521` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _251

          @NotNull
          public Tuple3<T2,T5,T1> _251()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 2nd, 5th, 1st.
      Specified by:
        `_251` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _215

          @NotNull
          public Tuple3<T2,T1,T5> _215()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 2nd, 1st, 5th.
      Specified by:
        `_215` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _135

          @NotNull
          public Tuple3<T1,T3,T5> _135()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 1st, 3rd, 5th.
      Specified by:
        `_135` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _153

          @NotNull
          public Tuple3<T1,T5,T3> _153()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 1st, 5th, 3rd.
      Specified by:
        `_153` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _513

          @NotNull
          public Tuple3<T5,T1,T3> _513()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 5th, 1st, 3rd.
      Specified by:
        `_513` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _531

          @NotNull
          public Tuple3<T5,T3,T1> _531()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 5th, 3rd, 1st.
      Specified by:
        `_531` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _351

          @NotNull
          public Tuple3<T3,T5,T1> _351()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 3rd, 5th, 1st.
      Specified by:
        `_351` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _315

          @NotNull
          public Tuple3<T3,T1,T5> _315()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 3rd, 1st, 5th.
      Specified by:
        `_315` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _235

          @NotNull
          public Tuple3<T2,T3,T5> _235()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 2nd, 3rd, 5th.
      Specified by:
        `_235` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _253

          @NotNull
          public Tuple3<T2,T5,T3> _253()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 2nd, 5th, 3rd.
      Specified by:
        `_253` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _523

          @NotNull
          public Tuple3<T5,T2,T3> _523()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 5th, 2nd, 3rd.
      Specified by:
        `_523` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _532

          @NotNull
          public Tuple3<T5,T3,T2> _532()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 5th, 3rd, 2nd.
      Specified by:
        `_532` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _352

          @NotNull
          public Tuple3<T3,T5,T2> _352()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 3rd, 5th, 2nd.
      Specified by:
        `_352` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _325

          @NotNull
          public Tuple3<T3,T2,T5> _325()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 3rd, 2nd, 5th.
      Specified by:
        `_325` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _145

          @NotNull
          public Tuple3<T1,T4,T5> _145()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 1st, 4th, 5th.
      Specified by:
        `_145` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _154

          @NotNull
          public Tuple3<T1,T5,T4> _154()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 1st, 5th, 4th.
      Specified by:
        `_154` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _514

          @NotNull
          public Tuple3<T5,T1,T4> _514()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 5th, 1st, 4th.
      Specified by:
        `_514` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _541

          @NotNull
          public Tuple3<T5,T4,T1> _541()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 5th, 4th, 1st.
      Specified by:
        `_541` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _451

          @NotNull
          public Tuple3<T4,T5,T1> _451()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 4th, 5th, 1st.
      Specified by:
        `_451` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _415

          @NotNull
          public Tuple3<T4,T1,T5> _415()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 4th, 1st, 5th.
      Specified by:
        `_415` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _245

          @NotNull
          public Tuple3<T2,T4,T5> _245()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 2nd, 4th, 5th.
      Specified by:
        `_245` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _254

          @NotNull
          public Tuple3<T2,T5,T4> _254()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 2nd, 5th, 4th.
      Specified by:
        `_254` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _524

          @NotNull
          public Tuple3<T5,T2,T4> _524()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 5th, 2nd, 4th.
      Specified by:
        `_524` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _542

          @NotNull
          public Tuple3<T5,T4,T2> _542()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 5th, 4th, 2nd.
      Specified by:
        `_542` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _452

          @NotNull
          public Tuple3<T4,T5,T2> _452()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 4th, 5th, 2nd.
      Specified by:
        `_452` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _425

          @NotNull
          public Tuple3<T4,T2,T5> _425()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 4th, 2nd, 5th.
      Specified by:
        `_425` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _345

          @NotNull
          public Tuple3<T3,T4,T5> _345()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 3rd, 4th, 5th.
      Specified by:
        `_345` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _354

          @NotNull
          public Tuple3<T3,T5,T4> _354()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 3rd, 5th, 4th.
      Specified by:
        `_354` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _534

          @NotNull
          public Tuple3<T5,T3,T4> _534()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 5th, 3rd, 4th.
      Specified by:
        `_534` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _543

          @NotNull
          public Tuple3<T5,T4,T3> _543()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 5th, 4th, 3rd.
      Specified by:
        `_543` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _453

          @NotNull
          public Tuple3<T4,T5,T3> _453()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 4th, 5th, 3rd.
      Specified by:
        `_453` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _435

          @NotNull
          public Tuple3<T4,T3,T5> _435()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 4th, 3rd, 5th.
      Specified by:
        `_435` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _126

          @NotNull
          public Tuple3<T1,T2,T6> _126()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 1st, 2nd, 6th.
      Specified by:
        `_126` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _162

          @NotNull
          public Tuple3<T1,T6,T2> _162()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 1st, 6th, 2nd.
      Specified by:
        `_162` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _612

          @NotNull
          public Tuple3<T6,T1,T2> _612()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 6th, 1st, 2nd.
      Specified by:
        `_612` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _621

          @NotNull
          public Tuple3<T6,T2,T1> _621()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 6th, 2nd, 1st.
      Specified by:
        `_621` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _261

          @NotNull
          public Tuple3<T2,T6,T1> _261()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 2nd, 6th, 1st.
      Specified by:
        `_261` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _216

          @NotNull
          public Tuple3<T2,T1,T6> _216()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 2nd, 1st, 6th.
      Specified by:
        `_216` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _136

          @NotNull
          public Tuple3<T1,T3,T6> _136()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 1st, 3rd, 6th.
      Specified by:
        `_136` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _163

          @NotNull
          public Tuple3<T1,T6,T3> _163()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 1st, 6th, 3rd.
      Specified by:
        `_163` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _613

          @NotNull
          public Tuple3<T6,T1,T3> _613()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 6th, 1st, 3rd.
      Specified by:
        `_613` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _631

          @NotNull
          public Tuple3<T6,T3,T1> _631()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 6th, 3rd, 1st.
      Specified by:
        `_631` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _361

          @NotNull
          public Tuple3<T3,T6,T1> _361()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 3rd, 6th, 1st.
      Specified by:
        `_361` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _316

          @NotNull
          public Tuple3<T3,T1,T6> _316()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 3rd, 1st, 6th.
      Specified by:
        `_316` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _236

          @NotNull
          public Tuple3<T2,T3,T6> _236()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 2nd, 3rd, 6th.
      Specified by:
        `_236` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _263

          @NotNull
          public Tuple3<T2,T6,T3> _263()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 2nd, 6th, 3rd.
      Specified by:
        `_263` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _623

          @NotNull
          public Tuple3<T6,T2,T3> _623()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 6th, 2nd, 3rd.
      Specified by:
        `_623` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _632

          @NotNull
          public Tuple3<T6,T3,T2> _632()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 6th, 3rd, 2nd.
      Specified by:
        `_632` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _362

          @NotNull
          public Tuple3<T3,T6,T2> _362()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 3rd, 6th, 2nd.
      Specified by:
        `_362` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _326

          @NotNull
          public Tuple3<T3,T2,T6> _326()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 3rd, 2nd, 6th.
      Specified by:
        `_326` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _146

          @NotNull
          public Tuple3<T1,T4,T6> _146()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 1st, 4th, 6th.
      Specified by:
        `_146` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _164

          @NotNull
          public Tuple3<T1,T6,T4> _164()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 1st, 6th, 4th.
      Specified by:
        `_164` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _614

          @NotNull
          public Tuple3<T6,T1,T4> _614()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 6th, 1st, 4th.
      Specified by:
        `_614` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _641

          @NotNull
          public Tuple3<T6,T4,T1> _641()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 6th, 4th, 1st.
      Specified by:
        `_641` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _461

          @NotNull
          public Tuple3<T4,T6,T1> _461()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 4th, 6th, 1st.
      Specified by:
        `_461` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _416

          @NotNull
          public Tuple3<T4,T1,T6> _416()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 4th, 1st, 6th.
      Specified by:
        `_416` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _246

          @NotNull
          public Tuple3<T2,T4,T6> _246()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 2nd, 4th, 6th.
      Specified by:
        `_246` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _264

          @NotNull
          public Tuple3<T2,T6,T4> _264()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 2nd, 6th, 4th.
      Specified by:
        `_264` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _624

          @NotNull
          public Tuple3<T6,T2,T4> _624()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 6th, 2nd, 4th.
      Specified by:
        `_624` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _642

          @NotNull
          public Tuple3<T6,T4,T2> _642()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 6th, 4th, 2nd.
      Specified by:
        `_642` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _462

          @NotNull
          public Tuple3<T4,T6,T2> _462()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 4th, 6th, 2nd.
      Specified by:
        `_462` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _426

          @NotNull
          public Tuple3<T4,T2,T6> _426()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 4th, 2nd, 6th.
      Specified by:
        `_426` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _346

          @NotNull
          public Tuple3<T3,T4,T6> _346()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 3rd, 4th, 6th.
      Specified by:
        `_346` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _364

          @NotNull
          public Tuple3<T3,T6,T4> _364()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 3rd, 6th, 4th.
      Specified by:
        `_364` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _634

          @NotNull
          public Tuple3<T6,T3,T4> _634()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 6th, 3rd, 4th.
      Specified by:
        `_634` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _643

          @NotNull
          public Tuple3<T6,T4,T3> _643()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 6th, 4th, 3rd.
      Specified by:
        `_643` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _463

          @NotNull
          public Tuple3<T4,T6,T3> _463()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 4th, 6th, 3rd.
      Specified by:
        `_463` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _436

          @NotNull
          public Tuple3<T4,T3,T6> _436()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 4th, 3rd, 6th.
      Specified by:
        `_436` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _156

          @NotNull
          public Tuple3<T1,T5,T6> _156()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 1st, 5th, 6th.
      Specified by:
        `_156` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _165

          @NotNull
          public Tuple3<T1,T6,T5> _165()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 1st, 6th, 5th.
      Specified by:
        `_165` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _615

          @NotNull
          public Tuple3<T6,T1,T5> _615()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 6th, 1st, 5th.
      Specified by:
        `_615` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _651

          @NotNull
          public Tuple3<T6,T5,T1> _651()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 6th, 5th, 1st.
      Specified by:
        `_651` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _561

          @NotNull
          public Tuple3<T5,T6,T1> _561()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 5th, 6th, 1st.
      Specified by:
        `_561` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _516

          @NotNull
          public Tuple3<T5,T1,T6> _516()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 5th, 1st, 6th.
      Specified by:
        `_516` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _256

          @NotNull
          public Tuple3<T2,T5,T6> _256()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 2nd, 5th, 6th.
      Specified by:
        `_256` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _265

          @NotNull
          public Tuple3<T2,T6,T5> _265()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 2nd, 6th, 5th.
      Specified by:
        `_265` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _625

          @NotNull
          public Tuple3<T6,T2,T5> _625()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 6th, 2nd, 5th.
      Specified by:
        `_625` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _652

          @NotNull
          public Tuple3<T6,T5,T2> _652()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 6th, 5th, 2nd.
      Specified by:
        `_652` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _562

          @NotNull
          public Tuple3<T5,T6,T2> _562()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 5th, 6th, 2nd.
      Specified by:
        `_562` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _526

          @NotNull
          public Tuple3<T5,T2,T6> _526()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 5th, 2nd, 6th.
      Specified by:
        `_526` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _356

          @NotNull
          public Tuple3<T3,T5,T6> _356()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 3rd, 5th, 6th.
      Specified by:
        `_356` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _365

          @NotNull
          public Tuple3<T3,T6,T5> _365()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 3rd, 6th, 5th.
      Specified by:
        `_365` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _635

          @NotNull
          public Tuple3<T6,T3,T5> _635()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 6th, 3rd, 5th.
      Specified by:
        `_635` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _653

          @NotNull
          public Tuple3<T6,T5,T3> _653()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 6th, 5th, 3rd.
      Specified by:
        `_653` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _563

          @NotNull
          public Tuple3<T5,T6,T3> _563()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 5th, 6th, 3rd.
      Specified by:
        `_563` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _536

          @NotNull
          public Tuple3<T5,T3,T6> _536()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 5th, 3rd, 6th.
      Specified by:
        `_536` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _456

          @NotNull
          public Tuple3<T4,T5,T6> _456()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 4th, 5th, 6th.
      Specified by:
        `_456` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _465

          @NotNull
          public Tuple3<T4,T6,T5> _465()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 4th, 6th, 5th.
      Specified by:
        `_465` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _645

          @NotNull
          public Tuple3<T6,T4,T5> _645()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 6th, 4th, 5th.
      Specified by:
        `_645` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _654

          @NotNull
          public Tuple3<T6,T5,T4> _654()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 6th, 5th, 4th.
      Specified by:
        `_654` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _564

          @NotNull
          public Tuple3<T5,T6,T4> _564()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 5th, 6th, 4th.
      Specified by:
        `_564` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _546

          @NotNull
          public Tuple3<T5,T4,T6> _546()

      Description copied from interface: `ITuple6`
      Create a new 3-tuple from this one where the elements are ordered: 5th, 4th, 6th.
      Specified by:
        `_546` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _12

          @NotNull
          public Tuple2<T1,T2> _12()

      Description copied from interface: `ITuple6`
      Create a new 2-tuple from this one where the elements are ordered: 1st, 2nd.
      Specified by:
        `_12` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _21

          @NotNull
          public Tuple2<T2,T1> _21()

      Description copied from interface: `ITuple6`
      Create a new 2-tuple from this one where the elements are ordered: 2nd, 1st.
      Specified by:
        `_21` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _13

          @NotNull
          public Tuple2<T1,T3> _13()

      Description copied from interface: `ITuple6`
      Create a new 2-tuple from this one where the elements are ordered: 1st, 3rd.
      Specified by:
        `_13` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _31

          @NotNull
          public Tuple2<T3,T1> _31()

      Description copied from interface: `ITuple6`
      Create a new 2-tuple from this one where the elements are ordered: 3rd, 1st.
      Specified by:
        `_31` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _23

          @NotNull
          public Tuple2<T2,T3> _23()

      Description copied from interface: `ITuple6`
      Create a new 2-tuple from this one where the elements are ordered: 2nd, 3rd.
      Specified by:
        `_23` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _32

          @NotNull
          public Tuple2<T3,T2> _32()

      Description copied from interface: `ITuple6`
      Create a new 2-tuple from this one where the elements are ordered: 3rd, 2nd.
      Specified by:
        `_32` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _14

          @NotNull
          public Tuple2<T1,T4> _14()

      Description copied from interface: `ITuple6`
      Create a new 2-tuple from this one where the elements are ordered: 1st, 4th.
      Specified by:
        `_14` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _41

          @NotNull
          public Tuple2<T4,T1> _41()

      Description copied from interface: `ITuple6`
      Create a new 2-tuple from this one where the elements are ordered: 4th, 1st.
      Specified by:
        `_41` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _24

          @NotNull
          public Tuple2<T2,T4> _24()

      Description copied from interface: `ITuple6`
      Create a new 2-tuple from this one where the elements are ordered: 2nd, 4th.
      Specified by:
        `_24` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _42

          @NotNull
          public Tuple2<T4,T2> _42()

      Description copied from interface: `ITuple6`
      Create a new 2-tuple from this one where the elements are ordered: 4th, 2nd.
      Specified by:
        `_42` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _34

          @NotNull
          public Tuple2<T3,T4> _34()

      Description copied from interface: `ITuple6`
      Create a new 2-tuple from this one where the elements are ordered: 3rd, 4th.
      Specified by:
        `_34` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _43

          @NotNull
          public Tuple2<T4,T3> _43()

      Description copied from interface: `ITuple6`
      Create a new 2-tuple from this one where the elements are ordered: 4th, 3rd.
      Specified by:
        `_43` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _15

          @NotNull
          public Tuple2<T1,T5> _15()

      Description copied from interface: `ITuple6`
      Create a new 2-tuple from this one where the elements are ordered: 1st, 5th.
      Specified by:
        `_15` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _51

          @NotNull
          public Tuple2<T5,T1> _51()

      Description copied from interface: `ITuple6`
      Create a new 2-tuple from this one where the elements are ordered: 5th, 1st.
      Specified by:
        `_51` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _25

          @NotNull
          public Tuple2<T2,T5> _25()

      Description copied from interface: `ITuple6`
      Create a new 2-tuple from this one where the elements are ordered: 2nd, 5th.
      Specified by:
        `_25` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _52

          @NotNull
          public Tuple2<T5,T2> _52()

      Description copied from interface: `ITuple6`
      Create a new 2-tuple from this one where the elements are ordered: 5th, 2nd.
      Specified by:
        `_52` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _35

          @NotNull
          public Tuple2<T3,T5> _35()

      Description copied from interface: `ITuple6`
      Create a new 2-tuple from this one where the elements are ordered: 3rd, 5th.
      Specified by:
        `_35` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _53

          @NotNull
          public Tuple2<T5,T3> _53()

      Description copied from interface: `ITuple6`
      Create a new 2-tuple from this one where the elements are ordered: 5th, 3rd.
      Specified by:
        `_53` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _45

          @NotNull
          public Tuple2<T4,T5> _45()

      Description copied from interface: `ITuple6`
      Create a new 2-tuple from this one where the elements are ordered: 4th, 5th.
      Specified by:
        `_45` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _54

          @NotNull
          public Tuple2<T5,T4> _54()

      Description copied from interface: `ITuple6`
      Create a new 2-tuple from this one where the elements are ordered: 5th, 4th.
      Specified by:
        `_54` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _16

          @NotNull
          public Tuple2<T1,T6> _16()

      Description copied from interface: `ITuple6`
      Create a new 2-tuple from this one where the elements are ordered: 1st, 6th.
      Specified by:
        `_16` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _61

          @NotNull
          public Tuple2<T6,T1> _61()

      Description copied from interface: `ITuple6`
      Create a new 2-tuple from this one where the elements are ordered: 6th, 1st.
      Specified by:
        `_61` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _26

          @NotNull
          public Tuple2<T2,T6> _26()

      Description copied from interface: `ITuple6`
      Create a new 2-tuple from this one where the elements are ordered: 2nd, 6th.
      Specified by:
        `_26` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _62

          @NotNull
          public Tuple2<T6,T2> _62()

      Description copied from interface: `ITuple6`
      Create a new 2-tuple from this one where the elements are ordered: 6th, 2nd.
      Specified by:
        `_62` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _36

          @NotNull
          public Tuple2<T3,T6> _36()

      Description copied from interface: `ITuple6`
      Create a new 2-tuple from this one where the elements are ordered: 3rd, 6th.
      Specified by:
        `_36` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _63

          @NotNull
          public Tuple2<T6,T3> _63()

      Description copied from interface: `ITuple6`
      Create a new 2-tuple from this one where the elements are ordered: 6th, 3rd.
      Specified by:
        `_63` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _46

          @NotNull
          public Tuple2<T4,T6> _46()

      Description copied from interface: `ITuple6`
      Create a new 2-tuple from this one where the elements are ordered: 4th, 6th.
      Specified by:
        `_46` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _64

          @NotNull
          public Tuple2<T6,T4> _64()

      Description copied from interface: `ITuple6`
      Create a new 2-tuple from this one where the elements are ordered: 6th, 4th.
      Specified by:
        `_64` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _56

          @NotNull
          public Tuple2<T5,T6> _56()

      Description copied from interface: `ITuple6`
      Create a new 2-tuple from this one where the elements are ordered: 5th, 6th.
      Specified by:
        `_56` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### _65

          @NotNull
          public Tuple2<T6,T5> _65()

      Description copied from interface: `ITuple6`
      Create a new 2-tuple from this one where the elements are ordered: 6th, 5th.
      Specified by:
        `_65` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        reordered tuple

    - #### frozenNotNull

          @NotNull
          public Tuple6<T1,T2,T3,T4,T5,T6> frozenNotNull()

      Description copied from interface: `ITuple6`
      Convert this into an object of a concrete tuple implementation. This is useful because implementations may just be a view of something else. This method makes sure to decouple the tuple from the viewed object. The resulting tuple is guaranteed not to have `null` elements, but if this interface has `null` elements this method will throw a `NullPointerException`.

      See `ITuple6.frozen()` for a method which will not throw exceptions.

      Specified by:
        `frozenNotNull` in interface `ITuple6<T1,T2,T3,T4,T5,T6>`
      Returns:
        standalone tuple object

    - #### x1

          @NotNull
          public <E1> Tuple6<E1,T2,T3,T4,T5,T6> x1(@NotNull
                                                            E1 e1)

      Create a 6-tuple from this one where the first element is exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
      Parameters:
        `e1` - new first element
      Returns:
        tuple with exchanged element

    - #### x2

          @NotNull
          public <E2> Tuple6<T1,E2,T3,T4,T5,T6> x2(@NotNull
                                                            E2 e2)

      Create a 6-tuple from this one where the second element is exchanged.
      Type Parameters:
        `E2` - type of exchanged second element
      Parameters:
        `e2` - new second element
      Returns:
        tuple with exchanged element

    - #### x3

          @NotNull
          public <E3> Tuple6<T1,T2,E3,T4,T5,T6> x3(@NotNull
                                                            E3 e3)

      Create a 6-tuple from this one where the third element is exchanged.
      Type Parameters:
        `E3` - type of exchanged third element
      Parameters:
        `e3` - new third element
      Returns:
        tuple with exchanged element

    - #### x4

          @NotNull
          public <E4> Tuple6<T1,T2,T3,E4,T5,T6> x4(@NotNull
                                                            E4 e4)

      Create a 6-tuple from this one where the fourth element is exchanged.
      Type Parameters:
        `E4` - type of exchanged fourth element
      Parameters:
        `e4` - new fourth element
      Returns:
        tuple with exchanged element

    - #### x5

          @NotNull
          public <E5> Tuple6<T1,T2,T3,T4,E5,T6> x5(@NotNull
                                                            E5 e5)

      Create a 6-tuple from this one where the fifth element is exchanged.
      Type Parameters:
        `E5` - type of exchanged fifth element
      Parameters:
        `e5` - new fifth element
      Returns:
        tuple with exchanged element

    - #### x6

          @NotNull
          public <E6> Tuple6<T1,T2,T3,T4,T5,E6> x6(@NotNull
                                                            E6 e6)

      Create a 6-tuple from this one where the sixth element is exchanged.
      Type Parameters:
        `E6` - type of exchanged sixth element
      Parameters:
        `e6` - new sixth element
      Returns:
        tuple with exchanged element

    - #### x12

          @NotNull
          public <E1,E2> Tuple6<E1,E2,T3,T4,T5,T6> x12(@NotNull
                                                                E1 e1,
                                                                @NotNull
                                                                E2 e2)

      Create a 6-tuple from this one where the first and second elements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E2` - type of exchanged second element
      Parameters:
        `e1` - new first element
        `e2` - new second element
      Returns:
        tuple with exchanged elements

    - #### x13

          @NotNull
          public <E1,E3> Tuple6<E1,T2,E3,T4,T5,T6> x13(@NotNull
                                                                E1 e1,
                                                                @NotNull
                                                                E3 e3)

      Create a 6-tuple from this one where the first and third elements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E3` - type of exchanged third element
      Parameters:
        `e1` - new first element
        `e3` - new third element
      Returns:
        tuple with exchanged elements

    - #### x23

          @NotNull
          public <E2,E3> Tuple6<T1,E2,E3,T4,T5,T6> x23(@NotNull
                                                                E2 e2,
                                                                @NotNull
                                                                E3 e3)

      Create a 6-tuple from this one where the second and third elements are exchanged.
      Type Parameters:
        `E2` - type of exchanged second element
        `E3` - type of exchanged third element
      Parameters:
        `e2` - new second element
        `e3` - new third element
      Returns:
        tuple with exchanged elements

    - #### x14

          @NotNull
          public <E1,E4> Tuple6<E1,T2,T3,E4,T5,T6> x14(@NotNull
                                                                E1 e1,
                                                                @NotNull
                                                                E4 e4)

      Create a 6-tuple from this one where the first and fourth elements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E4` - type of exchanged fourth element
      Parameters:
        `e1` - new first element
        `e4` - new fourth element
      Returns:
        tuple with exchanged elements

    - #### x24

          @NotNull
          public <E2,E4> Tuple6<T1,E2,T3,E4,T5,T6> x24(@NotNull
                                                                E2 e2,
                                                                @NotNull
                                                                E4 e4)

      Create a 6-tuple from this one where the second and fourth elements are exchanged.
      Type Parameters:
        `E2` - type of exchanged second element
        `E4` - type of exchanged fourth element
      Parameters:
        `e2` - new second element
        `e4` - new fourth element
      Returns:
        tuple with exchanged elements

    - #### x34

          @NotNull
          public <E3,E4> Tuple6<T1,T2,E3,E4,T5,T6> x34(@NotNull
                                                                E3 e3,
                                                                @NotNull
                                                                E4 e4)

      Create a 6-tuple from this one where the third and fourth elements are exchanged.
      Type Parameters:
        `E3` - type of exchanged third element
        `E4` - type of exchanged fourth element
      Parameters:
        `e3` - new third element
        `e4` - new fourth element
      Returns:
        tuple with exchanged elements

    - #### x15

          @NotNull
          public <E1,E5> Tuple6<E1,T2,T3,T4,E5,T6> x15(@NotNull
                                                                E1 e1,
                                                                @NotNull
                                                                E5 e5)

      Create a 6-tuple from this one where the first and fifth elements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E5` - type of exchanged fifth element
      Parameters:
        `e1` - new first element
        `e5` - new fifth element
      Returns:
        tuple with exchanged elements

    - #### x25

          @NotNull
          public <E2,E5> Tuple6<T1,E2,T3,T4,E5,T6> x25(@NotNull
                                                                E2 e2,
                                                                @NotNull
                                                                E5 e5)

      Create a 6-tuple from this one where the second and fifth elements are exchanged.
      Type Parameters:
        `E2` - type of exchanged second element
        `E5` - type of exchanged fifth element
      Parameters:
        `e2` - new second element
        `e5` - new fifth element
      Returns:
        tuple with exchanged elements

    - #### x35

          @NotNull
          public <E3,E5> Tuple6<T1,T2,E3,T4,E5,T6> x35(@NotNull
                                                                E3 e3,
                                                                @NotNull
                                                                E5 e5)

      Create a 6-tuple from this one where the third and fifth elements are exchanged.
      Type Parameters:
        `E3` - type of exchanged third element
        `E5` - type of exchanged fifth element
      Parameters:
        `e3` - new third element
        `e5` - new fifth element
      Returns:
        tuple with exchanged elements

    - #### x45

          @NotNull
          public <E4,E5> Tuple6<T1,T2,T3,E4,E5,T6> x45(@NotNull
                                                                E4 e4,
                                                                @NotNull
                                                                E5 e5)

      Create a 6-tuple from this one where the fourth and fifth elements are exchanged.
      Type Parameters:
        `E4` - type of exchanged fourth element
        `E5` - type of exchanged fifth element
      Parameters:
        `e4` - new fourth element
        `e5` - new fifth element
      Returns:
        tuple with exchanged elements

    - #### x16

          @NotNull
          public <E1,E6> Tuple6<E1,T2,T3,T4,T5,E6> x16(@NotNull
                                                                E1 e1,
                                                                @NotNull
                                                                E6 e6)

      Create a 6-tuple from this one where the first and sixth elements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E6` - type of exchanged sixth element
      Parameters:
        `e1` - new first element
        `e6` - new sixth element
      Returns:
        tuple with exchanged elements

    - #### x26

          @NotNull
          public <E2,E6> Tuple6<T1,E2,T3,T4,T5,E6> x26(@NotNull
                                                                E2 e2,
                                                                @NotNull
                                                                E6 e6)

      Create a 6-tuple from this one where the second and sixth elements are exchanged.
      Type Parameters:
        `E2` - type of exchanged second element
        `E6` - type of exchanged sixth element
      Parameters:
        `e2` - new second element
        `e6` - new sixth element
      Returns:
        tuple with exchanged elements

    - #### x36

          @NotNull
          public <E3,E6> Tuple6<T1,T2,E3,T4,T5,E6> x36(@NotNull
                                                                E3 e3,
                                                                @NotNull
                                                                E6 e6)

      Create a 6-tuple from this one where the third and sixth elements are exchanged.
      Type Parameters:
        `E3` - type of exchanged third element
        `E6` - type of exchanged sixth element
      Parameters:
        `e3` - new third element
        `e6` - new sixth element
      Returns:
        tuple with exchanged elements

    - #### x46

          @NotNull
          public <E4,E6> Tuple6<T1,T2,T3,E4,T5,E6> x46(@NotNull
                                                                E4 e4,
                                                                @NotNull
                                                                E6 e6)

      Create a 6-tuple from this one where the fourth and sixth elements are exchanged.
      Type Parameters:
        `E4` - type of exchanged fourth element
        `E6` - type of exchanged sixth element
      Parameters:
        `e4` - new fourth element
        `e6` - new sixth element
      Returns:
        tuple with exchanged elements

    - #### x56

          @NotNull
          public <E5,E6> Tuple6<T1,T2,T3,T4,E5,E6> x56(@NotNull
                                                                E5 e5,
                                                                @NotNull
                                                                E6 e6)

      Create a 6-tuple from this one where the fifth and sixth elements are exchanged.
      Type Parameters:
        `E5` - type of exchanged fifth element
        `E6` - type of exchanged sixth element
      Parameters:
        `e5` - new fifth element
        `e6` - new sixth element
      Returns:
        tuple with exchanged elements

    - #### x123

          @NotNull
          public <E1,E2,E3> Tuple6<E1,E2,E3,T4,T5,T6> x123(@NotNull
                                                                    E1 e1,
                                                                    @NotNull
                                                                    E2 e2,
                                                                    @NotNull
                                                                    E3 e3)

      Create a 6-tuple from this one where the first, second, and thirdelements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E2` - type of exchanged second element
        `E3` - type of exchanged third element
      Parameters:
        `e1` - new first element
        `e2` - new second element
        `e3` - new third element
      Returns:
        tuple with exchanged elements

    - #### x124

          @NotNull
          public <E1,E2,E4> Tuple6<E1,E2,T3,E4,T5,T6> x124(@NotNull
                                                                    E1 e1,
                                                                    @NotNull
                                                                    E2 e2,
                                                                    @NotNull
                                                                    E4 e4)

      Create a 6-tuple from this one where the first, second, and fourthelements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E2` - type of exchanged second element
        `E4` - type of exchanged fourth element
      Parameters:
        `e1` - new first element
        `e2` - new second element
        `e4` - new fourth element
      Returns:
        tuple with exchanged elements

    - #### x134

          @NotNull
          public <E1,E3,E4> Tuple6<E1,T2,E3,E4,T5,T6> x134(@NotNull
                                                                    E1 e1,
                                                                    @NotNull
                                                                    E3 e3,
                                                                    @NotNull
                                                                    E4 e4)

      Create a 6-tuple from this one where the first, third, and fourthelements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E3` - type of exchanged third element
        `E4` - type of exchanged fourth element
      Parameters:
        `e1` - new first element
        `e3` - new third element
        `e4` - new fourth element
      Returns:
        tuple with exchanged elements

    - #### x234

          @NotNull
          public <E2,E3,E4> Tuple6<T1,E2,E3,E4,T5,T6> x234(@NotNull
                                                                    E2 e2,
                                                                    @NotNull
                                                                    E3 e3,
                                                                    @NotNull
                                                                    E4 e4)

      Create a 6-tuple from this one where the second, third, and fourthelements are exchanged.
      Type Parameters:
        `E2` - type of exchanged second element
        `E3` - type of exchanged third element
        `E4` - type of exchanged fourth element
      Parameters:
        `e2` - new second element
        `e3` - new third element
        `e4` - new fourth element
      Returns:
        tuple with exchanged elements

    - #### x125

          @NotNull
          public <E1,E2,E5> Tuple6<E1,E2,T3,T4,E5,T6> x125(@NotNull
                                                                    E1 e1,
                                                                    @NotNull
                                                                    E2 e2,
                                                                    @NotNull
                                                                    E5 e5)

      Create a 6-tuple from this one where the first, second, and fifthelements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E2` - type of exchanged second element
        `E5` - type of exchanged fifth element
      Parameters:
        `e1` - new first element
        `e2` - new second element
        `e5` - new fifth element
      Returns:
        tuple with exchanged elements

    - #### x135

          @NotNull
          public <E1,E3,E5> Tuple6<E1,T2,E3,T4,E5,T6> x135(@NotNull
                                                                    E1 e1,
                                                                    @NotNull
                                                                    E3 e3,
                                                                    @NotNull
                                                                    E5 e5)

      Create a 6-tuple from this one where the first, third, and fifthelements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E3` - type of exchanged third element
        `E5` - type of exchanged fifth element
      Parameters:
        `e1` - new first element
        `e3` - new third element
        `e5` - new fifth element
      Returns:
        tuple with exchanged elements

    - #### x235

          @NotNull
          public <E2,E3,E5> Tuple6<T1,E2,E3,T4,E5,T6> x235(@NotNull
                                                                    E2 e2,
                                                                    @NotNull
                                                                    E3 e3,
                                                                    @NotNull
                                                                    E5 e5)

      Create a 6-tuple from this one where the second, third, and fifthelements are exchanged.
      Type Parameters:
        `E2` - type of exchanged second element
        `E3` - type of exchanged third element
        `E5` - type of exchanged fifth element
      Parameters:
        `e2` - new second element
        `e3` - new third element
        `e5` - new fifth element
      Returns:
        tuple with exchanged elements

    - #### x145

          @NotNull
          public <E1,E4,E5> Tuple6<E1,T2,T3,E4,E5,T6> x145(@NotNull
                                                                    E1 e1,
                                                                    @NotNull
                                                                    E4 e4,
                                                                    @NotNull
                                                                    E5 e5)

      Create a 6-tuple from this one where the first, fourth, and fifthelements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E4` - type of exchanged fourth element
        `E5` - type of exchanged fifth element
      Parameters:
        `e1` - new first element
        `e4` - new fourth element
        `e5` - new fifth element
      Returns:
        tuple with exchanged elements

    - #### x245

          @NotNull
          public <E2,E4,E5> Tuple6<T1,E2,T3,E4,E5,T6> x245(@NotNull
                                                                    E2 e2,
                                                                    @NotNull
                                                                    E4 e4,
                                                                    @NotNull
                                                                    E5 e5)

      Create a 6-tuple from this one where the second, fourth, and fifthelements are exchanged.
      Type Parameters:
        `E2` - type of exchanged second element
        `E4` - type of exchanged fourth element
        `E5` - type of exchanged fifth element
      Parameters:
        `e2` - new second element
        `e4` - new fourth element
        `e5` - new fifth element
      Returns:
        tuple with exchanged elements

    - #### x345

          @NotNull
          public <E3,E4,E5> Tuple6<T1,T2,E3,E4,E5,T6> x345(@NotNull
                                                                    E3 e3,
                                                                    @NotNull
                                                                    E4 e4,
                                                                    @NotNull
                                                                    E5 e5)

      Create a 6-tuple from this one where the third, fourth, and fifthelements are exchanged.
      Type Parameters:
        `E3` - type of exchanged third element
        `E4` - type of exchanged fourth element
        `E5` - type of exchanged fifth element
      Parameters:
        `e3` - new third element
        `e4` - new fourth element
        `e5` - new fifth element
      Returns:
        tuple with exchanged elements

    - #### x126

          @NotNull
          public <E1,E2,E6> Tuple6<E1,E2,T3,T4,T5,E6> x126(@NotNull
                                                                    E1 e1,
                                                                    @NotNull
                                                                    E2 e2,
                                                                    @NotNull
                                                                    E6 e6)

      Create a 6-tuple from this one where the first, second, and sixthelements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E2` - type of exchanged second element
        `E6` - type of exchanged sixth element
      Parameters:
        `e1` - new first element
        `e2` - new second element
        `e6` - new sixth element
      Returns:
        tuple with exchanged elements

    - #### x136

          @NotNull
          public <E1,E3,E6> Tuple6<E1,T2,E3,T4,T5,E6> x136(@NotNull
                                                                    E1 e1,
                                                                    @NotNull
                                                                    E3 e3,
                                                                    @NotNull
                                                                    E6 e6)

      Create a 6-tuple from this one where the first, third, and sixthelements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E3` - type of exchanged third element
        `E6` - type of exchanged sixth element
      Parameters:
        `e1` - new first element
        `e3` - new third element
        `e6` - new sixth element
      Returns:
        tuple with exchanged elements

    - #### x236

          @NotNull
          public <E2,E3,E6> Tuple6<T1,E2,E3,T4,T5,E6> x236(@NotNull
                                                                    E2 e2,
                                                                    @NotNull
                                                                    E3 e3,
                                                                    @NotNull
                                                                    E6 e6)

      Create a 6-tuple from this one where the second, third, and sixthelements are exchanged.
      Type Parameters:
        `E2` - type of exchanged second element
        `E3` - type of exchanged third element
        `E6` - type of exchanged sixth element
      Parameters:
        `e2` - new second element
        `e3` - new third element
        `e6` - new sixth element
      Returns:
        tuple with exchanged elements

    - #### x146

          @NotNull
          public <E1,E4,E6> Tuple6<E1,T2,T3,E4,T5,E6> x146(@NotNull
                                                                    E1 e1,
                                                                    @NotNull
                                                                    E4 e4,
                                                                    @NotNull
                                                                    E6 e6)

      Create a 6-tuple from this one where the first, fourth, and sixthelements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E4` - type of exchanged fourth element
        `E6` - type of exchanged sixth element
      Parameters:
        `e1` - new first element
        `e4` - new fourth element
        `e6` - new sixth element
      Returns:
        tuple with exchanged elements

    - #### x246

          @NotNull
          public <E2,E4,E6> Tuple6<T1,E2,T3,E4,T5,E6> x246(@NotNull
                                                                    E2 e2,
                                                                    @NotNull
                                                                    E4 e4,
                                                                    @NotNull
                                                                    E6 e6)

      Create a 6-tuple from this one where the second, fourth, and sixthelements are exchanged.
      Type Parameters:
        `E2` - type of exchanged second element
        `E4` - type of exchanged fourth element
        `E6` - type of exchanged sixth element
      Parameters:
        `e2` - new second element
        `e4` - new fourth element
        `e6` - new sixth element
      Returns:
        tuple with exchanged elements

    - #### x346

          @NotNull
          public <E3,E4,E6> Tuple6<T1,T2,E3,E4,T5,E6> x346(@NotNull
                                                                    E3 e3,
                                                                    @NotNull
                                                                    E4 e4,
                                                                    @NotNull
                                                                    E6 e6)

      Create a 6-tuple from this one where the third, fourth, and sixthelements are exchanged.
      Type Parameters:
        `E3` - type of exchanged third element
        `E4` - type of exchanged fourth element
        `E6` - type of exchanged sixth element
      Parameters:
        `e3` - new third element
        `e4` - new fourth element
        `e6` - new sixth element
      Returns:
        tuple with exchanged elements

    - #### x156

          @NotNull
          public <E1,E5,E6> Tuple6<E1,T2,T3,T4,E5,E6> x156(@NotNull
                                                                    E1 e1,
                                                                    @NotNull
                                                                    E5 e5,
                                                                    @NotNull
                                                                    E6 e6)

      Create a 6-tuple from this one where the first, fifth, and sixthelements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E5` - type of exchanged fifth element
        `E6` - type of exchanged sixth element
      Parameters:
        `e1` - new first element
        `e5` - new fifth element
        `e6` - new sixth element
      Returns:
        tuple with exchanged elements

    - #### x256

          @NotNull
          public <E2,E5,E6> Tuple6<T1,E2,T3,T4,E5,E6> x256(@NotNull
                                                                    E2 e2,
                                                                    @NotNull
                                                                    E5 e5,
                                                                    @NotNull
                                                                    E6 e6)

      Create a 6-tuple from this one where the second, fifth, and sixthelements are exchanged.
      Type Parameters:
        `E2` - type of exchanged second element
        `E5` - type of exchanged fifth element
        `E6` - type of exchanged sixth element
      Parameters:
        `e2` - new second element
        `e5` - new fifth element
        `e6` - new sixth element
      Returns:
        tuple with exchanged elements

    - #### x356

          @NotNull
          public <E3,E5,E6> Tuple6<T1,T2,E3,T4,E5,E6> x356(@NotNull
                                                                    E3 e3,
                                                                    @NotNull
                                                                    E5 e5,
                                                                    @NotNull
                                                                    E6 e6)

      Create a 6-tuple from this one where the third, fifth, and sixthelements are exchanged.
      Type Parameters:
        `E3` - type of exchanged third element
        `E5` - type of exchanged fifth element
        `E6` - type of exchanged sixth element
      Parameters:
        `e3` - new third element
        `e5` - new fifth element
        `e6` - new sixth element
      Returns:
        tuple with exchanged elements

    - #### x456

          @NotNull
          public <E4,E5,E6> Tuple6<T1,T2,T3,E4,E5,E6> x456(@NotNull
                                                                    E4 e4,
                                                                    @NotNull
                                                                    E5 e5,
                                                                    @NotNull
                                                                    E6 e6)

      Create a 6-tuple from this one where the fourth, fifth, and sixthelements are exchanged.
      Type Parameters:
        `E4` - type of exchanged fourth element
        `E5` - type of exchanged fifth element
        `E6` - type of exchanged sixth element
      Parameters:
        `e4` - new fourth element
        `e5` - new fifth element
        `e6` - new sixth element
      Returns:
        tuple with exchanged elements

    - #### x1234

          @NotNull
          public <E1,E2,E3,E4> Tuple6<E1,E2,E3,E4,T5,T6> x1234(@NotNull
                                                                        E1 e1,
                                                                        @NotNull
                                                                        E2 e2,
                                                                        @NotNull
                                                                        E3 e3,
                                                                        @NotNull
                                                                        E4 e4)

      Create a 6-tuple from this one where the first, second, third, and fourthelements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E2` - type of exchanged second element
        `E3` - type of exchanged third element
        `E4` - type of exchanged fourth element
      Parameters:
        `e1` - new first element
        `e2` - new second element
        `e3` - new third element
        `e4` - new fourth element
      Returns:
        tuple with exchanged elements

    - #### x1235

          @NotNull
          public <E1,E2,E3,E5> Tuple6<E1,E2,E3,T4,E5,T6> x1235(@NotNull
                                                                        E1 e1,
                                                                        @NotNull
                                                                        E2 e2,
                                                                        @NotNull
                                                                        E3 e3,
                                                                        @NotNull
                                                                        E5 e5)

      Create a 6-tuple from this one where the first, second, third, and fifthelements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E2` - type of exchanged second element
        `E3` - type of exchanged third element
        `E5` - type of exchanged fifth element
      Parameters:
        `e1` - new first element
        `e2` - new second element
        `e3` - new third element
        `e5` - new fifth element
      Returns:
        tuple with exchanged elements

    - #### x1245

          @NotNull
          public <E1,E2,E4,E5> Tuple6<E1,E2,T3,E4,E5,T6> x1245(@NotNull
                                                                        E1 e1,
                                                                        @NotNull
                                                                        E2 e2,
                                                                        @NotNull
                                                                        E4 e4,
                                                                        @NotNull
                                                                        E5 e5)

      Create a 6-tuple from this one where the first, second, fourth, and fifthelements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E2` - type of exchanged second element
        `E4` - type of exchanged fourth element
        `E5` - type of exchanged fifth element
      Parameters:
        `e1` - new first element
        `e2` - new second element
        `e4` - new fourth element
        `e5` - new fifth element
      Returns:
        tuple with exchanged elements

    - #### x1345

          @NotNull
          public <E1,E3,E4,E5> Tuple6<E1,T2,E3,E4,E5,T6> x1345(@NotNull
                                                                        E1 e1,
                                                                        @NotNull
                                                                        E3 e3,
                                                                        @NotNull
                                                                        E4 e4,
                                                                        @NotNull
                                                                        E5 e5)

      Create a 6-tuple from this one where the first, third, fourth, and fifthelements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E3` - type of exchanged third element
        `E4` - type of exchanged fourth element
        `E5` - type of exchanged fifth element
      Parameters:
        `e1` - new first element
        `e3` - new third element
        `e4` - new fourth element
        `e5` - new fifth element
      Returns:
        tuple with exchanged elements

    - #### x2345

          @NotNull
          public <E2,E3,E4,E5> Tuple6<T1,E2,E3,E4,E5,T6> x2345(@NotNull
                                                                        E2 e2,
                                                                        @NotNull
                                                                        E3 e3,
                                                                        @NotNull
                                                                        E4 e4,
                                                                        @NotNull
                                                                        E5 e5)

      Create a 6-tuple from this one where the second, third, fourth, and fifthelements are exchanged.
      Type Parameters:
        `E2` - type of exchanged second element
        `E3` - type of exchanged third element
        `E4` - type of exchanged fourth element
        `E5` - type of exchanged fifth element
      Parameters:
        `e2` - new second element
        `e3` - new third element
        `e4` - new fourth element
        `e5` - new fifth element
      Returns:
        tuple with exchanged elements

    - #### x1236

          @NotNull
          public <E1,E2,E3,E6> Tuple6<E1,E2,E3,T4,T5,E6> x1236(@NotNull
                                                                        E1 e1,
                                                                        @NotNull
                                                                        E2 e2,
                                                                        @NotNull
                                                                        E3 e3,
                                                                        @NotNull
                                                                        E6 e6)

      Create a 6-tuple from this one where the first, second, third, and sixthelements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E2` - type of exchanged second element
        `E3` - type of exchanged third element
        `E6` - type of exchanged sixth element
      Parameters:
        `e1` - new first element
        `e2` - new second element
        `e3` - new third element
        `e6` - new sixth element
      Returns:
        tuple with exchanged elements

    - #### x1246

          @NotNull
          public <E1,E2,E4,E6> Tuple6<E1,E2,T3,E4,T5,E6> x1246(@NotNull
                                                                        E1 e1,
                                                                        @NotNull
                                                                        E2 e2,
                                                                        @NotNull
                                                                        E4 e4,
                                                                        @NotNull
                                                                        E6 e6)

      Create a 6-tuple from this one where the first, second, fourth, and sixthelements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E2` - type of exchanged second element
        `E4` - type of exchanged fourth element
        `E6` - type of exchanged sixth element
      Parameters:
        `e1` - new first element
        `e2` - new second element
        `e4` - new fourth element
        `e6` - new sixth element
      Returns:
        tuple with exchanged elements

    - #### x1346

          @NotNull
          public <E1,E3,E4,E6> Tuple6<E1,T2,E3,E4,T5,E6> x1346(@NotNull
                                                                        E1 e1,
                                                                        @NotNull
                                                                        E3 e3,
                                                                        @NotNull
                                                                        E4 e4,
                                                                        @NotNull
                                                                        E6 e6)

      Create a 6-tuple from this one where the first, third, fourth, and sixthelements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E3` - type of exchanged third element
        `E4` - type of exchanged fourth element
        `E6` - type of exchanged sixth element
      Parameters:
        `e1` - new first element
        `e3` - new third element
        `e4` - new fourth element
        `e6` - new sixth element
      Returns:
        tuple with exchanged elements

    - #### x2346

          @NotNull
          public <E2,E3,E4,E6> Tuple6<T1,E2,E3,E4,T5,E6> x2346(@NotNull
                                                                        E2 e2,
                                                                        @NotNull
                                                                        E3 e3,
                                                                        @NotNull
                                                                        E4 e4,
                                                                        @NotNull
                                                                        E6 e6)

      Create a 6-tuple from this one where the second, third, fourth, and sixthelements are exchanged.
      Type Parameters:
        `E2` - type of exchanged second element
        `E3` - type of exchanged third element
        `E4` - type of exchanged fourth element
        `E6` - type of exchanged sixth element
      Parameters:
        `e2` - new second element
        `e3` - new third element
        `e4` - new fourth element
        `e6` - new sixth element
      Returns:
        tuple with exchanged elements

    - #### x1256

          @NotNull
          public <E1,E2,E5,E6> Tuple6<E1,E2,T3,T4,E5,E6> x1256(@NotNull
                                                                        E1 e1,
                                                                        @NotNull
                                                                        E2 e2,
                                                                        @NotNull
                                                                        E5 e5,
                                                                        @NotNull
                                                                        E6 e6)

      Create a 6-tuple from this one where the first, second, fifth, and sixthelements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E2` - type of exchanged second element
        `E5` - type of exchanged fifth element
        `E6` - type of exchanged sixth element
      Parameters:
        `e1` - new first element
        `e2` - new second element
        `e5` - new fifth element
        `e6` - new sixth element
      Returns:
        tuple with exchanged elements

    - #### x1356

          @NotNull
          public <E1,E3,E5,E6> Tuple6<E1,T2,E3,T4,E5,E6> x1356(@NotNull
                                                                        E1 e1,
                                                                        @NotNull
                                                                        E3 e3,
                                                                        @NotNull
                                                                        E5 e5,
                                                                        @NotNull
                                                                        E6 e6)

      Create a 6-tuple from this one where the first, third, fifth, and sixthelements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E3` - type of exchanged third element
        `E5` - type of exchanged fifth element
        `E6` - type of exchanged sixth element
      Parameters:
        `e1` - new first element
        `e3` - new third element
        `e5` - new fifth element
        `e6` - new sixth element
      Returns:
        tuple with exchanged elements

    - #### x2356

          @NotNull
          public <E2,E3,E5,E6> Tuple6<T1,E2,E3,T4,E5,E6> x2356(@NotNull
                                                                        E2 e2,
                                                                        @NotNull
                                                                        E3 e3,
                                                                        @NotNull
                                                                        E5 e5,
                                                                        @NotNull
                                                                        E6 e6)

      Create a 6-tuple from this one where the second, third, fifth, and sixthelements are exchanged.
      Type Parameters:
        `E2` - type of exchanged second element
        `E3` - type of exchanged third element
        `E5` - type of exchanged fifth element
        `E6` - type of exchanged sixth element
      Parameters:
        `e2` - new second element
        `e3` - new third element
        `e5` - new fifth element
        `e6` - new sixth element
      Returns:
        tuple with exchanged elements

    - #### x1456

          @NotNull
          public <E1,E4,E5,E6> Tuple6<E1,T2,T3,E4,E5,E6> x1456(@NotNull
                                                                        E1 e1,
                                                                        @NotNull
                                                                        E4 e4,
                                                                        @NotNull
                                                                        E5 e5,
                                                                        @NotNull
                                                                        E6 e6)

      Create a 6-tuple from this one where the first, fourth, fifth, and sixthelements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E4` - type of exchanged fourth element
        `E5` - type of exchanged fifth element
        `E6` - type of exchanged sixth element
      Parameters:
        `e1` - new first element
        `e4` - new fourth element
        `e5` - new fifth element
        `e6` - new sixth element
      Returns:
        tuple with exchanged elements

    - #### x2456

          @NotNull
          public <E2,E4,E5,E6> Tuple6<T1,E2,T3,E4,E5,E6> x2456(@NotNull
                                                                        E2 e2,
                                                                        @NotNull
                                                                        E4 e4,
                                                                        @NotNull
                                                                        E5 e5,
                                                                        @NotNull
                                                                        E6 e6)

      Create a 6-tuple from this one where the second, fourth, fifth, and sixthelements are exchanged.
      Type Parameters:
        `E2` - type of exchanged second element
        `E4` - type of exchanged fourth element
        `E5` - type of exchanged fifth element
        `E6` - type of exchanged sixth element
      Parameters:
        `e2` - new second element
        `e4` - new fourth element
        `e5` - new fifth element
        `e6` - new sixth element
      Returns:
        tuple with exchanged elements

    - #### x3456

          @NotNull
          public <E3,E4,E5,E6> Tuple6<T1,T2,E3,E4,E5,E6> x3456(@NotNull
                                                                        E3 e3,
                                                                        @NotNull
                                                                        E4 e4,
                                                                        @NotNull
                                                                        E5 e5,
                                                                        @NotNull
                                                                        E6 e6)

      Create a 6-tuple from this one where the third, fourth, fifth, and sixthelements are exchanged.
      Type Parameters:
        `E3` - type of exchanged third element
        `E4` - type of exchanged fourth element
        `E5` - type of exchanged fifth element
        `E6` - type of exchanged sixth element
      Parameters:
        `e3` - new third element
        `e4` - new fourth element
        `e5` - new fifth element
        `e6` - new sixth element
      Returns:
        tuple with exchanged elements

    - #### x12345

          @NotNull
          public <E1,E2,E3,E4,E5> Tuple6<E1,E2,E3,E4,E5,T6> x12345(@NotNull
                                                                            E1 e1,
                                                                            @NotNull
                                                                            E2 e2,
                                                                            @NotNull
                                                                            E3 e3,
                                                                            @NotNull
                                                                            E4 e4,
                                                                            @NotNull
                                                                            E5 e5)

      Create a 6-tuple from this one where the first, second, third, fourth, and fifthelements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E2` - type of exchanged second element
        `E3` - type of exchanged third element
        `E4` - type of exchanged fourth element
        `E5` - type of exchanged fifth element
      Parameters:
        `e1` - new first element
        `e2` - new second element
        `e3` - new third element
        `e4` - new fourth element
        `e5` - new fifth element
      Returns:
        tuple with exchanged elements

    - #### x12346

          @NotNull
          public <E1,E2,E3,E4,E6> Tuple6<E1,E2,E3,E4,T5,E6> x12346(@NotNull
                                                                            E1 e1,
                                                                            @NotNull
                                                                            E2 e2,
                                                                            @NotNull
                                                                            E3 e3,
                                                                            @NotNull
                                                                            E4 e4,
                                                                            @NotNull
                                                                            E6 e6)

      Create a 6-tuple from this one where the first, second, third, fourth, and sixthelements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E2` - type of exchanged second element
        `E3` - type of exchanged third element
        `E4` - type of exchanged fourth element
        `E6` - type of exchanged sixth element
      Parameters:
        `e1` - new first element
        `e2` - new second element
        `e3` - new third element
        `e4` - new fourth element
        `e6` - new sixth element
      Returns:
        tuple with exchanged elements

    - #### x12356

          @NotNull
          public <E1,E2,E3,E5,E6> Tuple6<E1,E2,E3,T4,E5,E6> x12356(@NotNull
                                                                            E1 e1,
                                                                            @NotNull
                                                                            E2 e2,
                                                                            @NotNull
                                                                            E3 e3,
                                                                            @NotNull
                                                                            E5 e5,
                                                                            @NotNull
                                                                            E6 e6)

      Create a 6-tuple from this one where the first, second, third, fifth, and sixthelements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E2` - type of exchanged second element
        `E3` - type of exchanged third element
        `E5` - type of exchanged fifth element
        `E6` - type of exchanged sixth element
      Parameters:
        `e1` - new first element
        `e2` - new second element
        `e3` - new third element
        `e5` - new fifth element
        `e6` - new sixth element
      Returns:
        tuple with exchanged elements

    - #### x12456

          @NotNull
          public <E1,E2,E4,E5,E6> Tuple6<E1,E2,T3,E4,E5,E6> x12456(@NotNull
                                                                            E1 e1,
                                                                            @NotNull
                                                                            E2 e2,
                                                                            @NotNull
                                                                            E4 e4,
                                                                            @NotNull
                                                                            E5 e5,
                                                                            @NotNull
                                                                            E6 e6)

      Create a 6-tuple from this one where the first, second, fourth, fifth, and sixthelements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E2` - type of exchanged second element
        `E4` - type of exchanged fourth element
        `E5` - type of exchanged fifth element
        `E6` - type of exchanged sixth element
      Parameters:
        `e1` - new first element
        `e2` - new second element
        `e4` - new fourth element
        `e5` - new fifth element
        `e6` - new sixth element
      Returns:
        tuple with exchanged elements

    - #### x13456

          @NotNull
          public <E1,E3,E4,E5,E6> Tuple6<E1,T2,E3,E4,E5,E6> x13456(@NotNull
                                                                            E1 e1,
                                                                            @NotNull
                                                                            E3 e3,
                                                                            @NotNull
                                                                            E4 e4,
                                                                            @NotNull
                                                                            E5 e5,
                                                                            @NotNull
                                                                            E6 e6)

      Create a 6-tuple from this one where the first, third, fourth, fifth, and sixthelements are exchanged.
      Type Parameters:
        `E1` - type of exchanged first element
        `E3` - type of exchanged third element
        `E4` - type of exchanged fourth element
        `E5` - type of exchanged fifth element
        `E6` - type of exchanged sixth element
      Parameters:
        `e1` - new first element
        `e3` - new third element
        `e4` - new fourth element
        `e5` - new fifth element
        `e6` - new sixth element
      Returns:
        tuple with exchanged elements

    - #### x23456

          @NotNull
          public <E2,E3,E4,E5,E6> Tuple6<T1,E2,E3,E4,E5,E6> x23456(@NotNull
                                                                            E2 e2,
                                                                            @NotNull
                                                                            E3 e3,
                                                                            @NotNull
                                                                            E4 e4,
                                                                            @NotNull
                                                                            E5 e5,
                                                                            @NotNull
                                                                            E6 e6)

      Create a 6-tuple from this one where the second, third, fourth, fifth, and sixthelements are exchanged.
      Type Parameters:
        `E2` - type of exchanged second element
        `E3` - type of exchanged third element
        `E4` - type of exchanged fourth element
        `E5` - type of exchanged fifth element
        `E6` - type of exchanged sixth element
      Parameters:
        `e2` - new second element
        `e3` - new third element
        `e4` - new fourth element
        `e5` - new fifth element
        `e6` - new sixth element
      Returns:
        tuple with exchanged elements

    - #### i1

          @NotNull
          public <T> Tuple7<T,T1,T2,T3,T4,T5,T6> i1(@NotNull
                                                             T e1)

      Create a 7-tuple from this 6-tuple by inserting a new first element.
      Type Parameters:
        `T` - new element type
      Parameters:
        `e1` - new element
      Returns:
        7-tuple

    - #### i2

          @NotNull
          public <T> Tuple7<T1,T,T2,T3,T4,T5,T6> i2(@NotNull
                                                             T e2)

      Create a 7-tuple from this 6-tuple by inserting a new second element.
      Type Parameters:
        `T` - new element type
      Parameters:
        `e2` - new element
      Returns:
        7-tuple

    - #### i3

          @NotNull
          public <T> Tuple7<T1,T2,T,T3,T4,T5,T6> i3(@NotNull
                                                             T e3)

      Create a 7-tuple from this 6-tuple by inserting a new third element.
      Type Parameters:
        `T` - new element type
      Parameters:
        `e3` - new element
      Returns:
        7-tuple

    - #### i4

          @NotNull
          public <T> Tuple7<T1,T2,T3,T,T4,T5,T6> i4(@NotNull
                                                             T e4)

      Create a 7-tuple from this 6-tuple by inserting a new fourth element.
      Type Parameters:
        `T` - new element type
      Parameters:
        `e4` - new element
      Returns:
        7-tuple

    - #### i5

          @NotNull
          public <T> Tuple7<T1,T2,T3,T4,T,T5,T6> i5(@NotNull
                                                             T e5)

      Create a 7-tuple from this 6-tuple by inserting a new fifth element.
      Type Parameters:
        `T` - new element type
      Parameters:
        `e5` - new element
      Returns:
        7-tuple

    - #### i6

          @NotNull
          public <T> Tuple7<T1,T2,T3,T4,T5,T,T6> i6(@NotNull
                                                             T e6)

      Create a 7-tuple from this 6-tuple by inserting a new sixth element.
      Type Parameters:
        `T` - new element type
      Parameters:
        `e6` - new element
      Returns:
        7-tuple

    - #### i7

          @NotNull
          public <T> Tuple7<T1,T2,T3,T4,T5,T6,T> i7(@NotNull
                                                             T e7)

      Create a 7-tuple from this 6-tuple by adding a new seventh element.
      Type Parameters:
        `T` - new element type
      Parameters:
        `e7` - new element
      Returns:
        7-tuple

    - #### toString

          @NotNull
          public java.lang.String toString()

      Overrides:
        `toString` in class `ITuple6.Base<T1,T2,T3,T4,T5,T6>`