Trait wundergraph::helper::TupleIndex

pub trait TupleIndex<N> {
    type Value;
    fn get(&self) -> Self::Value;
}

A trait to have a type level index into a tuple

Self represents the tuple to index into, N the type level index

let _a: <(i32, &str, f64) as TupleIndex<TupleIndex1>>::Value = "foo";

Associated Types

type Value

The type of the indexed tuple value

Loading content...

Required methods

fn get(&self) -> Self::Value

Get the actual value at the given index

Loading content...

Implementations on Foreign Types

impl<'a, A: 'static> TupleIndex<TupleIndex0> for (A,) where
    A: Clone, 

type Value = A

fn get(&self) -> Self::Value

impl<A, SA> TupleIndex<(A,)> for (SA,) where
    SA: 'static,
    (SA,): TupleIndex<A>, 

type Value = (<(SA,) as TupleIndex<A>>::Value,)

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static> TupleIndex<TupleIndex0> for (A, B) where
    A: Clone, 

type Value = A

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static> TupleIndex<TupleIndex1> for (A, B) where
    B: Clone, 

type Value = B

fn get(&self) -> Self::Value

impl<A, B, SA, SB> TupleIndex<(A, B)> for (SA, SB) where
    SA: 'static,
    SB: 'static,
    (SA, SB): TupleIndex<A>,
    (SA, SB): TupleIndex<B>, 

type Value = (<(SA, SB) as TupleIndex<A>>::Value, <(SA, SB) as TupleIndex<B>>::Value)

fn get(&self) -> Self::Value

impl<B, SA, SB> TupleIndex<(B,)> for (SA, SB) where
    SA: 'static,
    SB: 'static,
    (SA, SB): TupleIndex<B>, 

type Value = (<(SA, SB) as TupleIndex<B>>::Value,)

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static> TupleIndex<TupleIndex0> for (A, B, C) where
    A: Clone, 

type Value = A

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static> TupleIndex<TupleIndex1> for (A, B, C) where
    B: Clone, 

type Value = B

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static> TupleIndex<TupleIndex2> for (A, B, C) where
    C: Clone, 

type Value = C

fn get(&self) -> Self::Value

impl<A, B, C, SA, SB, SC> TupleIndex<(A, B, C)> for (SA, SB, SC) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    (SA, SB, SC): TupleIndex<A>,
    (SA, SB, SC): TupleIndex<B>,
    (SA, SB, SC): TupleIndex<C>, 

type Value = (<(SA, SB, SC) as TupleIndex<A>>::Value, <(SA, SB, SC) as TupleIndex<B>>::Value, <(SA, SB, SC) as TupleIndex<C>>::Value)

fn get(&self) -> Self::Value

impl<B, C, SA, SB, SC> TupleIndex<(B, C)> for (SA, SB, SC) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    (SA, SB, SC): TupleIndex<B>,
    (SA, SB, SC): TupleIndex<C>, 

type Value = (<(SA, SB, SC) as TupleIndex<B>>::Value, <(SA, SB, SC) as TupleIndex<C>>::Value)

fn get(&self) -> Self::Value

impl<C, SA, SB, SC> TupleIndex<(C,)> for (SA, SB, SC) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    (SA, SB, SC): TupleIndex<C>, 

type Value = (<(SA, SB, SC) as TupleIndex<C>>::Value,)

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static> TupleIndex<TupleIndex0> for (A, B, C, D) where
    A: Clone, 

type Value = A

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static> TupleIndex<TupleIndex1> for (A, B, C, D) where
    B: Clone, 

type Value = B

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static> TupleIndex<TupleIndex2> for (A, B, C, D) where
    C: Clone, 

type Value = C

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static> TupleIndex<TupleIndex3> for (A, B, C, D) where
    D: Clone, 

type Value = D

fn get(&self) -> Self::Value

impl<A, B, C, D, SA, SB, SC, SD> TupleIndex<(A, B, C, D)> for (SA, SB, SC, SD) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    (SA, SB, SC, SD): TupleIndex<A>,
    (SA, SB, SC, SD): TupleIndex<B>,
    (SA, SB, SC, SD): TupleIndex<C>,
    (SA, SB, SC, SD): TupleIndex<D>, 

type Value = (<(SA, SB, SC, SD) as TupleIndex<A>>::Value, <(SA, SB, SC, SD) as TupleIndex<B>>::Value, <(SA, SB, SC, SD) as TupleIndex<C>>::Value, <(SA, SB, SC, SD) as TupleIndex<D>>::Value)

fn get(&self) -> Self::Value

impl<B, C, D, SA, SB, SC, SD> TupleIndex<(B, C, D)> for (SA, SB, SC, SD) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    (SA, SB, SC, SD): TupleIndex<B>,
    (SA, SB, SC, SD): TupleIndex<C>,
    (SA, SB, SC, SD): TupleIndex<D>, 

type Value = (<(SA, SB, SC, SD) as TupleIndex<B>>::Value, <(SA, SB, SC, SD) as TupleIndex<C>>::Value, <(SA, SB, SC, SD) as TupleIndex<D>>::Value)

fn get(&self) -> Self::Value

impl<C, D, SA, SB, SC, SD> TupleIndex<(C, D)> for (SA, SB, SC, SD) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    (SA, SB, SC, SD): TupleIndex<C>,
    (SA, SB, SC, SD): TupleIndex<D>, 

type Value = (<(SA, SB, SC, SD) as TupleIndex<C>>::Value, <(SA, SB, SC, SD) as TupleIndex<D>>::Value)

fn get(&self) -> Self::Value

impl<D, SA, SB, SC, SD> TupleIndex<(D,)> for (SA, SB, SC, SD) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    (SA, SB, SC, SD): TupleIndex<D>, 

type Value = (<(SA, SB, SC, SD) as TupleIndex<D>>::Value,)

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> TupleIndex<TupleIndex0> for (A, B, C, D, E) where
    A: Clone, 

type Value = A

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> TupleIndex<TupleIndex1> for (A, B, C, D, E) where
    B: Clone, 

type Value = B

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> TupleIndex<TupleIndex2> for (A, B, C, D, E) where
    C: Clone, 

type Value = C

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> TupleIndex<TupleIndex3> for (A, B, C, D, E) where
    D: Clone, 

type Value = D

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static> TupleIndex<TupleIndex4> for (A, B, C, D, E) where
    E: Clone, 

type Value = E

fn get(&self) -> Self::Value

