de.caff.generics.tuple

## Class NTuple5<T1,T2,T3,T4,T5>

- java.lang.Object
- - de.caff.generics.tuple.ITuple5.Base<T1,T2,T3,T4,T5>
  - - de.caff.generics.tuple.NTuple5<T1,T2,T3,T4,T5>

- 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
  All Implemented Interfaces:
    ITuple5<T1,T2,T3,T4,T5>, java.io.Serializable

      public class NTuple5<T1,T2,T3,T4,T5>
      extends ITuple5.Base<T1,T2,T3,T4,T5>
      implements java.io.Serializable

  Immutable tuple with 5 nullable 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(ITuple5)` 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:
    `Tuple5`, Serialized Form

- - ### Nested Class Summary

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

      `ITuple5.Base<T1,T2,T3,T4,T5>`

  - ### Constructor Summary

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

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `T1` | `_1()` Get the first element.
    `NTuple2<T1,T2>` | `_12()` Create a new 2-tuple from this one where the elements are ordered: 1st, 2nd.
    `NTuple3<T1,T2,T3>` | `_123()` Create a new 3-tuple from this one where the elements are ordered: 1st, 2nd, 3rd.
    `NTuple4<T1,T2,T3,T4>` | `_1234()` Create a new 4-tuple from this one where the elements are ordered: 1st, 2nd, 3rd, 4th.
    `NTuple4<T1,T2,T3,T5>` | `_1235()` Create a new 4-tuple from this one where the elements are ordered: 1st, 2nd, 3rd, 5th.
    `NTuple5<T1,T2,T3,T5,T4>` | `_12354()` Create a new 5-tuple from this one where the elements are ordered: 1st, 2nd, 3rd, 5th, 4th.
    `NTuple3<T1,T2,T4>` | `_124()` Create a new 3-tuple from this one where the elements are ordered: 1st, 2nd, 4th.
    `NTuple5<T1,T2,T4,T3,T5>` | `_12435()` Create a new 5-tuple from this one where the elements are ordered: 1st, 2nd, 4th, 3rd, 5th.
    `NTuple4<T1,T2,T4,T5>` | `_1245()` Create a new 4-tuple from this one where the elements are ordered: 1st, 2nd, 4th, 5th.
    `NTuple5<T1,T2,T4,T5,T3>` | `_12453()` Create a new 5-tuple from this one where the elements are ordered: 1st, 2nd, 4th, 5th, 3rd.
    `NTuple3<T1,T2,T5>` | `_125()` Create a new 3-tuple from this one where the elements are ordered: 1st, 2nd, 5th.
    `NTuple5<T1,T2,T5,T3,T4>` | `_12534()` Create a new 5-tuple from this one where the elements are ordered: 1st, 2nd, 5th, 3rd, 4th.
    `NTuple5<T1,T2,T5,T4,T3>` | `_12543()` Create a new 5-tuple from this one where the elements are ordered: 1st, 2nd, 5th, 4th, 3rd.
    `NTuple2<T1,T3>` | `_13()` Create a new 2-tuple from this one where the elements are ordered: 1st, 3rd.
    `NTuple3<T1,T3,T2>` | `_132()` Create a new 3-tuple from this one where the elements are ordered: 1st, 3rd, 2nd.
    `NTuple5<T1,T3,T2,T4,T5>` | `_13245()` Create a new 5-tuple from this one where the elements are ordered: 1st, 3rd, 2nd, 4th, 5th.
    `NTuple5<T1,T3,T2,T5,T4>` | `_13254()` Create a new 5-tuple from this one where the elements are ordered: 1st, 3rd, 2nd, 5th, 4th.
    `NTuple3<T1,T3,T4>` | `_134()` Create a new 3-tuple from this one where the elements are ordered: 1st, 3rd, 4th.
    `NTuple5<T1,T3,T4,T2,T5>` | `_13425()` Create a new 5-tuple from this one where the elements are ordered: 1st, 3rd, 4th, 2nd, 5th.
    `NTuple4<T1,T3,T4,T5>` | `_1345()` Create a new 4-tuple from this one where the elements are ordered: 1st, 3rd, 4th, 5th.
    `NTuple5<T1,T3,T4,T5,T2>` | `_13452()` Create a new 5-tuple from this one where the elements are ordered: 1st, 3rd, 4th, 5th, 2nd.
    `NTuple3<T1,T3,T5>` | `_135()` Create a new 3-tuple from this one where the elements are ordered: 1st, 3rd, 5th.
    `NTuple5<T1,T3,T5,T2,T4>` | `_13524()` Create a new 5-tuple from this one where the elements are ordered: 1st, 3rd, 5th, 2nd, 4th.
    `NTuple5<T1,T3,T5,T4,T2>` | `_13542()` Create a new 5-tuple from this one where the elements are ordered: 1st, 3rd, 5th, 4th, 2nd.
    `NTuple2<T1,T4>` | `_14()` Create a new 2-tuple from this one where the elements are ordered: 1st, 4th.
    `NTuple3<T1,T4,T2>` | `_142()` Create a new 3-tuple from this one where the elements are ordered: 1st, 4th, 2nd.
    `NTuple5<T1,T4,T2,T3,T5>` | `_14235()` Create a new 5-tuple from this one where the elements are ordered: 1st, 4th, 2nd, 3rd, 5th.
    `NTuple5<T1,T4,T2,T5,T3>` | `_14253()` Create a new 5-tuple from this one where the elements are ordered: 1st, 4th, 2nd, 5th, 3rd.
    `NTuple3<T1,T4,T3>` | `_143()` Create a new 3-tuple from this one where the elements are ordered: 1st, 4th, 3rd.
    `NTuple5<T1,T4,T3,T2,T5>` | `_14325()` Create a new 5-tuple from this one where the elements are ordered: 1st, 4th, 3rd, 2nd, 5th.
    `NTuple5<T1,T4,T3,T5,T2>` | `_14352()` Create a new 5-tuple from this one where the elements are ordered: 1st, 4th, 3rd, 5th, 2nd.
    `NTuple3<T1,T4,T5>` | `_145()` Create a new 3-tuple from this one where the elements are ordered: 1st, 4th, 5th.
    `NTuple5<T1,T4,T5,T2,T3>` | `_14523()` Create a new 5-tuple from this one where the elements are ordered: 1st, 4th, 5th, 2nd, 3rd.
    `NTuple5<T1,T4,T5,T3,T2>` | `_14532()` Create a new 5-tuple from this one where the elements are ordered: 1st, 4th, 5th, 3rd, 2nd.
    `NTuple2<T1,T5>` | `_15()` Create a new 2-tuple from this one where the elements are ordered: 1st, 5th.
    `NTuple3<T1,T5,T2>` | `_152()` Create a new 3-tuple from this one where the elements are ordered: 1st, 5th, 2nd.
    `NTuple5<T1,T5,T2,T3,T4>` | `_15234()` Create a new 5-tuple from this one where the elements are ordered: 1st, 5th, 2nd, 3rd, 4th.
    `NTuple5<T1,T5,T2,T4,T3>` | `_15243()` Create a new 5-tuple from this one where the elements are ordered: 1st, 5th, 2nd, 4th, 3rd.
    `NTuple3<T1,T5,T3>` | `_153()` Create a new 3-tuple from this one where the elements are ordered: 1st, 5th, 3rd.
    `NTuple5<T1,T5,T3,T2,T4>` | `_15324()` Create a new 5-tuple from this one where the elements are ordered: 1st, 5th, 3rd, 2nd, 4th.
    `NTuple5<T1,T5,T3,T4,T2>` | `_15342()` Create a new 5-tuple from this one where the elements are ordered: 1st, 5th, 3rd, 4th, 2nd.
    `NTuple3<T1,T5,T4>` | `_154()` Create a new 3-tuple from this one where the elements are ordered: 1st, 5th, 4th.
    `NTuple5<T1,T5,T4,T2,T3>` | `_15423()` Create a new 5-tuple from this one where the elements are ordered: 1st, 5th, 4th, 2nd, 3rd.
    `NTuple5<T1,T5,T4,T3,T2>` | `_15432()` Create a new 5-tuple from this one where the elements are ordered: 1st, 5th, 4th, 3rd, 2nd.
    `T2` | `_2()` Get the second element.
    `NTuple2<T2,T1>` | `_21()` Create a new 2-tuple from this one where the elements are ordered: 2nd, 1st.
    `NTuple3<T2,T1,T3>` | `_213()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 1st, 3rd.
    `NTuple5<T2,T1,T3,T4,T5>` | `_21345()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 1st, 3rd, 4th, 5th.
    `NTuple5<T2,T1,T3,T5,T4>` | `_21354()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 1st, 3rd, 5th, 4th.
    `NTuple3<T2,T1,T4>` | `_214()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 1st, 4th.
    `NTuple5<T2,T1,T4,T3,T5>` | `_21435()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 1st, 4th, 3rd, 5th.
    `NTuple5<T2,T1,T4,T5,T3>` | `_21453()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 1st, 4th, 5th, 3rd.
    `NTuple3<T2,T1,T5>` | `_215()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 1st, 5th.
    `NTuple5<T2,T1,T5,T3,T4>` | `_21534()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 1st, 5th, 3rd, 4th.
    `NTuple5<T2,T1,T5,T4,T3>` | `_21543()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 1st, 5th, 4th, 3rd.
    `NTuple2<T2,T3>` | `_23()` Create a new 2-tuple from this one where the elements are ordered: 2nd, 3rd.
    `NTuple3<T2,T3,T1>` | `_231()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 3rd, 1st.
    `NTuple5<T2,T3,T1,T4,T5>` | `_23145()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 3rd, 1st, 4th, 5th.
    `NTuple5<T2,T3,T1,T5,T4>` | `_23154()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 3rd, 1st, 5th, 4th.
    `NTuple3<T2,T3,T4>` | `_234()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 3rd, 4th.
    `NTuple5<T2,T3,T4,T1,T5>` | `_23415()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 3rd, 4th, 1st, 5th.
    `NTuple4<T2,T3,T4,T5>` | `_2345()` Create a new 4-tuple from this one where the elements are ordered: 2nd, 3rd, 4th, 5th.
    `NTuple5<T2,T3,T4,T5,T1>` | `_23451()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 3rd, 4th, 5th, 1st.
    `NTuple3<T2,T3,T5>` | `_235()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 3rd, 5th.
    `NTuple5<T2,T3,T5,T1,T4>` | `_23514()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 3rd, 5th, 1st, 4th.
    `NTuple5<T2,T3,T5,T4,T1>` | `_23541()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 3rd, 5th, 4th, 1st.
    `NTuple2<T2,T4>` | `_24()` Create a new 2-tuple from this one where the elements are ordered: 2nd, 4th.
    `NTuple3<T2,T4,T1>` | `_241()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 4th, 1st.
    `NTuple5<T2,T4,T1,T3,T5>` | `_24135()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 4th, 1st, 3rd, 5th.
    `NTuple5<T2,T4,T1,T5,T3>` | `_24153()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 4th, 1st, 5th, 3rd.
    `NTuple3<T2,T4,T3>` | `_243()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 4th, 3rd.
    `NTuple5<T2,T4,T3,T1,T5>` | `_24315()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 4th, 3rd, 1st, 5th.
    `NTuple5<T2,T4,T3,T5,T1>` | `_24351()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 4th, 3rd, 5th, 1st.
    `NTuple3<T2,T4,T5>` | `_245()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 4th, 5th.
    `NTuple5<T2,T4,T5,T1,T3>` | `_24513()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 4th, 5th, 1st, 3rd.
    `NTuple5<T2,T4,T5,T3,T1>` | `_24531()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 4th, 5th, 3rd, 1st.
    `NTuple2<T2,T5>` | `_25()` Create a new 2-tuple from this one where the elements are ordered: 2nd, 5th.
    `NTuple3<T2,T5,T1>` | `_251()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 5th, 1st.
    `NTuple5<T2,T5,T1,T3,T4>` | `_25134()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 5th, 1st, 3rd, 4th.
    `NTuple5<T2,T5,T1,T4,T3>` | `_25143()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 5th, 1st, 4th, 3rd.
    `NTuple3<T2,T5,T3>` | `_253()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 5th, 3rd.
    `NTuple5<T2,T5,T3,T1,T4>` | `_25314()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 5th, 3rd, 1st, 4th.
    `NTuple5<T2,T5,T3,T4,T1>` | `_25341()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 5th, 3rd, 4th, 1st.
    `NTuple3<T2,T5,T4>` | `_254()` Create a new 3-tuple from this one where the elements are ordered: 2nd, 5th, 4th.
    `NTuple5<T2,T5,T4,T1,T3>` | `_25413()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 5th, 4th, 1st, 3rd.
    `NTuple5<T2,T5,T4,T3,T1>` | `_25431()` Create a new 5-tuple from this one where the elements are ordered: 2nd, 5th, 4th, 3rd, 1st.
    `T3` | `_3()` Get the third element.
    `NTuple2<T3,T1>` | `_31()` Create a new 2-tuple from this one where the elements are ordered: 3rd, 1st.
    `NTuple3<T3,T1,T2>` | `_312()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 1st, 2nd.
    `NTuple5<T3,T1,T2,T4,T5>` | `_31245()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 1st, 2nd, 4th, 5th.
    `NTuple5<T3,T1,T2,T5,T4>` | `_31254()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 1st, 2nd, 5th, 4th.
    `NTuple3<T3,T1,T4>` | `_314()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 1st, 4th.
    `NTuple5<T3,T1,T4,T2,T5>` | `_31425()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 1st, 4th, 2nd, 5th.
    `NTuple5<T3,T1,T4,T5,T2>` | `_31452()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 1st, 4th, 5th, 2nd.
    `NTuple3<T3,T1,T5>` | `_315()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 1st, 5th.
    `NTuple5<T3,T1,T5,T2,T4>` | `_31524()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 1st, 5th, 2nd, 4th.
    `NTuple5<T3,T1,T5,T4,T2>` | `_31542()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 1st, 5th, 4th, 2nd.
    `NTuple2<T3,T2>` | `_32()` Create a new 2-tuple from this one where the elements are ordered: 3rd, 2nd.
    `NTuple3<T3,T2,T1>` | `_321()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 2nd, 1st.
    `NTuple5<T3,T2,T1,T4,T5>` | `_32145()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 2nd, 1st, 4th, 5th.
    `NTuple5<T3,T2,T1,T5,T4>` | `_32154()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 2nd, 1st, 5th, 4th.
    `NTuple3<T3,T2,T4>` | `_324()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 2nd, 4th.
    `NTuple5<T3,T2,T4,T1,T5>` | `_32415()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 2nd, 4th, 1st, 5th.
    `NTuple5<T3,T2,T4,T5,T1>` | `_32451()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 2nd, 4th, 5th, 1st.
    `NTuple3<T3,T2,T5>` | `_325()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 2nd, 5th.
    `NTuple5<T3,T2,T5,T1,T4>` | `_32514()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 2nd, 5th, 1st, 4th.
    `NTuple5<T3,T2,T5,T4,T1>` | `_32541()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 2nd, 5th, 4th, 1st.
    `NTuple2<T3,T4>` | `_34()` Create a new 2-tuple from this one where the elements are ordered: 3rd, 4th.
    `NTuple3<T3,T4,T1>` | `_341()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 4th, 1st.
    `NTuple5<T3,T4,T1,T2,T5>` | `_34125()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 4th, 1st, 2nd, 5th.
    `NTuple5<T3,T4,T1,T5,T2>` | `_34152()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 4th, 1st, 5th, 2nd.
    `NTuple3<T3,T4,T2>` | `_342()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 4th, 2nd.
    `NTuple5<T3,T4,T2,T1,T5>` | `_34215()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 4th, 2nd, 1st, 5th.
    `NTuple5<T3,T4,T2,T5,T1>` | `_34251()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 4th, 2nd, 5th, 1st.
    `NTuple3<T3,T4,T5>` | `_345()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 4th, 5th.
    `NTuple5<T3,T4,T5,T1,T2>` | `_34512()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 4th, 5th, 1st, 2nd.
    `NTuple5<T3,T4,T5,T2,T1>` | `_34521()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 4th, 5th, 2nd, 1st.
    `NTuple2<T3,T5>` | `_35()` Create a new 2-tuple from this one where the elements are ordered: 3rd, 5th.
    `NTuple3<T3,T5,T1>` | `_351()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 5th, 1st.
    `NTuple5<T3,T5,T1,T2,T4>` | `_35124()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 5th, 1st, 2nd, 4th.
    `NTuple5<T3,T5,T1,T4,T2>` | `_35142()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 5th, 1st, 4th, 2nd.
    `NTuple3<T3,T5,T2>` | `_352()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 5th, 2nd.
    `NTuple5<T3,T5,T2,T1,T4>` | `_35214()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 5th, 2nd, 1st, 4th.
    `NTuple5<T3,T5,T2,T4,T1>` | `_35241()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 5th, 2nd, 4th, 1st.
    `NTuple3<T3,T5,T4>` | `_354()` Create a new 3-tuple from this one where the elements are ordered: 3rd, 5th, 4th.
    `NTuple5<T3,T5,T4,T1,T2>` | `_35412()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 5th, 4th, 1st, 2nd.
    `NTuple5<T3,T5,T4,T2,T1>` | `_35421()` Create a new 5-tuple from this one where the elements are ordered: 3rd, 5th, 4th, 2nd, 1st.
    `T4` | `_4()` Get the fourth element.
    `NTuple2<T4,T1>` | `_41()` Create a new 2-tuple from this one where the elements are ordered: 4th, 1st.
    `NTuple3<T4,T1,T2>` | `_412()` Create a new 3-tuple from this one where the elements are ordered: 4th, 1st, 2nd.
    `NTuple5<T4,T1,T2,T3,T5>` | `_41235()` Create a new 5-tuple from this one where the elements are ordered: 4th, 1st, 2nd, 3rd, 5th.
    `NTuple5<T4,T1,T2,T5,T3>` | `_41253()` Create a new 5-tuple from this one where the elements are ordered: 4th, 1st, 2nd, 5th, 3rd.
    `NTuple3<T4,T1,T3>` | `_413()` Create a new 3-tuple from this one where the elements are ordered: 4th, 1st, 3rd.
    `NTuple5<T4,T1,T3,T2,T5>` | `_41325()` Create a new 5-tuple from this one where the elements are ordered: 4th, 1st, 3rd, 2nd, 5th.
    `NTuple5<T4,T1,T3,T5,T2>` | `_41352()` Create a new 5-tuple from this one where the elements are ordered: 4th, 1st, 3rd, 5th, 2nd.
    `NTuple3<T4,T1,T5>` | `_415()` Create a new 3-tuple from this one where the elements are ordered: 4th, 1st, 5th.
    `NTuple5<T4,T1,T5,T2,T3>` | `_41523()` Create a new 5-tuple from this one where the elements are ordered: 4th, 1st, 5th, 2nd, 3rd.
    `NTuple5<T4,T1,T5,T3,T2>` | `_41532()` Create a new 5-tuple from this one where the elements are ordered: 4th, 1st, 5th, 3rd, 2nd.
    `NTuple2<T4,T2>` | `_42()` Create a new 2-tuple from this one where the elements are ordered: 4th, 2nd.
    `NTuple3<T4,T2,T1>` | `_421()` Create a new 3-tuple from this one where the elements are ordered: 4th, 2nd, 1st.
    `NTuple5<T4,T2,T1,T3,T5>` | `_42135()` Create a new 5-tuple from this one where the elements are ordered: 4th, 2nd, 1st, 3rd, 5th.
    `NTuple5<T4,T2,T1,T5,T3>` | `_42153()` Create a new 5-tuple from this one where the elements are ordered: 4th, 2nd, 1st, 5th, 3rd.
    `NTuple3<T4,T2,T3>` | `_423()` Create a new 3-tuple from this one where the elements are ordered: 4th, 2nd, 3rd.
    `NTuple5<T4,T2,T3,T1,T5>` | `_42315()` Create a new 5-tuple from this one where the elements are ordered: 4th, 2nd, 3rd, 1st, 5th.
    `NTuple5<T4,T2,T3,T5,T1>` | `_42351()` Create a new 5-tuple from this one where the elements are ordered: 4th, 2nd, 3rd, 5th, 1st.
    `NTuple3<T4,T2,T5>` | `_425()` Create a new 3-tuple from this one where the elements are ordered: 4th, 2nd, 5th.
    `NTuple5<T4,T2,T5,T1,T3>` | `_42513()` Create a new 5-tuple from this one where the elements are ordered: 4th, 2nd, 5th, 1st, 3rd.
    `NTuple5<T4,T2,T5,T3,T1>` | `_42531()` Create a new 5-tuple from this one where the elements are ordered: 4th, 2nd, 5th, 3rd, 1st.
    `NTuple2<T4,T3>` | `_43()` Create a new 2-tuple from this one where the elements are ordered: 4th, 3rd.
    `NTuple3<T4,T3,T1>` | `_431()` Create a new 3-tuple from this one where the elements are ordered: 4th, 3rd, 1st.
    `NTuple5<T4,T3,T1,T2,T5>` | `_43125()` Create a new 5-tuple from this one where the elements are ordered: 4th, 3rd, 1st, 2nd, 5th.
    `NTuple5<T4,T3,T1,T5,T2>` | `_43152()` Create a new 5-tuple from this one where the elements are ordered: 4th, 3rd, 1st, 5th, 2nd.
    `NTuple3<T4,T3,T2>` | `_432()` Create a new 3-tuple from this one where the elements are ordered: 4th, 3rd, 2nd.
    `NTuple5<T4,T3,T2,T1,T5>` | `_43215()` Create a new 5-tuple from this one where the elements are ordered: 4th, 3rd, 2nd, 1st, 5th.
    `NTuple5<T4,T3,T2,T5,T1>` | `_43251()` Create a new 5-tuple from this one where the elements are ordered: 4th, 3rd, 2nd, 5th, 1st.
    `NTuple3<T4,T3,T5>` | `_435()` Create a new 3-tuple from this one where the elements are ordered: 4th, 3rd, 5th.
    `NTuple5<T4,T3,T5,T1,T2>` | `_43512()` Create a new 5-tuple from this one where the elements are ordered: 4th, 3rd, 5th, 1st, 2nd.
    `NTuple5<T4,T3,T5,T2,T1>` | `_43521()` Create a new 5-tuple from this one where the elements are ordered: 4th, 3rd, 5th, 2nd, 1st.
    `NTuple2<T4,T5>` | `_45()` Create a new 2-tuple from this one where the elements are ordered: 4th, 5th.
    `NTuple3<T4,T5,T1>` | `_451()` Create a new 3-tuple from this one where the elements are ordered: 4th, 5th, 1st.
    `NTuple5<T4,T5,T1,T2,T3>` | `_45123()` Create a new 5-tuple from this one where the elements are ordered: 4th, 5th, 1st, 2nd, 3rd.
    `NTuple5<T4,T5,T1,T3,T2>` | `_45132()` Create a new 5-tuple from this one where the elements are ordered: 4th, 5th, 1st, 3rd, 2nd.
    `NTuple3<T4,T5,T2>` | `_452()` Create a new 3-tuple from this one where the elements are ordered: 4th, 5th, 2nd.
    `NTuple5<T4,T5,T2,T1,T3>` | `_45213()` Create a new 5-tuple from this one where the elements are ordered: 4th, 5th, 2nd, 1st, 3rd.
    `NTuple5<T4,T5,T2,T3,T1>` | `_45231()` Create a new 5-tuple from this one where the elements are ordered: 4th, 5th, 2nd, 3rd, 1st.
    `NTuple3<T4,T5,T3>` | `_453()` Create a new 3-tuple from this one where the elements are ordered: 4th, 5th, 3rd.
    `NTuple5<T4,T5,T3,T1,T2>` | `_45312()` Create a new 5-tuple from this one where the elements are ordered: 4th, 5th, 3rd, 1st, 2nd.
    `NTuple5<T4,T5,T3,T2,T1>` | `_45321()` Create a new 5-tuple from this one where the elements are ordered: 4th, 5th, 3rd, 2nd, 1st.
    `T5` | `_5()` Get the fifth element.
    `NTuple2<T5,T1>` | `_51()` Create a new 2-tuple from this one where the elements are ordered: 5th, 1st.
    `NTuple3<T5,T1,T2>` | `_512()` Create a new 3-tuple from this one where the elements are ordered: 5th, 1st, 2nd.
    `NTuple5<T5,T1,T2,T3,T4>` | `_51234()` Create a new 5-tuple from this one where the elements are ordered: 5th, 1st, 2nd, 3rd, 4th.
    `NTuple5<T5,T1,T2,T4,T3>` | `_51243()` Create a new 5-tuple from this one where the elements are ordered: 5th, 1st, 2nd, 4th, 3rd.
    `NTuple3<T5,T1,T3>` | `_513()` Create a new 3-tuple from this one where the elements are ordered: 5th, 1st, 3rd.
    `NTuple5<T5,T1,T3,T2,T4>` | `_51324()` Create a new 5-tuple from this one where the elements are ordered: 5th, 1st, 3rd, 2nd, 4th.
    `NTuple5<T5,T1,T3,T4,T2>` | `_51342()` Create a new 5-tuple from this one where the elements are ordered: 5th, 1st, 3rd, 4th, 2nd.
    `NTuple3<T5,T1,T4>` | `_514()` Create a new 3-tuple from this one where the elements are ordered: 5th, 1st, 4th.
    `NTuple5<T5,T1,T4,T2,T3>` | `_51423()` Create a new 5-tuple from this one where the elements are ordered: 5th, 1st, 4th, 2nd, 3rd.
    `NTuple5<T5,T1,T4,T3,T2>` | `_51432()` Create a new 5-tuple from this one where the elements are ordered: 5th, 1st, 4th, 3rd, 2nd.
    `NTuple2<T5,T2>` | `_52()` Create a new 2-tuple from this one where the elements are ordered: 5th, 2nd.
    `NTuple3<T5,T2,T1>` | `_521()` Create a new 3-tuple from this one where the elements are ordered: 5th, 2nd, 1st.
    `NTuple5<T5,T2,T1,T3,T4>` | `_52134()` Create a new 5-tuple from this one where the elements are ordered: 5th, 2nd, 1st, 3rd, 4th.
    `NTuple5<T5,T2,T1,T4,T3>` | `_52143()` Create a new 5-tuple from this one where the elements are ordered: 5th, 2nd, 1st, 4th, 3rd.
    `NTuple3<T5,T2,T3>` | `_523()` Create a new 3-tuple from this one where the elements are ordered: 5th, 2nd, 3rd.
    `NTuple5<T5,T2,T3,T1,T4>` | `_52314()` Create a new 5-tuple from this one where the elements are ordered: 5th, 2nd, 3rd, 1st, 4th.
    `NTuple5<T5,T2,T3,T4,T1>` | `_52341()` Create a new 5-tuple from this one where the elements are ordered: 5th, 2nd, 3rd, 4th, 1st.
    `NTuple3<T5,T2,T4>` | `_524()` Create a new 3-tuple from this one where the elements are ordered: 5th, 2nd, 4th.
    `NTuple5<T5,T2,T4,T1,T3>` | `_52413()` Create a new 5-tuple from this one where the elements are ordered: 5th, 2nd, 4th, 1st, 3rd.
    `NTuple5<T5,T2,T4,T3,T1>` | `_52431()` Create a new 5-tuple from this one where the elements are ordered: 5th, 2nd, 4th, 3rd, 1st.
    `NTuple2<T5,T3>` | `_53()` Create a new 2-tuple from this one where the elements are ordered: 5th, 3rd.
    `NTuple3<T5,T3,T1>` | `_531()` Create a new 3-tuple from this one where the elements are ordered: 5th, 3rd, 1st.
    `NTuple5<T5,T3,T1,T2,T4>` | `_53124()` Create a new 5-tuple from this one where the elements are ordered: 5th, 3rd, 1st, 2nd, 4th.
    `NTuple5<T5,T3,T1,T4,T2>` | `_53142()` Create a new 5-tuple from this one where the elements are ordered: 5th, 3rd, 1st, 4th, 2nd.
    `NTuple3<T5,T3,T2>` | `_532()` Create a new 3-tuple from this one where the elements are ordered: 5th, 3rd, 2nd.
    `NTuple5<T5,T3,T2,T1,T4>` | `_53214()` Create a new 5-tuple from this one where the elements are ordered: 5th, 3rd, 2nd, 1st, 4th.
    `NTuple5<T5,T3,T2,T4,T1>` | `_53241()` Create a new 5-tuple from this one where the elements are ordered: 5th, 3rd, 2nd, 4th, 1st.
    `NTuple3<T5,T3,T4>` | `_534()` Create a new 3-tuple from this one where the elements are ordered: 5th, 3rd, 4th.
    `NTuple5<T5,T3,T4,T1,T2>` | `_53412()` Create a new 5-tuple from this one where the elements are ordered: 5th, 3rd, 4th, 1st, 2nd.
    `NTuple5<T5,T3,T4,T2,T1>` | `_53421()` Create a new 5-tuple from this one where the elements are ordered: 5th, 3rd, 4th, 2nd, 1st.
    `NTuple2<T5,T4>` | `_54()` Create a new 2-tuple from this one where the elements are ordered: 5th, 4th.
    `NTuple3<T5,T4,T1>` | `_541()` Create a new 3-tuple from this one where the elements are ordered: 5th, 4th, 1st.
    `NTuple5<T5,T4,T1,T2,T3>` | `_54123()` Create a new 5-tuple from this one where the elements are ordered: 5th, 4th, 1st, 2nd, 3rd.
    `NTuple5<T5,T4,T1,T3,T2>` | `_54132()` Create a new 5-tuple from this one where the elements are ordered: 5th, 4th, 1st, 3rd, 2nd.
    `NTuple3<T5,T4,T2>` | `_542()` Create a new 3-tuple from this one where the elements are ordered: 5th, 4th, 2nd.
    `NTuple5<T5,T4,T2,T1,T3>` | `_54213()` Create a new 5-tuple from this one where the elements are ordered: 5th, 4th, 2nd, 1st, 3rd.
    `NTuple5<T5,T4,T2,T3,T1>` | `_54231()` Create a new 5-tuple from this one where the elements are ordered: 5th, 4th, 2nd, 3rd, 1st.
    `NTuple3<T5,T4,T3>` | `_543()` Create a new 3-tuple from this one where the elements are ordered: 5th, 4th, 3rd.
    `NTuple5<T5,T4,T3,T1,T2>` | `_54312()` Create a new 5-tuple from this one where the elements are ordered: 5th, 4th, 3rd, 1st, 2nd.
    `NTuple5<T5,T4,T3,T2,T1>` | `_54321()` Create a new 5-tuple from this one where the elements are ordered: 5th, 4th, 3rd, 2nd, 1st.
    `NTuple5<T1,T2,T3,T4,T5>` | `frozen()` Convert this into an object of a concrete tuple implementation.
    `<T> NTuple6<T,T1,T2,T3,T4,T5>` | `i1(T e1)` Create a 6-tuple from this 5-tuple by inserting a new first element.
    `<T> NTuple6<T1,T,T2,T3,T4,T5>` | `i2(T e2)` Create a 6-tuple from this 5-tuple by inserting a new second element.
    `<T> NTuple6<T1,T2,T,T3,T4,T5>` | `i3(T e3)` Create a 6-tuple from this 5-tuple by inserting a new third element.
    `<T> NTuple6<T1,T2,T3,T,T4,T5>` | `i4(T e4)` Create a 6-tuple from this 5-tuple by inserting a new fourth element.
    `<T> NTuple6<T1,T2,T3,T4,T,T5>` | `i5(T e5)` Create a 6-tuple from this 5-tuple by inserting a new fifth element.
    `<T> NTuple6<T1,T2,T3,T4,T5,T>` | `i6(T e6)` Create a 6-tuple from this 5-tuple by adding a new sixth element.
    `java.lang.String` | `toString()`
    `<E1> NTuple5<E1,T2,T3,T4,T5>` | `x1(E1 e1)` Create a 5-tuple from this one where the first element is exchanged.
    `<E1,E2> NTuple5<E1,E2,T3,T4,T5>` | `x12(E1 e1, E2 e2)` Create a 5-tuple from this one where the first and second elements are exchanged.
    `<E1,E2,E3> NTuple5<E1,E2,E3,T4,T5>` | `x123(E1 e1, E2 e2, E3 e3)` Create a 5-tuple from this one where the first, second, and thirdelements are exchanged.
    `<E1,E2,E3,E4> NTuple5<E1,E2,E3,E4,T5>` | `x1234(E1 e1, E2 e2, E3 e3, E4 e4)` Create a 5-tuple from this one where the first, second, third, and fourthelements are exchanged.
    `<E1,E2,E3,E5> NTuple5<E1,E2,E3,T4,E5>` | `x1235(E1 e1, E2 e2, E3 e3, E5 e5)` Create a 5-tuple from this one where the first, second, third, and fifthelements are exchanged.
    `<E1,E2,E4> NTuple5<E1,E2,T3,E4,T5>` | `x124(E1 e1, E2 e2, E4 e4)` Create a 5-tuple from this one where the first, second, and fourthelements are exchanged.
    `<E1,E2,E4,E5> NTuple5<E1,E2,T3,E4,E5>` | `x1245(E1 e1, E2 e2, E4 e4, E5 e5)` Create a 5-tuple from this one where the first, second, fourth, and fifthelements are exchanged.
    `<E1,E2,E5> NTuple5<E1,E2,T3,T4,E5>` | `x125(E1 e1, E2 e2, E5 e5)` Create a 5-tuple from this one where the first, second, and fifthelements are exchanged.
    `<E1,E3> NTuple5<E1,T2,E3,T4,T5>` | `x13(E1 e1, E3 e3)` Create a 5-tuple from this one where the first and third elements are exchanged.
    `<E1,E3,E4> NTuple5<E1,T2,E3,E4,T5>` | `x134(E1 e1, E3 e3, E4 e4)` Create a 5-tuple from this one where the first, third, and fourthelements are exchanged.
    `<E1,E3,E4,E5> NTuple5<E1,T2,E3,E4,E5>` | `x1345(E1 e1, E3 e3, E4 e4, E5 e5)` Create a 5-tuple from this one where the first, third, fourth, and fifthelements are exchanged.
    `<E1,E3,E5> NTuple5<E1,T2,E3,T4,E5>` | `x135(E1 e1, E3 e3, E5 e5)` Create a 5-tuple from this one where the first, third, and fifthelements are exchanged.
    `<E1,E4> NTuple5<E1,T2,T3,E4,T5>` | `x14(E1 e1, E4 e4)` Create a 5-tuple from this one where the first and fourth elements are exchanged.
    `<E1,E4,E5> NTuple5<E1,T2,T3,E4,E5>` | `x145(E1 e1, E4 e4, E5 e5)` Create a 5-tuple from this one where the first, fourth, and fifthelements are exchanged.
    `<E1,E5> NTuple5<E1,T2,T3,T4,E5>` | `x15(E1 e1, E5 e5)` Create a 5-tuple from this one where the first and fifth elements are exchanged.
    `<E2> NTuple5<T1,E2,T3,T4,T5>` | `x2(E2 e2)` Create a 5-tuple from this one where the second element is exchanged.
    `<E2,E3> NTuple5<T1,E2,E3,T4,T5>` | `x23(E2 e2, E3 e3)` Create a 5-tuple from this one where the second and third elements are exchanged.
    `<E2,E3,E4> NTuple5<T1,E2,E3,E4,T5>` | `x234(E2 e2, E3 e3, E4 e4)` Create a 5-tuple from this one where the second, third, and fourthelements are exchanged.
    `<E2,E3,E4,E5> NTuple5<T1,E2,E3,E4,E5>` | `x2345(E2 e2, E3 e3, E4 e4, E5 e5)` Create a 5-tuple from this one where the second, third, fourth, and fifthelements are exchanged.
    `<E2,E3,E5> NTuple5<T1,E2,E3,T4,E5>` | `x235(E2 e2, E3 e3, E5 e5)` Create a 5-tuple from this one where the second, third, and fifthelements are exchanged.
    `<E2,E4> NTuple5<T1,E2,T3,E4,T5>` | `x24(E2 e2, E4 e4)` Create a 5-tuple from this one where the second and fourth elements are exchanged.
    `<E2,E4,E5> NTuple5<T1,E2,T3,E4,E5>` | `x245(E2 e2, E4 e4, E5 e5)` Create a 5-tuple from this one where the second, fourth, and fifthelements are exchanged.
    `<E2,E5> NTuple5<T1,E2,T3,T4,E5>` | `x25(E2 e2, E5 e5)` Create a 5-tuple from this one where the second and fifth elements are exchanged.
    `<E3> NTuple5<T1,T2,E3,T4,T5>` | `x3(E3 e3)` Create a 5-tuple from this one where the third element is exchanged.
    `<E3,E4> NTuple5<T1,T2,E3,E4,T5>` | `x34(E3 e3, E4 e4)` Create a 5-tuple from this one where the third and fourth elements are exchanged.
    `<E3,E4,E5> NTuple5<T1,T2,E3,E4,E5>` | `x345(E3 e3, E4 e4, E5 e5)` Create a 5-tuple from this one where the third, fourth, and fifthelements are exchanged.
    `<E3,E5> NTuple5<T1,T2,E3,T4,E5>` | `x35(E3 e3, E5 e5)` Create a 5-tuple from this one where the third and fifth elements are exchanged.
    `<E4> NTuple5<T1,T2,T3,E4,T5>` | `x4(E4 e4)` Create a 5-tuple from this one where the fourth element is exchanged.
    `<E4,E5> NTuple5<T1,T2,T3,E4,E5>` | `x45(E4 e4, E5 e5)` Create a 5-tuple from this one where the fourth and fifth elements are exchanged.
    `<E5> NTuple5<T1,T2,T3,T4,E5>` | `x5(E5 e5)` Create a 5-tuple from this one where the fifth element is exchanged.

    - ### Methods inherited from class de.caff.generics.tuple.ITuple5.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.ITuple5

      `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, frozenNotNull, hash, invoke, sendTo, testBy, toString, toString, view`

- - ### Constructor Detail

    - #### NTuple5

          public NTuple5(@Nullable
                         T1 e1,
                         @Nullable
                         T2 e2,
                         @Nullable
                         T3 e3,
                         @Nullable
                         T4 e4,
                         @Nullable
                         T5 e5)

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

  - ### Method Detail

    - #### _1

          @Nullable
          public T1 _1()

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

    - #### _2

          @Nullable
          public T2 _2()

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

    - #### _3

          @Nullable
          public T3 _3()

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

    - #### _4

          @Nullable
          public T4 _4()

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

    - #### _5

          @Nullable
          public T5 _5()

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

    - #### _12354

          @NotNull
          public NTuple5<T1,T2,T3,T5,T4> _12354()

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

    - #### _12534

          @NotNull
          public NTuple5<T1,T2,T5,T3,T4> _12534()

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

    - #### _15234

          @NotNull
          public NTuple5<T1,T5,T2,T3,T4> _15234()

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

    - #### _51234

          @NotNull
          public NTuple5<T5,T1,T2,T3,T4> _51234()

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

    - #### _51243

          @NotNull
          public NTuple5<T5,T1,T2,T4,T3> _51243()

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

    - #### _15243

          @NotNull
          public NTuple5<T1,T5,T2,T4,T3> _15243()

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

    - #### _12543

          @NotNull
          public NTuple5<T1,T2,T5,T4,T3> _12543()

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

    - #### _12453

          @NotNull
          public NTuple5<T1,T2,T4,T5,T3> _12453()

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

    - #### _12435

          @NotNull
          public NTuple5<T1,T2,T4,T3,T5> _12435()

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

    - #### _14235

          @NotNull
          public NTuple5<T1,T4,T2,T3,T5> _14235()

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

    - #### _14253

          @NotNull
          public NTuple5<T1,T4,T2,T5,T3> _14253()

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

    - #### _14523

          @NotNull
          public NTuple5<T1,T4,T5,T2,T3> _14523()

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

    - #### _15423

          @NotNull
          public NTuple5<T1,T5,T4,T2,T3> _15423()

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

    - #### _51423

          @NotNull
          public NTuple5<T5,T1,T4,T2,T3> _51423()

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

    - #### _54123

          @NotNull
          public NTuple5<T5,T4,T1,T2,T3> _54123()

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

    - #### _45123

          @NotNull
          public NTuple5<T4,T5,T1,T2,T3> _45123()

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

    - #### _41523

          @NotNull
          public NTuple5<T4,T1,T5,T2,T3> _41523()

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

    - #### _41253

          @NotNull
          public NTuple5<T4,T1,T2,T5,T3> _41253()

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

    - #### _41235

          @NotNull
          public NTuple5<T4,T1,T2,T3,T5> _41235()

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

    - #### _41325

          @NotNull
          public NTuple5<T4,T1,T3,T2,T5> _41325()

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

    - #### _41352

          @NotNull
          public NTuple5<T4,T1,T3,T5,T2> _41352()

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

    - #### _41532

          @NotNull
          public NTuple5<T4,T1,T5,T3,T2> _41532()

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

    - #### _45132

          @NotNull
          public NTuple5<T4,T5,T1,T3,T2> _45132()

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

    - #### _54132

          @NotNull
          public NTuple5<T5,T4,T1,T3,T2> _54132()

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

    - #### _51432

          @NotNull
          public NTuple5<T5,T1,T4,T3,T2> _51432()

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

    - #### _15432

          @NotNull
          public NTuple5<T1,T5,T4,T3,T2> _15432()

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

    - #### _14532

          @NotNull
          public NTuple5<T1,T4,T5,T3,T2> _14532()

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

    - #### _14352

          @NotNull
          public NTuple5<T1,T4,T3,T5,T2> _14352()

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

    - #### _14325

          @NotNull
          public NTuple5<T1,T4,T3,T2,T5> _14325()

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

    - #### _13425

          @NotNull
          public NTuple5<T1,T3,T4,T2,T5> _13425()

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

    - #### _13452

          @NotNull
          public NTuple5<T1,T3,T4,T5,T2> _13452()

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

    - #### _13542

          @NotNull
          public NTuple5<T1,T3,T5,T4,T2> _13542()

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

    - #### _15342

          @NotNull
          public NTuple5<T1,T5,T3,T4,T2> _15342()

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

    - #### _51342

          @NotNull
          public NTuple5<T5,T1,T3,T4,T2> _51342()

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

    - #### _51324

          @NotNull
          public NTuple5<T5,T1,T3,T2,T4> _51324()

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

    - #### _15324

          @NotNull
          public NTuple5<T1,T5,T3,T2,T4> _15324()

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

    - #### _13524

          @NotNull
          public NTuple5<T1,T3,T5,T2,T4> _13524()

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

    - #### _13254

          @NotNull
          public NTuple5<T1,T3,T2,T5,T4> _13254()

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

    - #### _13245

          @NotNull
          public NTuple5<T1,T3,T2,T4,T5> _13245()

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

    - #### _31245

          @NotNull
          public NTuple5<T3,T1,T2,T4,T5> _31245()

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

    - #### _31254

          @NotNull
          public NTuple5<T3,T1,T2,T5,T4> _31254()

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

    - #### _31524

          @NotNull
          public NTuple5<T3,T1,T5,T2,T4> _31524()

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

    - #### _35124

          @NotNull
          public NTuple5<T3,T5,T1,T2,T4> _35124()

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

    - #### _53124

          @NotNull
          public NTuple5<T5,T3,T1,T2,T4> _53124()

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

    - #### _53142

          @NotNull
          public NTuple5<T5,T3,T1,T4,T2> _53142()

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

    - #### _35142

          @NotNull
          public NTuple5<T3,T5,T1,T4,T2> _35142()

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

    - #### _31542

          @NotNull
          public NTuple5<T3,T1,T5,T4,T2> _31542()

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

    - #### _31452

          @NotNull
          public NTuple5<T3,T1,T4,T5,T2> _31452()

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

    - #### _31425

          @NotNull
          public NTuple5<T3,T1,T4,T2,T5> _31425()

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

    - #### _34125

          @NotNull
          public NTuple5<T3,T4,T1,T2,T5> _34125()

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

    - #### _34152

          @NotNull
          public NTuple5<T3,T4,T1,T5,T2> _34152()

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

    - #### _34512

          @NotNull
          public NTuple5<T3,T4,T5,T1,T2> _34512()

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

    - #### _35412

          @NotNull
          public NTuple5<T3,T5,T4,T1,T2> _35412()

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

    - #### _53412

          @NotNull
          public NTuple5<T5,T3,T4,T1,T2> _53412()

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

    - #### _54312

          @NotNull
          public NTuple5<T5,T4,T3,T1,T2> _54312()

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

    - #### _45312

          @NotNull
          public NTuple5<T4,T5,T3,T1,T2> _45312()

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

    - #### _43512

          @NotNull
          public NTuple5<T4,T3,T5,T1,T2> _43512()

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

    - #### _43152

          @NotNull
          public NTuple5<T4,T3,T1,T5,T2> _43152()

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

    - #### _43125

          @NotNull
          public NTuple5<T4,T3,T1,T2,T5> _43125()

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

    - #### _43215

          @NotNull
          public NTuple5<T4,T3,T2,T1,T5> _43215()

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

    - #### _43251

          @NotNull
          public NTuple5<T4,T3,T2,T5,T1> _43251()

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

    - #### _43521

          @NotNull
          public NTuple5<T4,T3,T5,T2,T1> _43521()

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

    - #### _45321

          @NotNull
          public NTuple5<T4,T5,T3,T2,T1> _45321()

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

    - #### _54321

          @NotNull
          public NTuple5<T5,T4,T3,T2,T1> _54321()

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

    - #### _53421

          @NotNull
          public NTuple5<T5,T3,T4,T2,T1> _53421()

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

    - #### _35421

          @NotNull
          public NTuple5<T3,T5,T4,T2,T1> _35421()

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

    - #### _34521

          @NotNull
          public NTuple5<T3,T4,T5,T2,T1> _34521()

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

    - #### _34251

          @NotNull
          public NTuple5<T3,T4,T2,T5,T1> _34251()

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

    - #### _34215

          @NotNull
          public NTuple5<T3,T4,T2,T1,T5> _34215()

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

    - #### _32415

          @NotNull
          public NTuple5<T3,T2,T4,T1,T5> _32415()

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

    - #### _32451

          @NotNull
          public NTuple5<T3,T2,T4,T5,T1> _32451()

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

    - #### _32541

          @NotNull
          public NTuple5<T3,T2,T5,T4,T1> _32541()

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

    - #### _35241

          @NotNull
          public NTuple5<T3,T5,T2,T4,T1> _35241()

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

    - #### _53241

          @NotNull
          public NTuple5<T5,T3,T2,T4,T1> _53241()

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

    - #### _53214

          @NotNull
          public NTuple5<T5,T3,T2,T1,T4> _53214()

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

    - #### _35214

          @NotNull
          public NTuple5<T3,T5,T2,T1,T4> _35214()

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

    - #### _32514

          @NotNull
          public NTuple5<T3,T2,T5,T1,T4> _32514()

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

    - #### _32154

          @NotNull
          public NTuple5<T3,T2,T1,T5,T4> _32154()

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

    - #### _32145

          @NotNull
          public NTuple5<T3,T2,T1,T4,T5> _32145()

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

    - #### _23145

          @NotNull
          public NTuple5<T2,T3,T1,T4,T5> _23145()

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

    - #### _23154

          @NotNull
          public NTuple5<T2,T3,T1,T5,T4> _23154()

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

    - #### _23514

          @NotNull
          public NTuple5<T2,T3,T5,T1,T4> _23514()

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

    - #### _25314

          @NotNull
          public NTuple5<T2,T5,T3,T1,T4> _25314()

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

    - #### _52314

          @NotNull
          public NTuple5<T5,T2,T3,T1,T4> _52314()

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

    - #### _52341

          @NotNull
          public NTuple5<T5,T2,T3,T4,T1> _52341()

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

    - #### _25341

          @NotNull
          public NTuple5<T2,T5,T3,T4,T1> _25341()

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

    - #### _23541

          @NotNull
          public NTuple5<T2,T3,T5,T4,T1> _23541()

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

    - #### _23451

          @NotNull
          public NTuple5<T2,T3,T4,T5,T1> _23451()

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

    - #### _23415

          @NotNull
          public NTuple5<T2,T3,T4,T1,T5> _23415()

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

    - #### _24315

          @NotNull
          public NTuple5<T2,T4,T3,T1,T5> _24315()

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

    - #### _24351

          @NotNull
          public NTuple5<T2,T4,T3,T5,T1> _24351()

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

    - #### _24531

          @NotNull
          public NTuple5<T2,T4,T5,T3,T1> _24531()

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

    - #### _25431

          @NotNull
          public NTuple5<T2,T5,T4,T3,T1> _25431()

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

    - #### _52431

          @NotNull
          public NTuple5<T5,T2,T4,T3,T1> _52431()

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

    - #### _54231

          @NotNull
          public NTuple5<T5,T4,T2,T3,T1> _54231()

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

    - #### _45231

          @NotNull
          public NTuple5<T4,T5,T2,T3,T1> _45231()

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

    - #### _42531

          @NotNull
          public NTuple5<T4,T2,T5,T3,T1> _42531()

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

    - #### _42351

          @NotNull
          public NTuple5<T4,T2,T3,T5,T1> _42351()

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

    - #### _42315

          @NotNull
          public NTuple5<T4,T2,T3,T1,T5> _42315()

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

    - #### _42135

          @NotNull
          public NTuple5<T4,T2,T1,T3,T5> _42135()

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

    - #### _42153

          @NotNull
          public NTuple5<T4,T2,T1,T5,T3> _42153()

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

    - #### _42513

          @NotNull
          public NTuple5<T4,T2,T5,T1,T3> _42513()

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

    - #### _45213

          @NotNull
          public NTuple5<T4,T5,T2,T1,T3> _45213()

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

    - #### _54213

          @NotNull
          public NTuple5<T5,T4,T2,T1,T3> _54213()

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

    - #### _52413

          @NotNull
          public NTuple5<T5,T2,T4,T1,T3> _52413()

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

    - #### _25413

          @NotNull
          public NTuple5<T2,T5,T4,T1,T3> _25413()

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

    - #### _24513

          @NotNull
          public NTuple5<T2,T4,T5,T1,T3> _24513()

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

    - #### _24153

          @NotNull
          public NTuple5<T2,T4,T1,T5,T3> _24153()

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

    - #### _24135

          @NotNull
          public NTuple5<T2,T4,T1,T3,T5> _24135()

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

    - #### _21435

          @NotNull
          public NTuple5<T2,T1,T4,T3,T5> _21435()

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

    - #### _21453

          @NotNull
          public NTuple5<T2,T1,T4,T5,T3> _21453()

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

    - #### _21543

          @NotNull
          public NTuple5<T2,T1,T5,T4,T3> _21543()

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

    - #### _25143

          @NotNull
          public NTuple5<T2,T5,T1,T4,T3> _25143()

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

    - #### _52143

          @NotNull
          public NTuple5<T5,T2,T1,T4,T3> _52143()

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

    - #### _52134

          @NotNull
          public NTuple5<T5,T2,T1,T3,T4> _52134()

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

    - #### _25134

          @NotNull
          public NTuple5<T2,T5,T1,T3,T4> _25134()

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

    - #### _21534

          @NotNull
          public NTuple5<T2,T1,T5,T3,T4> _21534()

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

    - #### _21354

          @NotNull
          public NTuple5<T2,T1,T3,T5,T4> _21354()

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

    - #### _21345

          @NotNull
          public NTuple5<T2,T1,T3,T4,T5> _21345()

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

    - #### _1234

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

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

    - #### _1235

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

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

    - #### _1245

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

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

    - #### _1345

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

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

    - #### _2345

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

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

    - #### _123

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

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

    - #### _132

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

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

    - #### _312

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

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

    - #### _321

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

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

    - #### _231

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

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

    - #### _213

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

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

    - #### _124

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

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

    - #### _142

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

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

    - #### _412

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

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

    - #### _421

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

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

    - #### _241

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

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

    - #### _214

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

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

    - #### _134

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

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

    - #### _143

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

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

    - #### _413

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

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

    - #### _431

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

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

    - #### _341

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

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

    - #### _314

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

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

    - #### _234

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

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

    - #### _243

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

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

    - #### _423

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

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

    - #### _432

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

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

    - #### _342

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

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

    - #### _324

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

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

    - #### _125

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

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

    - #### _152

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

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

    - #### _512

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

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

    - #### _521

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

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

    - #### _251

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

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

    - #### _215

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

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

    - #### _135

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

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

    - #### _153

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

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

    - #### _513

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

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

    - #### _531

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

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

    - #### _351

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

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

    - #### _315

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

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

    - #### _235

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

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

    - #### _253

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

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

    - #### _523

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

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

    - #### _532

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

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

    - #### _352

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

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

    - #### _325

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

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

    - #### _145

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

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

    - #### _154

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

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

    - #### _514

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

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

    - #### _541

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

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

    - #### _451

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

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

    - #### _415

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

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

    - #### _245

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

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

    - #### _254

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

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

    - #### _524

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

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

    - #### _542

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

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

    - #### _452

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

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

    - #### _425

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

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

    - #### _345

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

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

    - #### _354

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

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

    - #### _534

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

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

    - #### _543

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

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

    - #### _453

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

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

    - #### _435

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

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

    - #### _12

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

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

    - #### _21

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

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

    - #### _13

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

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

    - #### _31

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

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

    - #### _23

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

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

    - #### _32

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

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

    - #### _14

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

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

    - #### _41

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

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

    - #### _24

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

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

    - #### _42

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

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

    - #### _34

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

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

    - #### _43

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

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

    - #### _15

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

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

    - #### _51

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

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

    - #### _25

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

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

    - #### _52

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

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

    - #### _35

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

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

    - #### _53

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

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

    - #### _45

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

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

    - #### _54

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

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

    - #### frozen

          @NotNull
          public NTuple5<T1,T2,T3,T4,T5> frozen()

      Description copied from interface: `ITuple5`
      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 may contain `null` elements, see `ITuple5.frozenNotNull()` for a method which returns tuples which don't have nullable elements.
      Specified by:
        `frozen` in interface `ITuple5<T1,T2,T3,T4,T5>`
      Returns:
        standalone tuple object

    - #### x1

          @NotNull
          public <E1> NTuple5<E1,T2,T3,T4,T5> x1(@Nullable
                                                          E1 e1)

      Create a 5-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> NTuple5<T1,E2,T3,T4,T5> x2(@Nullable
                                                          E2 e2)

      Create a 5-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> NTuple5<T1,T2,E3,T4,T5> x3(@Nullable
                                                          E3 e3)

      Create a 5-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> NTuple5<T1,T2,T3,E4,T5> x4(@Nullable
                                                          E4 e4)

      Create a 5-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> NTuple5<T1,T2,T3,T4,E5> x5(@Nullable
                                                          E5 e5)

      Create a 5-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

    - #### x12

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

      Create a 5-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> NTuple5<E1,T2,E3,T4,T5> x13(@Nullable
                                                              E1 e1,
                                                              @Nullable
                                                              E3 e3)

      Create a 5-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> NTuple5<T1,E2,E3,T4,T5> x23(@Nullable
                                                              E2 e2,
                                                              @Nullable
                                                              E3 e3)

      Create a 5-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> NTuple5<E1,T2,T3,E4,T5> x14(@Nullable
                                                              E1 e1,
                                                              @Nullable
                                                              E4 e4)

      Create a 5-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> NTuple5<T1,E2,T3,E4,T5> x24(@Nullable
                                                              E2 e2,
                                                              @Nullable
                                                              E4 e4)

      Create a 5-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> NTuple5<T1,T2,E3,E4,T5> x34(@Nullable
                                                              E3 e3,
                                                              @Nullable
                                                              E4 e4)

      Create a 5-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> NTuple5<E1,T2,T3,T4,E5> x15(@Nullable
                                                              E1 e1,
                                                              @Nullable
                                                              E5 e5)

      Create a 5-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> NTuple5<T1,E2,T3,T4,E5> x25(@Nullable
                                                              E2 e2,
                                                              @Nullable
                                                              E5 e5)

      Create a 5-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> NTuple5<T1,T2,E3,T4,E5> x35(@Nullable
                                                              E3 e3,
                                                              @Nullable
                                                              E5 e5)

      Create a 5-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> NTuple5<T1,T2,T3,E4,E5> x45(@Nullable
                                                              E4 e4,
                                                              @Nullable
                                                              E5 e5)

      Create a 5-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

    - #### x123

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

      Create a 5-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> NTuple5<E1,E2,T3,E4,T5> x124(@Nullable
                                                                  E1 e1,
                                                                  @Nullable
                                                                  E2 e2,
                                                                  @Nullable
                                                                  E4 e4)

      Create a 5-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> NTuple5<E1,T2,E3,E4,T5> x134(@Nullable
                                                                  E1 e1,
                                                                  @Nullable
                                                                  E3 e3,
                                                                  @Nullable
                                                                  E4 e4)

      Create a 5-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> NTuple5<T1,E2,E3,E4,T5> x234(@Nullable
                                                                  E2 e2,
                                                                  @Nullable
                                                                  E3 e3,
                                                                  @Nullable
                                                                  E4 e4)

      Create a 5-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> NTuple5<E1,E2,T3,T4,E5> x125(@Nullable
                                                                  E1 e1,
                                                                  @Nullable
                                                                  E2 e2,
                                                                  @Nullable
                                                                  E5 e5)

      Create a 5-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> NTuple5<E1,T2,E3,T4,E5> x135(@Nullable
                                                                  E1 e1,
                                                                  @Nullable
                                                                  E3 e3,
                                                                  @Nullable
                                                                  E5 e5)

      Create a 5-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> NTuple5<T1,E2,E3,T4,E5> x235(@Nullable
                                                                  E2 e2,
                                                                  @Nullable
                                                                  E3 e3,
                                                                  @Nullable
                                                                  E5 e5)

      Create a 5-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> NTuple5<E1,T2,T3,E4,E5> x145(@Nullable
                                                                  E1 e1,
                                                                  @Nullable
                                                                  E4 e4,
                                                                  @Nullable
                                                                  E5 e5)

      Create a 5-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> NTuple5<T1,E2,T3,E4,E5> x245(@Nullable
                                                                  E2 e2,
                                                                  @Nullable
                                                                  E4 e4,
                                                                  @Nullable
                                                                  E5 e5)

      Create a 5-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> NTuple5<T1,T2,E3,E4,E5> x345(@Nullable
                                                                  E3 e3,
                                                                  @Nullable
                                                                  E4 e4,
                                                                  @Nullable
                                                                  E5 e5)

      Create a 5-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

    - #### x1234

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

      Create a 5-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> NTuple5<E1,E2,E3,T4,E5> x1235(@Nullable
                                                                      E1 e1,
                                                                      @Nullable
                                                                      E2 e2,
                                                                      @Nullable
                                                                      E3 e3,
                                                                      @Nullable
                                                                      E5 e5)

      Create a 5-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> NTuple5<E1,E2,T3,E4,E5> x1245(@Nullable
                                                                      E1 e1,
                                                                      @Nullable
                                                                      E2 e2,
                                                                      @Nullable
                                                                      E4 e4,
                                                                      @Nullable
                                                                      E5 e5)

      Create a 5-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> NTuple5<E1,T2,E3,E4,E5> x1345(@Nullable
                                                                      E1 e1,
                                                                      @Nullable
                                                                      E3 e3,
                                                                      @Nullable
                                                                      E4 e4,
                                                                      @Nullable
                                                                      E5 e5)

      Create a 5-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> NTuple5<T1,E2,E3,E4,E5> x2345(@Nullable
                                                                      E2 e2,
                                                                      @Nullable
                                                                      E3 e3,
                                                                      @Nullable
                                                                      E4 e4,
                                                                      @Nullable
                                                                      E5 e5)

      Create a 5-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

    - #### i1

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

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

    - #### i2

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

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

    - #### i3

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

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

    - #### i4

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

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

    - #### i5

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

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

    - #### i6

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

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

    - #### toString

          @NotNull
          public java.lang.String toString()

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