impl<A, B, C, D, E, SA, SB, SC, SD, SE> TupleIndex<(A, B, C, D, E)> for (SA, SB, SC, SD, SE) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    (SA, SB, SC, SD, SE): TupleIndex<A>,
    (SA, SB, SC, SD, SE): TupleIndex<B>,
    (SA, SB, SC, SD, SE): TupleIndex<C>,
    (SA, SB, SC, SD, SE): TupleIndex<D>,
    (SA, SB, SC, SD, SE): TupleIndex<E>, 

type Value = (<(SA, SB, SC, SD, SE) as TupleIndex<A>>::Value, <(SA, SB, SC, SD, SE) as TupleIndex<B>>::Value, <(SA, SB, SC, SD, SE) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE) as TupleIndex<E>>::Value)

fn get(&self) -> Self::Value

impl<B, C, D, E, SA, SB, SC, SD, SE> TupleIndex<(B, C, D, E)> for (SA, SB, SC, SD, SE) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    (SA, SB, SC, SD, SE): TupleIndex<B>,
    (SA, SB, SC, SD, SE): TupleIndex<C>,
    (SA, SB, SC, SD, SE): TupleIndex<D>,
    (SA, SB, SC, SD, SE): TupleIndex<E>, 

type Value = (<(SA, SB, SC, SD, SE) as TupleIndex<B>>::Value, <(SA, SB, SC, SD, SE) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE) as TupleIndex<E>>::Value)

fn get(&self) -> Self::Value

impl<C, D, E, SA, SB, SC, SD, SE> TupleIndex<(C, D, E)> for (SA, SB, SC, SD, SE) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    (SA, SB, SC, SD, SE): TupleIndex<C>,
    (SA, SB, SC, SD, SE): TupleIndex<D>,
    (SA, SB, SC, SD, SE): TupleIndex<E>, 

type Value = (<(SA, SB, SC, SD, SE) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE) as TupleIndex<E>>::Value)

fn get(&self) -> Self::Value

impl<D, E, SA, SB, SC, SD, SE> TupleIndex<(D, E)> for (SA, SB, SC, SD, SE) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    (SA, SB, SC, SD, SE): TupleIndex<D>,
    (SA, SB, SC, SD, SE): TupleIndex<E>, 

type Value = (<(SA, SB, SC, SD, SE) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE) as TupleIndex<E>>::Value)

fn get(&self) -> Self::Value

impl<E, SA, SB, SC, SD, SE> TupleIndex<(E,)> for (SA, SB, SC, SD, SE) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    (SA, SB, SC, SD, SE): TupleIndex<E>, 

type Value = (<(SA, SB, SC, SD, SE) as TupleIndex<E>>::Value,)

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> TupleIndex<TupleIndex0> for (A, B, C, D, E, F) where
    A: Clone, 

type Value = A

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> TupleIndex<TupleIndex1> for (A, B, C, D, E, F) where
    B: Clone, 

type Value = B

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> TupleIndex<TupleIndex2> for (A, B, C, D, E, F) where
    C: Clone, 

type Value = C

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> TupleIndex<TupleIndex3> for (A, B, C, D, E, F) where
    D: Clone, 

type Value = D

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> TupleIndex<TupleIndex4> for (A, B, C, D, E, F) where
    E: Clone, 

type Value = E

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static> TupleIndex<TupleIndex5> for (A, B, C, D, E, F) where
    F: Clone, 

type Value = F

fn get(&self) -> Self::Value

impl<A, B, C, D, E, F, SA, SB, SC, SD, SE, SF> TupleIndex<(A, B, C, D, E, F)> for (SA, SB, SC, SD, SE, SF) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    (SA, SB, SC, SD, SE, SF): TupleIndex<A>,
    (SA, SB, SC, SD, SE, SF): TupleIndex<B>,
    (SA, SB, SC, SD, SE, SF): TupleIndex<C>,
    (SA, SB, SC, SD, SE, SF): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF): TupleIndex<F>, 

type Value = (<(SA, SB, SC, SD, SE, SF) as TupleIndex<A>>::Value, <(SA, SB, SC, SD, SE, SF) as TupleIndex<B>>::Value, <(SA, SB, SC, SD, SE, SF) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE, SF) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF) as TupleIndex<F>>::Value)

fn get(&self) -> Self::Value

impl<B, C, D, E, F, SA, SB, SC, SD, SE, SF> TupleIndex<(B, C, D, E, F)> for (SA, SB, SC, SD, SE, SF) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    (SA, SB, SC, SD, SE, SF): TupleIndex<B>,
    (SA, SB, SC, SD, SE, SF): TupleIndex<C>,
    (SA, SB, SC, SD, SE, SF): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF): TupleIndex<F>, 

type Value = (<(SA, SB, SC, SD, SE, SF) as TupleIndex<B>>::Value, <(SA, SB, SC, SD, SE, SF) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE, SF) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF) as TupleIndex<F>>::Value)

fn get(&self) -> Self::Value

impl<C, D, E, F, SA, SB, SC, SD, SE, SF> TupleIndex<(C, D, E, F)> for (SA, SB, SC, SD, SE, SF) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    (SA, SB, SC, SD, SE, SF): TupleIndex<C>,
    (SA, SB, SC, SD, SE, SF): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF): TupleIndex<F>, 

type Value = (<(SA, SB, SC, SD, SE, SF) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE, SF) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF) as TupleIndex<F>>::Value)

fn get(&self) -> Self::Value

impl<D, E, F, SA, SB, SC, SD, SE, SF> TupleIndex<(D, E, F)> for (SA, SB, SC, SD, SE, SF) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    (SA, SB, SC, SD, SE, SF): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF): TupleIndex<F>, 

type Value = (<(SA, SB, SC, SD, SE, SF) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF) as TupleIndex<F>>::Value)

fn get(&self) -> Self::Value

impl<E, F, SA, SB, SC, SD, SE, SF> TupleIndex<(E, F)> for (SA, SB, SC, SD, SE, SF) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    (SA, SB, SC, SD, SE, SF): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF): TupleIndex<F>, 

type Value = (<(SA, SB, SC, SD, SE, SF) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF) as TupleIndex<F>>::Value)

fn get(&self) -> Self::Value

impl<F, SA, SB, SC, SD, SE, SF> TupleIndex<(F,)> for (SA, SB, SC, SD, SE, SF) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    (SA, SB, SC, SD, SE, SF): TupleIndex<F>, 

type Value = (<(SA, SB, SC, SD, SE, SF) as TupleIndex<F>>::Value,)

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static> TupleIndex<TupleIndex0> for (A, B, C, D, E, F, G) where
    A: Clone, 

type Value = A

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static> TupleIndex<TupleIndex1> for (A, B, C, D, E, F, G) where
    B: Clone, 

type Value = B

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static> TupleIndex<TupleIndex2> for (A, B, C, D, E, F, G) where
    C: Clone, 

type Value = C

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static> TupleIndex<TupleIndex3> for (A, B, C, D, E, F, G) where
    D: Clone, 

type Value = D

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static> TupleIndex<TupleIndex4> for (A, B, C, D, E, F, G) where
    E: Clone, 

type Value = E

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static> TupleIndex<TupleIndex5> for (A, B, C, D, E, F, G) where
    F: Clone, 

type Value = F

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static> TupleIndex<TupleIndex6> for (A, B, C, D, E, F, G) where
    G: Clone, 

type Value = G

fn get(&self) -> Self::Value

impl<A, B, C, D, E, F, G, SA, SB, SC, SD, SE, SF, SG> TupleIndex<(A, B, C, D, E, F, G)> for (SA, SB, SC, SD, SE, SF, SG) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    (SA, SB, SC, SD, SE, SF, SG): TupleIndex<A>,
    (SA, SB, SC, SD, SE, SF, SG): TupleIndex<B>,
    (SA, SB, SC, SD, SE, SF, SG): TupleIndex<C>,
    (SA, SB, SC, SD, SE, SF, SG): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG): TupleIndex<G>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG) as TupleIndex<A>>::Value, <(SA, SB, SC, SD, SE, SF, SG) as TupleIndex<B>>::Value, <(SA, SB, SC, SD, SE, SF, SG) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE, SF, SG) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG) as TupleIndex<G>>::Value)

fn get(&self) -> Self::Value

impl<B, C, D, E, F, G, SA, SB, SC, SD, SE, SF, SG> TupleIndex<(B, C, D, E, F, G)> for (SA, SB, SC, SD, SE, SF, SG) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    (SA, SB, SC, SD, SE, SF, SG): TupleIndex<B>,
    (SA, SB, SC, SD, SE, SF, SG): TupleIndex<C>,
    (SA, SB, SC, SD, SE, SF, SG): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG): TupleIndex<G>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG) as TupleIndex<B>>::Value, <(SA, SB, SC, SD, SE, SF, SG) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE, SF, SG) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG) as TupleIndex<G>>::Value)

fn get(&self) -> Self::Value

impl<C, D, E, F, G, SA, SB, SC, SD, SE, SF, SG> TupleIndex<(C, D, E, F, G)> for (SA, SB, SC, SD, SE, SF, SG) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    (SA, SB, SC, SD, SE, SF, SG): TupleIndex<C>,
    (SA, SB, SC, SD, SE, SF, SG): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG): TupleIndex<G>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE, SF, SG) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG) as TupleIndex<G>>::Value)

fn get(&self) -> Self::Value

impl<D, E, F, G, SA, SB, SC, SD, SE, SF, SG> TupleIndex<(D, E, F, G)> for (SA, SB, SC, SD, SE, SF, SG) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    (SA, SB, SC, SD, SE, SF, SG): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG): TupleIndex<G>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG) as TupleIndex<G>>::Value)

fn get(&self) -> Self::Value

impl<E, F, G, SA, SB, SC, SD, SE, SF, SG> TupleIndex<(E, F, G)> for (SA, SB, SC, SD, SE, SF, SG) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    (SA, SB, SC, SD, SE, SF, SG): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG): TupleIndex<G>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG) as TupleIndex<G>>::Value)

fn get(&self) -> Self::Value

impl<F, G, SA, SB, SC, SD, SE, SF, SG> TupleIndex<(F, G)> for (SA, SB, SC, SD, SE, SF, SG) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    (SA, SB, SC, SD, SE, SF, SG): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG): TupleIndex<G>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG) as TupleIndex<G>>::Value)

fn get(&self) -> Self::Value

impl<G, SA, SB, SC, SD, SE, SF, SG> TupleIndex<(G,)> for (SA, SB, SC, SD, SE, SF, SG) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    (SA, SB, SC, SD, SE, SF, SG): TupleIndex<G>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG) as TupleIndex<G>>::Value,)

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static> TupleIndex<TupleIndex0> for (A, B, C, D, E, F, G, H) where
    A: Clone, 

type Value = A

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static> TupleIndex<TupleIndex1> for (A, B, C, D, E, F, G, H) where
    B: Clone, 

type Value = B

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static> TupleIndex<TupleIndex2> for (A, B, C, D, E, F, G, H) where
    C: Clone, 

type Value = C

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static> TupleIndex<TupleIndex3> for (A, B, C, D, E, F, G, H) where
    D: Clone, 

type Value = D

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static> TupleIndex<TupleIndex4> for (A, B, C, D, E, F, G, H) where
    E: Clone, 

type Value = E

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static> TupleIndex<TupleIndex5> for (A, B, C, D, E, F, G, H) where
    F: Clone, 

type Value = F

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static> TupleIndex<TupleIndex6> for (A, B, C, D, E, F, G, H) where
    G: Clone, 

type Value = G

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static> TupleIndex<TupleIndex7> for (A, B, C, D, E, F, G, H) where
    H: Clone, 

type Value = H

fn get(&self) -> Self::Value

impl<A, B, C, D, E, F, G, H, SA, SB, SC, SD, SE, SF, SG, SH> TupleIndex<(A, B, C, D, E, F, G, H)> for (SA, SB, SC, SD, SE, SF, SG, SH) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<A>,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<B>,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<C>,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<H>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<A>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<B>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<H>>::Value)

fn get(&self) -> Self::Value

impl<B, C, D, E, F, G, H, SA, SB, SC, SD, SE, SF, SG, SH> TupleIndex<(B, C, D, E, F, G, H)> for (SA, SB, SC, SD, SE, SF, SG, SH) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<B>,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<C>,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<H>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<B>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<H>>::Value)

fn get(&self) -> Self::Value

impl<C, D, E, F, G, H, SA, SB, SC, SD, SE, SF, SG, SH> TupleIndex<(C, D, E, F, G, H)> for (SA, SB, SC, SD, SE, SF, SG, SH) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<C>,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<H>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<H>>::Value)

fn get(&self) -> Self::Value

impl<D, E, F, G, H, SA, SB, SC, SD, SE, SF, SG, SH> TupleIndex<(D, E, F, G, H)> for (SA, SB, SC, SD, SE, SF, SG, SH) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<H>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<H>>::Value)

fn get(&self) -> Self::Value

impl<E, F, G, H, SA, SB, SC, SD, SE, SF, SG, SH> TupleIndex<(E, F, G, H)> for (SA, SB, SC, SD, SE, SF, SG, SH) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<H>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<H>>::Value)

fn get(&self) -> Self::Value

impl<F, G, H, SA, SB, SC, SD, SE, SF, SG, SH> TupleIndex<(F, G, H)> for (SA, SB, SC, SD, SE, SF, SG, SH) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<H>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<H>>::Value)

fn get(&self) -> Self::Value

impl<G, H, SA, SB, SC, SD, SE, SF, SG, SH> TupleIndex<(G, H)> for (SA, SB, SC, SD, SE, SF, SG, SH) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<H>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<H>>::Value)

fn get(&self) -> Self::Value

impl<H, SA, SB, SC, SD, SE, SF, SG, SH> TupleIndex<(H,)> for (SA, SB, SC, SD, SE, SF, SG, SH) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH): TupleIndex<H>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH) as TupleIndex<H>>::Value,)

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static> TupleIndex<TupleIndex0> for (A, B, C, D, E, F, G, H, I) where
    A: Clone, 

type Value = A

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static> TupleIndex<TupleIndex1> for (A, B, C, D, E, F, G, H, I) where
    B: Clone, 

type Value = B

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static> TupleIndex<TupleIndex2> for (A, B, C, D, E, F, G, H, I) where
    C: Clone, 

type Value = C

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static> TupleIndex<TupleIndex3> for (A, B, C, D, E, F, G, H, I) where
    D: Clone, 

type Value = D

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static> TupleIndex<TupleIndex4> for (A, B, C, D, E, F, G, H, I) where
    E: Clone, 

type Value = E

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static> TupleIndex<TupleIndex5> for (A, B, C, D, E, F, G, H, I) where
    F: Clone, 

type Value = F

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static> TupleIndex<TupleIndex6> for (A, B, C, D, E, F, G, H, I) where
    G: Clone, 

type Value = G

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static> TupleIndex<TupleIndex7> for (A, B, C, D, E, F, G, H, I) where
    H: Clone, 

type Value = H

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static> TupleIndex<TupleIndex8> for (A, B, C, D, E, F, G, H, I) where
    I: Clone, 

type Value = I

fn get(&self) -> Self::Value

impl<A, B, C, D, E, F, G, H, I, SA, SB, SC, SD, SE, SF, SG, SH, SI> TupleIndex<(A, B, C, D, E, F, G, H, I)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<A>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<B>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<C>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<I>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<A>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<B>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<I>>::Value)

fn get(&self) -> Self::Value

impl<B, C, D, E, F, G, H, I, SA, SB, SC, SD, SE, SF, SG, SH, SI> TupleIndex<(B, C, D, E, F, G, H, I)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<B>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<C>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<I>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<B>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<I>>::Value)

fn get(&self) -> Self::Value

impl<C, D, E, F, G, H, I, SA, SB, SC, SD, SE, SF, SG, SH, SI> TupleIndex<(C, D, E, F, G, H, I)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<C>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<I>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<I>>::Value)

fn get(&self) -> Self::Value

impl<D, E, F, G, H, I, SA, SB, SC, SD, SE, SF, SG, SH, SI> TupleIndex<(D, E, F, G, H, I)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<I>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<I>>::Value)

fn get(&self) -> Self::Value

impl<E, F, G, H, I, SA, SB, SC, SD, SE, SF, SG, SH, SI> TupleIndex<(E, F, G, H, I)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<I>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<I>>::Value)

fn get(&self) -> Self::Value

impl<F, G, H, I, SA, SB, SC, SD, SE, SF, SG, SH, SI> TupleIndex<(F, G, H, I)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<I>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<I>>::Value)

fn get(&self) -> Self::Value

impl<G, H, I, SA, SB, SC, SD, SE, SF, SG, SH, SI> TupleIndex<(G, H, I)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<I>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<I>>::Value)

fn get(&self) -> Self::Value

impl<H, I, SA, SB, SC, SD, SE, SF, SG, SH, SI> TupleIndex<(H, I)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<I>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<I>>::Value)

fn get(&self) -> Self::Value

impl<I, SA, SB, SC, SD, SE, SF, SG, SH, SI> TupleIndex<(I,)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI): TupleIndex<I>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI) as TupleIndex<I>>::Value,)

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static> TupleIndex<TupleIndex0> for (A, B, C, D, E, F, G, H, I, J) where
    A: Clone, 

type Value = A

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static> TupleIndex<TupleIndex1> for (A, B, C, D, E, F, G, H, I, J) where
    B: Clone, 

type Value = B

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static> TupleIndex<TupleIndex2> for (A, B, C, D, E, F, G, H, I, J) where
    C: Clone, 

type Value = C

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static> TupleIndex<TupleIndex3> for (A, B, C, D, E, F, G, H, I, J) where
    D: Clone, 

type Value = D

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static> TupleIndex<TupleIndex4> for (A, B, C, D, E, F, G, H, I, J) where
    E: Clone, 

type Value = E

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static> TupleIndex<TupleIndex5> for (A, B, C, D, E, F, G, H, I, J) where
    F: Clone, 

type Value = F

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static> TupleIndex<TupleIndex6> for (A, B, C, D, E, F, G, H, I, J) where
    G: Clone, 

type Value = G

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static> TupleIndex<TupleIndex7> for (A, B, C, D, E, F, G, H, I, J) where
    H: Clone, 

type Value = H

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static> TupleIndex<TupleIndex8> for (A, B, C, D, E, F, G, H, I, J) where
    I: Clone, 

type Value = I

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static> TupleIndex<TupleIndex9> for (A, B, C, D, E, F, G, H, I, J) where
    J: Clone, 

type Value = J

fn get(&self) -> Self::Value

impl<A, B, C, D, E, F, G, H, I, J, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ> TupleIndex<(A, B, C, D, E, F, G, H, I, J)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<A>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<B>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<C>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<J>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<A>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<B>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<J>>::Value)

fn get(&self) -> Self::Value

impl<B, C, D, E, F, G, H, I, J, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ> TupleIndex<(B, C, D, E, F, G, H, I, J)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<B>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<C>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<J>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<B>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<J>>::Value)

fn get(&self) -> Self::Value

impl<C, D, E, F, G, H, I, J, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ> TupleIndex<(C, D, E, F, G, H, I, J)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<C>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<J>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<J>>::Value)

fn get(&self) -> Self::Value

impl<D, E, F, G, H, I, J, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ> TupleIndex<(D, E, F, G, H, I, J)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<J>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<J>>::Value)

fn get(&self) -> Self::Value

impl<E, F, G, H, I, J, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ> TupleIndex<(E, F, G, H, I, J)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<J>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<J>>::Value)

fn get(&self) -> Self::Value

impl<F, G, H, I, J, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ> TupleIndex<(F, G, H, I, J)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<J>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<J>>::Value)

fn get(&self) -> Self::Value

impl<G, H, I, J, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ> TupleIndex<(G, H, I, J)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<J>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<J>>::Value)

fn get(&self) -> Self::Value

impl<H, I, J, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ> TupleIndex<(H, I, J)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<J>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<J>>::Value)

fn get(&self) -> Self::Value

impl<I, J, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ> TupleIndex<(I, J)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<J>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<J>>::Value)

fn get(&self) -> Self::Value

impl<J, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ> TupleIndex<(J,)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ): TupleIndex<J>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ) as TupleIndex<J>>::Value,)

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static> TupleIndex<TupleIndex0> for (A, B, C, D, E, F, G, H, I, J, K) where
    A: Clone, 

type Value = A

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static> TupleIndex<TupleIndex1> for (A, B, C, D, E, F, G, H, I, J, K) where
    B: Clone, 

type Value = B

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static> TupleIndex<TupleIndex2> for (A, B, C, D, E, F, G, H, I, J, K) where
    C: Clone, 

type Value = C

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static> TupleIndex<TupleIndex3> for (A, B, C, D, E, F, G, H, I, J, K) where
    D: Clone, 

type Value = D

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static> TupleIndex<TupleIndex4> for (A, B, C, D, E, F, G, H, I, J, K) where
    E: Clone, 

type Value = E

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static> TupleIndex<TupleIndex5> for (A, B, C, D, E, F, G, H, I, J, K) where
    F: Clone, 

type Value = F

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static> TupleIndex<TupleIndex6> for (A, B, C, D, E, F, G, H, I, J, K) where
    G: Clone, 

type Value = G

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static> TupleIndex<TupleIndex7> for (A, B, C, D, E, F, G, H, I, J, K) where
    H: Clone, 

type Value = H

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static> TupleIndex<TupleIndex8> for (A, B, C, D, E, F, G, H, I, J, K) where
    I: Clone, 

type Value = I

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static> TupleIndex<TupleIndex9> for (A, B, C, D, E, F, G, H, I, J, K) where
    J: Clone, 

type Value = J

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static> TupleIndex<TupleIndex10> for (A, B, C, D, E, F, G, H, I, J, K) where
    K: Clone, 

type Value = K

fn get(&self) -> Self::Value

impl<A, B, C, D, E, F, G, H, I, J, K, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK> TupleIndex<(A, B, C, D, E, F, G, H, I, J, K)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<A>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<B>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<C>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<K>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<A>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<B>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<K>>::Value)

fn get(&self) -> Self::Value

impl<B, C, D, E, F, G, H, I, J, K, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK> TupleIndex<(B, C, D, E, F, G, H, I, J, K)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<B>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<C>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<K>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<B>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<K>>::Value)

fn get(&self) -> Self::Value

impl<C, D, E, F, G, H, I, J, K, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK> TupleIndex<(C, D, E, F, G, H, I, J, K)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<C>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<K>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<K>>::Value)

fn get(&self) -> Self::Value

impl<D, E, F, G, H, I, J, K, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK> TupleIndex<(D, E, F, G, H, I, J, K)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<K>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<K>>::Value)

fn get(&self) -> Self::Value

impl<E, F, G, H, I, J, K, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK> TupleIndex<(E, F, G, H, I, J, K)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<K>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<K>>::Value)

fn get(&self) -> Self::Value

impl<F, G, H, I, J, K, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK> TupleIndex<(F, G, H, I, J, K)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<K>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<K>>::Value)

fn get(&self) -> Self::Value

impl<G, H, I, J, K, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK> TupleIndex<(G, H, I, J, K)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<K>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<K>>::Value)

fn get(&self) -> Self::Value

impl<H, I, J, K, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK> TupleIndex<(H, I, J, K)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<K>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<K>>::Value)

fn get(&self) -> Self::Value

impl<I, J, K, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK> TupleIndex<(I, J, K)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<K>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<K>>::Value)

fn get(&self) -> Self::Value

impl<J, K, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK> TupleIndex<(J, K)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<K>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<K>>::Value)

fn get(&self) -> Self::Value

impl<K, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK> TupleIndex<(K,)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK): TupleIndex<K>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK) as TupleIndex<K>>::Value,)

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static> TupleIndex<TupleIndex0> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    A: Clone, 

type Value = A

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static> TupleIndex<TupleIndex1> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    B: Clone, 

type Value = B

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static> TupleIndex<TupleIndex2> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    C: Clone, 

type Value = C

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static> TupleIndex<TupleIndex3> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    D: Clone, 

type Value = D

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static> TupleIndex<TupleIndex4> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    E: Clone, 

type Value = E

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static> TupleIndex<TupleIndex5> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    F: Clone, 

type Value = F

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static> TupleIndex<TupleIndex6> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    G: Clone, 

type Value = G

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static> TupleIndex<TupleIndex7> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    H: Clone, 

type Value = H

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static> TupleIndex<TupleIndex8> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    I: Clone, 

type Value = I

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static> TupleIndex<TupleIndex9> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    J: Clone, 

type Value = J

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static> TupleIndex<TupleIndex10> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    K: Clone, 

type Value = K

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static> TupleIndex<TupleIndex11> for (A, B, C, D, E, F, G, H, I, J, K, L) where
    L: Clone, 

type Value = L

fn get(&self) -> Self::Value

impl<A, B, C, D, E, F, G, H, I, J, K, L, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL> TupleIndex<(A, B, C, D, E, F, G, H, I, J, K, L)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<A>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<B>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<C>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<L>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<A>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<B>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<L>>::Value)

fn get(&self) -> Self::Value

impl<B, C, D, E, F, G, H, I, J, K, L, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL> TupleIndex<(B, C, D, E, F, G, H, I, J, K, L)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<B>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<C>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<L>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<B>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<L>>::Value)

fn get(&self) -> Self::Value

impl<C, D, E, F, G, H, I, J, K, L, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL> TupleIndex<(C, D, E, F, G, H, I, J, K, L)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<C>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<L>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<L>>::Value)

fn get(&self) -> Self::Value

impl<D, E, F, G, H, I, J, K, L, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL> TupleIndex<(D, E, F, G, H, I, J, K, L)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<L>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<L>>::Value)

fn get(&self) -> Self::Value

impl<E, F, G, H, I, J, K, L, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL> TupleIndex<(E, F, G, H, I, J, K, L)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<L>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<L>>::Value)

fn get(&self) -> Self::Value

impl<F, G, H, I, J, K, L, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL> TupleIndex<(F, G, H, I, J, K, L)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<L>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<L>>::Value)

fn get(&self) -> Self::Value

impl<G, H, I, J, K, L, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL> TupleIndex<(G, H, I, J, K, L)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<L>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<L>>::Value)

fn get(&self) -> Self::Value

impl<H, I, J, K, L, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL> TupleIndex<(H, I, J, K, L)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<L>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<L>>::Value)

fn get(&self) -> Self::Value

impl<I, J, K, L, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL> TupleIndex<(I, J, K, L)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<L>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<L>>::Value)

fn get(&self) -> Self::Value

impl<J, K, L, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL> TupleIndex<(J, K, L)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<L>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<L>>::Value)

fn get(&self) -> Self::Value

impl<K, L, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL> TupleIndex<(K, L)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<L>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<L>>::Value)

fn get(&self) -> Self::Value

impl<L, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL> TupleIndex<(L,)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL): TupleIndex<L>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL) as TupleIndex<L>>::Value,)

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static> TupleIndex<TupleIndex0> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    A: Clone, 

type Value = A

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static> TupleIndex<TupleIndex1> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    B: Clone, 

type Value = B

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static> TupleIndex<TupleIndex2> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    C: Clone, 

type Value = C

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static> TupleIndex<TupleIndex3> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    D: Clone, 

type Value = D

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static> TupleIndex<TupleIndex4> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    E: Clone, 

type Value = E

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static> TupleIndex<TupleIndex5> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    F: Clone, 

type Value = F

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static> TupleIndex<TupleIndex6> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    G: Clone, 

type Value = G

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static> TupleIndex<TupleIndex7> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    H: Clone, 

type Value = H

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static> TupleIndex<TupleIndex8> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    I: Clone, 

type Value = I

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static> TupleIndex<TupleIndex9> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    J: Clone, 

type Value = J

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static> TupleIndex<TupleIndex10> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    K: Clone, 

type Value = K

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static> TupleIndex<TupleIndex11> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    L: Clone, 

type Value = L

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static> TupleIndex<TupleIndex12> for (A, B, C, D, E, F, G, H, I, J, K, L, M) where
    M: Clone, 

type Value = M

fn get(&self) -> Self::Value

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM> TupleIndex<(A, B, C, D, E, F, G, H, I, J, K, L, M)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<A>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<B>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<C>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<M>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<A>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<B>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<M>>::Value)

fn get(&self) -> Self::Value

impl<B, C, D, E, F, G, H, I, J, K, L, M, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM> TupleIndex<(B, C, D, E, F, G, H, I, J, K, L, M)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<B>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<C>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<M>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<B>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<M>>::Value)

fn get(&self) -> Self::Value

impl<C, D, E, F, G, H, I, J, K, L, M, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM> TupleIndex<(C, D, E, F, G, H, I, J, K, L, M)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<C>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<M>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<M>>::Value)

fn get(&self) -> Self::Value

impl<D, E, F, G, H, I, J, K, L, M, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM> TupleIndex<(D, E, F, G, H, I, J, K, L, M)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<M>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<M>>::Value)

fn get(&self) -> Self::Value

impl<E, F, G, H, I, J, K, L, M, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM> TupleIndex<(E, F, G, H, I, J, K, L, M)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<M>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<M>>::Value)

fn get(&self) -> Self::Value

impl<F, G, H, I, J, K, L, M, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM> TupleIndex<(F, G, H, I, J, K, L, M)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<M>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<M>>::Value)

fn get(&self) -> Self::Value

impl<G, H, I, J, K, L, M, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM> TupleIndex<(G, H, I, J, K, L, M)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<M>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<M>>::Value)

fn get(&self) -> Self::Value

impl<H, I, J, K, L, M, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM> TupleIndex<(H, I, J, K, L, M)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<M>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<M>>::Value)

fn get(&self) -> Self::Value

impl<I, J, K, L, M, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM> TupleIndex<(I, J, K, L, M)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<M>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<M>>::Value)

fn get(&self) -> Self::Value

impl<J, K, L, M, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM> TupleIndex<(J, K, L, M)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<M>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<M>>::Value)

fn get(&self) -> Self::Value

impl<K, L, M, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM> TupleIndex<(K, L, M)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<M>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<M>>::Value)

fn get(&self) -> Self::Value

impl<L, M, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM> TupleIndex<(L, M)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<M>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<M>>::Value)

fn get(&self) -> Self::Value

impl<M, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM> TupleIndex<(M,)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM): TupleIndex<M>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM) as TupleIndex<M>>::Value,)

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static> TupleIndex<TupleIndex0> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    A: Clone, 

type Value = A

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static> TupleIndex<TupleIndex1> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    B: Clone, 

type Value = B

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static> TupleIndex<TupleIndex2> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    C: Clone, 

type Value = C

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static> TupleIndex<TupleIndex3> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    D: Clone, 

type Value = D

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static> TupleIndex<TupleIndex4> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    E: Clone, 

type Value = E

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static> TupleIndex<TupleIndex5> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    F: Clone, 

type Value = F

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static> TupleIndex<TupleIndex6> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    G: Clone, 

type Value = G

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static> TupleIndex<TupleIndex7> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    H: Clone, 

type Value = H

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static> TupleIndex<TupleIndex8> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    I: Clone, 

type Value = I

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static> TupleIndex<TupleIndex9> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    J: Clone, 

type Value = J

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static> TupleIndex<TupleIndex10> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    K: Clone, 

type Value = K

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static> TupleIndex<TupleIndex11> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    L: Clone, 

type Value = L

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static> TupleIndex<TupleIndex12> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    M: Clone, 

type Value = M

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static> TupleIndex<TupleIndex13> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N) where
    N: Clone, 

type Value = N

fn get(&self) -> Self::Value

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN> TupleIndex<(A, B, C, D, E, F, G, H, I, J, K, L, M, N)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<A>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<B>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<C>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<N>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<A>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<B>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<N>>::Value)

fn get(&self) -> Self::Value

impl<B, C, D, E, F, G, H, I, J, K, L, M, N, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN> TupleIndex<(B, C, D, E, F, G, H, I, J, K, L, M, N)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<B>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<C>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<N>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<B>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<N>>::Value)

fn get(&self) -> Self::Value

impl<C, D, E, F, G, H, I, J, K, L, M, N, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN> TupleIndex<(C, D, E, F, G, H, I, J, K, L, M, N)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<C>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<N>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<N>>::Value)

fn get(&self) -> Self::Value

impl<D, E, F, G, H, I, J, K, L, M, N, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN> TupleIndex<(D, E, F, G, H, I, J, K, L, M, N)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<N>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<N>>::Value)

fn get(&self) -> Self::Value

impl<E, F, G, H, I, J, K, L, M, N, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN> TupleIndex<(E, F, G, H, I, J, K, L, M, N)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<N>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<N>>::Value)

fn get(&self) -> Self::Value

impl<F, G, H, I, J, K, L, M, N, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN> TupleIndex<(F, G, H, I, J, K, L, M, N)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<N>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<N>>::Value)

fn get(&self) -> Self::Value

impl<G, H, I, J, K, L, M, N, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN> TupleIndex<(G, H, I, J, K, L, M, N)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<N>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<N>>::Value)

fn get(&self) -> Self::Value

impl<H, I, J, K, L, M, N, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN> TupleIndex<(H, I, J, K, L, M, N)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<N>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<N>>::Value)

fn get(&self) -> Self::Value

impl<I, J, K, L, M, N, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN> TupleIndex<(I, J, K, L, M, N)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<N>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<N>>::Value)

fn get(&self) -> Self::Value

impl<J, K, L, M, N, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN> TupleIndex<(J, K, L, M, N)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<N>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<N>>::Value)

fn get(&self) -> Self::Value

impl<K, L, M, N, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN> TupleIndex<(K, L, M, N)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<N>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<N>>::Value)

fn get(&self) -> Self::Value

impl<L, M, N, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN> TupleIndex<(L, M, N)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<N>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<N>>::Value)

fn get(&self) -> Self::Value

impl<M, N, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN> TupleIndex<(M, N)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<N>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<N>>::Value)

fn get(&self) -> Self::Value

impl<N, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN> TupleIndex<(N,)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN): TupleIndex<N>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN) as TupleIndex<N>>::Value,)

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static, O: 'static> TupleIndex<TupleIndex0> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    A: Clone, 

type Value = A

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static, O: 'static> TupleIndex<TupleIndex1> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    B: Clone, 

type Value = B

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static, O: 'static> TupleIndex<TupleIndex2> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    C: Clone, 

type Value = C

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static, O: 'static> TupleIndex<TupleIndex3> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    D: Clone, 

type Value = D

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static, O: 'static> TupleIndex<TupleIndex4> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    E: Clone, 

type Value = E

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static, O: 'static> TupleIndex<TupleIndex5> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    F: Clone, 

type Value = F

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static, O: 'static> TupleIndex<TupleIndex6> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    G: Clone, 

type Value = G

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static, O: 'static> TupleIndex<TupleIndex7> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    H: Clone, 

type Value = H

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static, O: 'static> TupleIndex<TupleIndex8> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    I: Clone, 

type Value = I

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static, O: 'static> TupleIndex<TupleIndex9> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    J: Clone, 

type Value = J

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static, O: 'static> TupleIndex<TupleIndex10> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    K: Clone, 

type Value = K

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static, O: 'static> TupleIndex<TupleIndex11> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    L: Clone, 

type Value = L

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static, O: 'static> TupleIndex<TupleIndex12> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    M: Clone, 

type Value = M

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static, O: 'static> TupleIndex<TupleIndex13> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    N: Clone, 

type Value = N

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static, O: 'static> TupleIndex<TupleIndex14> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) where
    O: Clone, 

type Value = O

fn get(&self) -> Self::Value

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO> TupleIndex<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    SO: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<A>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<B>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<C>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<N>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<O>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<A>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<B>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<N>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<O>>::Value)

fn get(&self) -> Self::Value

impl<B, C, D, E, F, G, H, I, J, K, L, M, N, O, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO> TupleIndex<(B, C, D, E, F, G, H, I, J, K, L, M, N, O)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    SO: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<B>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<C>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<N>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<O>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<B>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<N>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<O>>::Value)

fn get(&self) -> Self::Value

impl<C, D, E, F, G, H, I, J, K, L, M, N, O, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO> TupleIndex<(C, D, E, F, G, H, I, J, K, L, M, N, O)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    SO: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<C>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<N>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<O>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<N>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<O>>::Value)

fn get(&self) -> Self::Value

impl<D, E, F, G, H, I, J, K, L, M, N, O, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO> TupleIndex<(D, E, F, G, H, I, J, K, L, M, N, O)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    SO: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<N>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<O>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<N>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<O>>::Value)

fn get(&self) -> Self::Value

impl<E, F, G, H, I, J, K, L, M, N, O, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO> TupleIndex<(E, F, G, H, I, J, K, L, M, N, O)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    SO: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<N>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<O>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<N>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<O>>::Value)

fn get(&self) -> Self::Value

impl<F, G, H, I, J, K, L, M, N, O, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO> TupleIndex<(F, G, H, I, J, K, L, M, N, O)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    SO: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<N>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<O>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<N>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<O>>::Value)

fn get(&self) -> Self::Value

impl<G, H, I, J, K, L, M, N, O, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO> TupleIndex<(G, H, I, J, K, L, M, N, O)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    SO: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<N>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<O>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<N>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<O>>::Value)

fn get(&self) -> Self::Value

impl<H, I, J, K, L, M, N, O, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO> TupleIndex<(H, I, J, K, L, M, N, O)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    SO: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<N>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<O>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<N>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<O>>::Value)

fn get(&self) -> Self::Value

impl<I, J, K, L, M, N, O, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO> TupleIndex<(I, J, K, L, M, N, O)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    SO: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<N>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<O>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<N>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<O>>::Value)

fn get(&self) -> Self::Value

impl<J, K, L, M, N, O, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO> TupleIndex<(J, K, L, M, N, O)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    SO: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<N>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<O>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<N>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<O>>::Value)

fn get(&self) -> Self::Value

impl<K, L, M, N, O, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO> TupleIndex<(K, L, M, N, O)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    SO: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<N>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<O>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<N>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<O>>::Value)

fn get(&self) -> Self::Value

impl<L, M, N, O, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO> TupleIndex<(L, M, N, O)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    SO: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<N>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<O>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<N>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<O>>::Value)

fn get(&self) -> Self::Value

impl<M, N, O, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO> TupleIndex<(M, N, O)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    SO: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<N>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<O>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<N>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<O>>::Value)

fn get(&self) -> Self::Value

impl<N, O, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO> TupleIndex<(N, O)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    SO: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<N>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<O>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<N>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<O>>::Value)

fn get(&self) -> Self::Value

impl<O, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO> TupleIndex<(O,)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    SO: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO): TupleIndex<O>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO) as TupleIndex<O>>::Value,)

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static, O: 'static, P: 'static> TupleIndex<TupleIndex0> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    A: Clone, 

type Value = A

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static, O: 'static, P: 'static> TupleIndex<TupleIndex1> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    B: Clone, 

type Value = B

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static, O: 'static, P: 'static> TupleIndex<TupleIndex2> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    C: Clone, 

type Value = C

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static, O: 'static, P: 'static> TupleIndex<TupleIndex3> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    D: Clone, 

type Value = D

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static, O: 'static, P: 'static> TupleIndex<TupleIndex4> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    E: Clone, 

type Value = E

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static, O: 'static, P: 'static> TupleIndex<TupleIndex5> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    F: Clone, 

type Value = F

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static, O: 'static, P: 'static> TupleIndex<TupleIndex6> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    G: Clone, 

type Value = G

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static, O: 'static, P: 'static> TupleIndex<TupleIndex7> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    H: Clone, 

type Value = H

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static, O: 'static, P: 'static> TupleIndex<TupleIndex8> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    I: Clone, 

type Value = I

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static, O: 'static, P: 'static> TupleIndex<TupleIndex9> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    J: Clone, 

type Value = J

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static, O: 'static, P: 'static> TupleIndex<TupleIndex10> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    K: Clone, 

type Value = K

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static, O: 'static, P: 'static> TupleIndex<TupleIndex11> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    L: Clone, 

type Value = L

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static, O: 'static, P: 'static> TupleIndex<TupleIndex12> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    M: Clone, 

type Value = M

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static, O: 'static, P: 'static> TupleIndex<TupleIndex13> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    N: Clone, 

type Value = N

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static, O: 'static, P: 'static> TupleIndex<TupleIndex14> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    O: Clone, 

type Value = O

fn get(&self) -> Self::Value

impl<'a, A: 'static, B: 'static, C: 'static, D: 'static, E: 'static, F: 'static, G: 'static, H: 'static, I: 'static, J: 'static, K: 'static, L: 'static, M: 'static, N: 'static, O: 'static, P: 'static> TupleIndex<TupleIndex15> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) where
    P: Clone, 

type Value = P

fn get(&self) -> Self::Value

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP> TupleIndex<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    SO: 'static,
    SP: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<A>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<B>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<C>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<N>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<O>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<P>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<A>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<B>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<N>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<O>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<P>>::Value)

fn get(&self) -> Self::Value

impl<B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP> TupleIndex<(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    SO: 'static,
    SP: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<B>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<C>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<N>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<O>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<P>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<B>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<N>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<O>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<P>>::Value)

fn get(&self) -> Self::Value

impl<C, D, E, F, G, H, I, J, K, L, M, N, O, P, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP> TupleIndex<(C, D, E, F, G, H, I, J, K, L, M, N, O, P)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    SO: 'static,
    SP: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<C>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<N>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<O>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<P>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<C>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<N>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<O>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<P>>::Value)

fn get(&self) -> Self::Value

impl<D, E, F, G, H, I, J, K, L, M, N, O, P, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP> TupleIndex<(D, E, F, G, H, I, J, K, L, M, N, O, P)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    SO: 'static,
    SP: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<D>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<N>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<O>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<P>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<D>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<N>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<O>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<P>>::Value)

fn get(&self) -> Self::Value

impl<E, F, G, H, I, J, K, L, M, N, O, P, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP> TupleIndex<(E, F, G, H, I, J, K, L, M, N, O, P)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    SO: 'static,
    SP: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<E>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<N>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<O>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<P>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<E>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<N>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<O>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<P>>::Value)

fn get(&self) -> Self::Value

impl<F, G, H, I, J, K, L, M, N, O, P, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP> TupleIndex<(F, G, H, I, J, K, L, M, N, O, P)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    SO: 'static,
    SP: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<F>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<N>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<O>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<P>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<F>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<N>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<O>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<P>>::Value)

fn get(&self) -> Self::Value

impl<G, H, I, J, K, L, M, N, O, P, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP> TupleIndex<(G, H, I, J, K, L, M, N, O, P)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    SO: 'static,
    SP: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<G>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<N>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<O>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<P>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<G>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<N>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<O>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<P>>::Value)

fn get(&self) -> Self::Value

impl<H, I, J, K, L, M, N, O, P, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP> TupleIndex<(H, I, J, K, L, M, N, O, P)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    SO: 'static,
    SP: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<H>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<N>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<O>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<P>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<H>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<N>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<O>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<P>>::Value)

fn get(&self) -> Self::Value

impl<I, J, K, L, M, N, O, P, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP> TupleIndex<(I, J, K, L, M, N, O, P)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    SO: 'static,
    SP: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<I>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<N>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<O>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<P>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<I>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<N>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<O>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<P>>::Value)

fn get(&self) -> Self::Value

impl<J, K, L, M, N, O, P, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP> TupleIndex<(J, K, L, M, N, O, P)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    SO: 'static,
    SP: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<J>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<N>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<O>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<P>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<J>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<N>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<O>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<P>>::Value)

fn get(&self) -> Self::Value

impl<K, L, M, N, O, P, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP> TupleIndex<(K, L, M, N, O, P)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    SO: 'static,
    SP: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<K>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<N>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<O>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<P>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<K>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<N>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<O>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<P>>::Value)

fn get(&self) -> Self::Value

impl<L, M, N, O, P, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP> TupleIndex<(L, M, N, O, P)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    SO: 'static,
    SP: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<L>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<N>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<O>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<P>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<L>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<N>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<O>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<P>>::Value)

fn get(&self) -> Self::Value

impl<M, N, O, P, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP> TupleIndex<(M, N, O, P)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    SO: 'static,
    SP: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<M>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<N>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<O>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<P>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<M>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<N>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<O>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<P>>::Value)

fn get(&self) -> Self::Value

impl<N, O, P, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP> TupleIndex<(N, O, P)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    SO: 'static,
    SP: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<N>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<O>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<P>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<N>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<O>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<P>>::Value)

fn get(&self) -> Self::Value

impl<O, P, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP> TupleIndex<(O, P)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    SO: 'static,
    SP: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<O>,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<P>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<O>>::Value, <(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<P>>::Value)

fn get(&self) -> Self::Value

impl<P, SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP> TupleIndex<(P,)> for (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) where
    SA: 'static,
    SB: 'static,
    SC: 'static,
    SD: 'static,
    SE: 'static,
    SF: 'static,
    SG: 'static,
    SH: 'static,
    SI: 'static,
    SJ: 'static,
    SK: 'static,
    SL: 'static,
    SM: 'static,
    SN: 'static,
    SO: 'static,
    SP: 'static,
    (SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP): TupleIndex<P>, 

type Value = (<(SA, SB, SC, SD, SE, SF, SG, SH, SI, SJ, SK, SL, SM, SN, SO, SP) as TupleIndex<P>>::Value,)

fn get(&self) -> Self::Value

Loading content...

Implementors

Loading content...