tuples 1.20.1

// auto generated code, do not modify

impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, T) -> U> TupleUniformMapperBy<(T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: (T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), input.0), (&mut self)(arg.pass(), input.1))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &T) -> U> TupleUniformMapperBy<&(T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &(T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &input.0), (&mut self)(arg.pass(), &input.1))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &mut T) -> U> TupleUniformMapperBy<&mut (T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &mut (T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &mut input.0), (&mut self)(arg.pass(), &mut input.1))
    }
}
impl<A, U, T0, T1, F0: for<'s> FnOnce(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, T1) -> U> TupleUniformMapperBy<(T0, T1), U, A> for (F0, F1)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1))
    }
}
impl<A, U, T0, T1, F0: for<'s> FnMut(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, T1) -> U> TupleUniformMapperBy<(T0, T1), U, A> for &mut (F0, F1)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1))
    }
}
impl<A, U, T0, T1, F0: for<'s> Fn(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, T1) -> U> TupleUniformMapperBy<(T0, T1), U, A> for &(F0, F1)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1))
    }
}
impl<A, U, T0, T1, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &T1) -> U> TupleUniformMapperBy<&(T0, T1), U, A> for (F0, F1)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1))
    }
}
impl<A, U, T0, T1, F0: for<'s> FnMut(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &T1) -> U> TupleUniformMapperBy<&(T0, T1), U, A> for &mut (F0, F1)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1))
    }
}
impl<A, U, T0, T1, F0: for<'s> Fn(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &T1) -> U> TupleUniformMapperBy<&(T0, T1), U, A> for &(F0, F1)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1))
    }
}
impl<A, U, T0, T1, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T1) -> U> TupleUniformMapperBy<&mut (T0, T1), U, A> for (F0, F1)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1))
    }
}
impl<A, U, T0, T1, F0: for<'s> FnMut(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &mut T1) -> U> TupleUniformMapperBy<&mut (T0, T1), U, A> for &mut (F0, F1)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1))
    }
}
impl<A, U, T0, T1, F0: for<'s> Fn(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &mut T1) -> U> TupleUniformMapperBy<&mut (T0, T1), U, A> for &(F0, F1)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, T) -> U> TupleUniformMapperBy<(T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: (T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), input.0), (&mut self)(arg.pass(), input.1), (&mut self)(arg.pass(), input.2))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &T) -> U> TupleUniformMapperBy<&(T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &(T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &input.0), (&mut self)(arg.pass(), &input.1), (&mut self)(arg.pass(), &input.2))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &mut T) -> U> TupleUniformMapperBy<&mut (T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &mut (T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &mut input.0), (&mut self)(arg.pass(), &mut input.1), (&mut self)(arg.pass(), &mut input.2))
    }
}
impl<A, U, T0, T1, T2, F0: for<'s> FnOnce(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, T2) -> U> TupleUniformMapperBy<(T0, T1, T2), U, A> for (F0, F1, F2)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2))
    }
}
impl<A, U, T0, T1, T2, F0: for<'s> FnMut(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, T2) -> U> TupleUniformMapperBy<(T0, T1, T2), U, A> for &mut (F0, F1, F2)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2))
    }
}
impl<A, U, T0, T1, T2, F0: for<'s> Fn(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, T2) -> U> TupleUniformMapperBy<(T0, T1, T2), U, A> for &(F0, F1, F2)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2))
    }
}
impl<A, U, T0, T1, T2, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &T2) -> U> TupleUniformMapperBy<&(T0, T1, T2), U, A> for (F0, F1, F2)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2))
    }
}
impl<A, U, T0, T1, T2, F0: for<'s> FnMut(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &T2) -> U> TupleUniformMapperBy<&(T0, T1, T2), U, A> for &mut (F0, F1, F2)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2))
    }
}
impl<A, U, T0, T1, T2, F0: for<'s> Fn(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &T2) -> U> TupleUniformMapperBy<&(T0, T1, T2), U, A> for &(F0, F1, F2)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2))
    }
}
impl<A, U, T0, T1, T2, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T2) -> U> TupleUniformMapperBy<&mut (T0, T1, T2), U, A> for (F0, F1, F2)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2))
    }
}
impl<A, U, T0, T1, T2, F0: for<'s> FnMut(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &mut T2) -> U> TupleUniformMapperBy<&mut (T0, T1, T2), U, A> for &mut (F0, F1, F2)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2))
    }
}
impl<A, U, T0, T1, T2, F0: for<'s> Fn(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &mut T2) -> U> TupleUniformMapperBy<&mut (T0, T1, T2), U, A> for &(F0, F1, F2)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, T) -> U> TupleUniformMapperBy<(T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: (T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), input.0), (&mut self)(arg.pass(), input.1), (&mut self)(arg.pass(), input.2), (&mut self)(arg.pass(), input.3))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &T) -> U> TupleUniformMapperBy<&(T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &(T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &input.0), (&mut self)(arg.pass(), &input.1), (&mut self)(arg.pass(), &input.2), (&mut self)(arg.pass(), &input.3))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &mut T) -> U> TupleUniformMapperBy<&mut (T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &mut (T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &mut input.0), (&mut self)(arg.pass(), &mut input.1), (&mut self)(arg.pass(), &mut input.2), (&mut self)(arg.pass(), &mut input.3))
    }
}
impl<A, U, T0, T1, T2, T3, F0: for<'s> FnOnce(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, T3) -> U> TupleUniformMapperBy<(T0, T1, T2, T3), U, A> for (F0, F1, F2, F3)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3))
    }
}
impl<A, U, T0, T1, T2, T3, F0: for<'s> FnMut(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, T3) -> U> TupleUniformMapperBy<(T0, T1, T2, T3), U, A> for &mut (F0, F1, F2, F3)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3))
    }
}
impl<A, U, T0, T1, T2, T3, F0: for<'s> Fn(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, T3) -> U> TupleUniformMapperBy<(T0, T1, T2, T3), U, A> for &(F0, F1, F2, F3)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3))
    }
}
impl<A, U, T0, T1, T2, T3, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &T3) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3), U, A> for (F0, F1, F2, F3)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3))
    }
}
impl<A, U, T0, T1, T2, T3, F0: for<'s> FnMut(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &T3) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3), U, A> for &mut (F0, F1, F2, F3)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3))
    }
}
impl<A, U, T0, T1, T2, T3, F0: for<'s> Fn(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &T3) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3), U, A> for &(F0, F1, F2, F3)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3))
    }
}
impl<A, U, T0, T1, T2, T3, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T3) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3), U, A> for (F0, F1, F2, F3)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3))
    }
}
impl<A, U, T0, T1, T2, T3, F0: for<'s> FnMut(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &mut T3) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3), U, A> for &mut (F0, F1, F2, F3)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3))
    }
}
impl<A, U, T0, T1, T2, T3, F0: for<'s> Fn(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &mut T3) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3), U, A> for &(F0, F1, F2, F3)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, T) -> U> TupleUniformMapperBy<(T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: (T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), input.0), (&mut self)(arg.pass(), input.1), (&mut self)(arg.pass(), input.2), (&mut self)(arg.pass(), input.3), (&mut self)(arg.pass(), input.4))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &T) -> U> TupleUniformMapperBy<&(T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &(T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &input.0), (&mut self)(arg.pass(), &input.1), (&mut self)(arg.pass(), &input.2), (&mut self)(arg.pass(), &input.3), (&mut self)(arg.pass(), &input.4))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &mut T) -> U> TupleUniformMapperBy<&mut (T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &mut (T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &mut input.0), (&mut self)(arg.pass(), &mut input.1), (&mut self)(arg.pass(), &mut input.2), (&mut self)(arg.pass(), &mut input.3), (&mut self)(arg.pass(), &mut input.4))
    }
}
impl<A, U, T0, T1, T2, T3, T4, F0: for<'s> FnOnce(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, T4) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4), U, A> for (F0, F1, F2, F3, F4)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4))
    }
}
impl<A, U, T0, T1, T2, T3, T4, F0: for<'s> FnMut(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, T4) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4), U, A> for &mut (F0, F1, F2, F3, F4)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4))
    }
}
impl<A, U, T0, T1, T2, T3, T4, F0: for<'s> Fn(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, T4) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4), U, A> for &(F0, F1, F2, F3, F4)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4))
    }
}
impl<A, U, T0, T1, T2, T3, T4, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &T4) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4), U, A> for (F0, F1, F2, F3, F4)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4))
    }
}
impl<A, U, T0, T1, T2, T3, T4, F0: for<'s> FnMut(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &T4) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4), U, A> for &mut (F0, F1, F2, F3, F4)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4))
    }
}
impl<A, U, T0, T1, T2, T3, T4, F0: for<'s> Fn(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &T4) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4), U, A> for &(F0, F1, F2, F3, F4)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4))
    }
}
impl<A, U, T0, T1, T2, T3, T4, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T4) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4), U, A> for (F0, F1, F2, F3, F4)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4))
    }
}
impl<A, U, T0, T1, T2, T3, T4, F0: for<'s> FnMut(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &mut T4) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4), U, A> for &mut (F0, F1, F2, F3, F4)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4))
    }
}
impl<A, U, T0, T1, T2, T3, T4, F0: for<'s> Fn(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &mut T4) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4), U, A> for &(F0, F1, F2, F3, F4)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, T) -> U> TupleUniformMapperBy<(T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: (T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), input.0), (&mut self)(arg.pass(), input.1), (&mut self)(arg.pass(), input.2), (&mut self)(arg.pass(), input.3), (&mut self)(arg.pass(), input.4), (&mut self)(arg.pass(), input.5))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &T) -> U> TupleUniformMapperBy<&(T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &(T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &input.0), (&mut self)(arg.pass(), &input.1), (&mut self)(arg.pass(), &input.2), (&mut self)(arg.pass(), &input.3), (&mut self)(arg.pass(), &input.4), (&mut self)(arg.pass(), &input.5))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &mut T) -> U> TupleUniformMapperBy<&mut (T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &mut (T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &mut input.0), (&mut self)(arg.pass(), &mut input.1), (&mut self)(arg.pass(), &mut input.2), (&mut self)(arg.pass(), &mut input.3), (&mut self)(arg.pass(), &mut input.4), (&mut self)(arg.pass(), &mut input.5))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, F0: for<'s> FnOnce(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, T5) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5), U, A> for (F0, F1, F2, F3, F4, F5)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, F0: for<'s> FnMut(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, T5) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5), U, A> for &mut (F0, F1, F2, F3, F4, F5)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, F0: for<'s> Fn(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, T5) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5), U, A> for &(F0, F1, F2, F3, F4, F5)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &T5) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5), U, A> for (F0, F1, F2, F3, F4, F5)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, F0: for<'s> FnMut(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &T5) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5), U, A> for &mut (F0, F1, F2, F3, F4, F5)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, F0: for<'s> Fn(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &T5) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5), U, A> for &(F0, F1, F2, F3, F4, F5)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T5) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5), U, A> for (F0, F1, F2, F3, F4, F5)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, F0: for<'s> FnMut(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &mut T5) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5), U, A> for &mut (F0, F1, F2, F3, F4, F5)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, F0: for<'s> Fn(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &mut T5) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5), U, A> for &(F0, F1, F2, F3, F4, F5)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, T) -> U> TupleUniformMapperBy<(T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: (T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), input.0), (&mut self)(arg.pass(), input.1), (&mut self)(arg.pass(), input.2), (&mut self)(arg.pass(), input.3), (&mut self)(arg.pass(), input.4), (&mut self)(arg.pass(), input.5), (&mut self)(arg.pass(), input.6))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &T) -> U> TupleUniformMapperBy<&(T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &(T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &input.0), (&mut self)(arg.pass(), &input.1), (&mut self)(arg.pass(), &input.2), (&mut self)(arg.pass(), &input.3), (&mut self)(arg.pass(), &input.4), (&mut self)(arg.pass(), &input.5), (&mut self)(arg.pass(), &input.6))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &mut T) -> U> TupleUniformMapperBy<&mut (T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &mut (T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &mut input.0), (&mut self)(arg.pass(), &mut input.1), (&mut self)(arg.pass(), &mut input.2), (&mut self)(arg.pass(), &mut input.3), (&mut self)(arg.pass(), &mut input.4), (&mut self)(arg.pass(), &mut input.5), (&mut self)(arg.pass(), &mut input.6))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, F0: for<'s> FnOnce(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, T6) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6), U, A> for (F0, F1, F2, F3, F4, F5, F6)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, F0: for<'s> FnMut(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, T6) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, F0: for<'s> Fn(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, T6) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6), U, A> for &(F0, F1, F2, F3, F4, F5, F6)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &T6) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6), U, A> for (F0, F1, F2, F3, F4, F5, F6)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, F0: for<'s> FnMut(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &T6) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, F0: for<'s> Fn(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &T6) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6), U, A> for &(F0, F1, F2, F3, F4, F5, F6)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T6) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6), U, A> for (F0, F1, F2, F3, F4, F5, F6)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, F0: for<'s> FnMut(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &mut T6) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, F0: for<'s> Fn(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &mut T6) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6), U, A> for &(F0, F1, F2, F3, F4, F5, F6)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, T) -> U> TupleUniformMapperBy<(T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: (T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), input.0), (&mut self)(arg.pass(), input.1), (&mut self)(arg.pass(), input.2), (&mut self)(arg.pass(), input.3), (&mut self)(arg.pass(), input.4), (&mut self)(arg.pass(), input.5), (&mut self)(arg.pass(), input.6), (&mut self)(arg.pass(), input.7))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &T) -> U> TupleUniformMapperBy<&(T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &(T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &input.0), (&mut self)(arg.pass(), &input.1), (&mut self)(arg.pass(), &input.2), (&mut self)(arg.pass(), &input.3), (&mut self)(arg.pass(), &input.4), (&mut self)(arg.pass(), &input.5), (&mut self)(arg.pass(), &input.6), (&mut self)(arg.pass(), &input.7))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &mut T) -> U> TupleUniformMapperBy<&mut (T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &mut (T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &mut input.0), (&mut self)(arg.pass(), &mut input.1), (&mut self)(arg.pass(), &mut input.2), (&mut self)(arg.pass(), &mut input.3), (&mut self)(arg.pass(), &mut input.4), (&mut self)(arg.pass(), &mut input.5), (&mut self)(arg.pass(), &mut input.6), (&mut self)(arg.pass(), &mut input.7))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, F0: for<'s> FnOnce(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, T7) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, F0: for<'s> FnMut(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, T7) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, F0: for<'s> Fn(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, T7) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &T7) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, F0: for<'s> FnMut(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &T7) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, F0: for<'s> Fn(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &T7) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T7) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, F0: for<'s> FnMut(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &mut T7) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, F0: for<'s> Fn(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &mut T7) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, T) -> U> TupleUniformMapperBy<(T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: (T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), input.0), (&mut self)(arg.pass(), input.1), (&mut self)(arg.pass(), input.2), (&mut self)(arg.pass(), input.3), (&mut self)(arg.pass(), input.4), (&mut self)(arg.pass(), input.5), (&mut self)(arg.pass(), input.6), (&mut self)(arg.pass(), input.7), (&mut self)(arg.pass(), input.8))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &T) -> U> TupleUniformMapperBy<&(T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &(T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &input.0), (&mut self)(arg.pass(), &input.1), (&mut self)(arg.pass(), &input.2), (&mut self)(arg.pass(), &input.3), (&mut self)(arg.pass(), &input.4), (&mut self)(arg.pass(), &input.5), (&mut self)(arg.pass(), &input.6), (&mut self)(arg.pass(), &input.7), (&mut self)(arg.pass(), &input.8))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &mut T) -> U> TupleUniformMapperBy<&mut (T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &mut (T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &mut input.0), (&mut self)(arg.pass(), &mut input.1), (&mut self)(arg.pass(), &mut input.2), (&mut self)(arg.pass(), &mut input.3), (&mut self)(arg.pass(), &mut input.4), (&mut self)(arg.pass(), &mut input.5), (&mut self)(arg.pass(), &mut input.6), (&mut self)(arg.pass(), &mut input.7), (&mut self)(arg.pass(), &mut input.8))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, F0: for<'s> FnOnce(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, T8) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, F0: for<'s> FnMut(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, T8) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, F0: for<'s> Fn(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, T8) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &T8) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, F0: for<'s> FnMut(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &T8) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, F0: for<'s> Fn(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &T8) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T8) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, F0: for<'s> FnMut(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &mut T8) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, F0: for<'s> Fn(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &mut T8) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, T) -> U> TupleUniformMapperBy<(T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: (T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), input.0), (&mut self)(arg.pass(), input.1), (&mut self)(arg.pass(), input.2), (&mut self)(arg.pass(), input.3), (&mut self)(arg.pass(), input.4), (&mut self)(arg.pass(), input.5), (&mut self)(arg.pass(), input.6), (&mut self)(arg.pass(), input.7), (&mut self)(arg.pass(), input.8), (&mut self)(arg.pass(), input.9))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &T) -> U> TupleUniformMapperBy<&(T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &(T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &input.0), (&mut self)(arg.pass(), &input.1), (&mut self)(arg.pass(), &input.2), (&mut self)(arg.pass(), &input.3), (&mut self)(arg.pass(), &input.4), (&mut self)(arg.pass(), &input.5), (&mut self)(arg.pass(), &input.6), (&mut self)(arg.pass(), &input.7), (&mut self)(arg.pass(), &input.8), (&mut self)(arg.pass(), &input.9))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &mut T) -> U> TupleUniformMapperBy<&mut (T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &mut (T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &mut input.0), (&mut self)(arg.pass(), &mut input.1), (&mut self)(arg.pass(), &mut input.2), (&mut self)(arg.pass(), &mut input.3), (&mut self)(arg.pass(), &mut input.4), (&mut self)(arg.pass(), &mut input.5), (&mut self)(arg.pass(), &mut input.6), (&mut self)(arg.pass(), &mut input.7), (&mut self)(arg.pass(), &mut input.8), (&mut self)(arg.pass(), &mut input.9))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, F0: for<'s> FnOnce(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, T9) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, F0: for<'s> FnMut(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, T9) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, F0: for<'s> Fn(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, T9) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &T9) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, F0: for<'s> FnMut(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &T9) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, F0: for<'s> Fn(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &T9) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T9) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, F0: for<'s> FnMut(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &mut T9) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, F0: for<'s> Fn(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &mut T9) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, T) -> U> TupleUniformMapperBy<(T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: (T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), input.0), (&mut self)(arg.pass(), input.1), (&mut self)(arg.pass(), input.2), (&mut self)(arg.pass(), input.3), (&mut self)(arg.pass(), input.4), (&mut self)(arg.pass(), input.5), (&mut self)(arg.pass(), input.6), (&mut self)(arg.pass(), input.7), (&mut self)(arg.pass(), input.8), (&mut self)(arg.pass(), input.9), (&mut self)(arg.pass(), input.10))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &T) -> U> TupleUniformMapperBy<&(T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &(T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &input.0), (&mut self)(arg.pass(), &input.1), (&mut self)(arg.pass(), &input.2), (&mut self)(arg.pass(), &input.3), (&mut self)(arg.pass(), &input.4), (&mut self)(arg.pass(), &input.5), (&mut self)(arg.pass(), &input.6), (&mut self)(arg.pass(), &input.7), (&mut self)(arg.pass(), &input.8), (&mut self)(arg.pass(), &input.9), (&mut self)(arg.pass(), &input.10))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &mut T) -> U> TupleUniformMapperBy<&mut (T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &mut (T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &mut input.0), (&mut self)(arg.pass(), &mut input.1), (&mut self)(arg.pass(), &mut input.2), (&mut self)(arg.pass(), &mut input.3), (&mut self)(arg.pass(), &mut input.4), (&mut self)(arg.pass(), &mut input.5), (&mut self)(arg.pass(), &mut input.6), (&mut self)(arg.pass(), &mut input.7), (&mut self)(arg.pass(), &mut input.8), (&mut self)(arg.pass(), &mut input.9), (&mut self)(arg.pass(), &mut input.10))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, F0: for<'s> FnOnce(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, T10) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, F0: for<'s> FnMut(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, T10) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, F0: for<'s> Fn(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, T10) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &T10) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, F0: for<'s> FnMut(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &T10) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, F0: for<'s> Fn(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &T10) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T10) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, F0: for<'s> FnMut(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &mut T10) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, F0: for<'s> Fn(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &mut T10) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, T) -> U> TupleUniformMapperBy<(T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: (T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), input.0), (&mut self)(arg.pass(), input.1), (&mut self)(arg.pass(), input.2), (&mut self)(arg.pass(), input.3), (&mut self)(arg.pass(), input.4), (&mut self)(arg.pass(), input.5), (&mut self)(arg.pass(), input.6), (&mut self)(arg.pass(), input.7), (&mut self)(arg.pass(), input.8), (&mut self)(arg.pass(), input.9), (&mut self)(arg.pass(), input.10), (&mut self)(arg.pass(), input.11))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &T) -> U> TupleUniformMapperBy<&(T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &(T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &input.0), (&mut self)(arg.pass(), &input.1), (&mut self)(arg.pass(), &input.2), (&mut self)(arg.pass(), &input.3), (&mut self)(arg.pass(), &input.4), (&mut self)(arg.pass(), &input.5), (&mut self)(arg.pass(), &input.6), (&mut self)(arg.pass(), &input.7), (&mut self)(arg.pass(), &input.8), (&mut self)(arg.pass(), &input.9), (&mut self)(arg.pass(), &input.10), (&mut self)(arg.pass(), &input.11))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &mut T) -> U> TupleUniformMapperBy<&mut (T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &mut (T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &mut input.0), (&mut self)(arg.pass(), &mut input.1), (&mut self)(arg.pass(), &mut input.2), (&mut self)(arg.pass(), &mut input.3), (&mut self)(arg.pass(), &mut input.4), (&mut self)(arg.pass(), &mut input.5), (&mut self)(arg.pass(), &mut input.6), (&mut self)(arg.pass(), &mut input.7), (&mut self)(arg.pass(), &mut input.8), (&mut self)(arg.pass(), &mut input.9), (&mut self)(arg.pass(), &mut input.10), (&mut self)(arg.pass(), &mut input.11))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, F0: for<'s> FnOnce(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, T11) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, F0: for<'s> FnMut(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, T11) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, F0: for<'s> Fn(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, T11) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &T11) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, F0: for<'s> FnMut(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &T11) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, F0: for<'s> Fn(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &T11) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T11) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, F0: for<'s> FnMut(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &mut T11) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, F0: for<'s> Fn(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &mut T11) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, T) -> U> TupleUniformMapperBy<(T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: (T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), input.0), (&mut self)(arg.pass(), input.1), (&mut self)(arg.pass(), input.2), (&mut self)(arg.pass(), input.3), (&mut self)(arg.pass(), input.4), (&mut self)(arg.pass(), input.5), (&mut self)(arg.pass(), input.6), (&mut self)(arg.pass(), input.7), (&mut self)(arg.pass(), input.8), (&mut self)(arg.pass(), input.9), (&mut self)(arg.pass(), input.10), (&mut self)(arg.pass(), input.11), (&mut self)(arg.pass(), input.12))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &T) -> U> TupleUniformMapperBy<&(T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &(T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &input.0), (&mut self)(arg.pass(), &input.1), (&mut self)(arg.pass(), &input.2), (&mut self)(arg.pass(), &input.3), (&mut self)(arg.pass(), &input.4), (&mut self)(arg.pass(), &input.5), (&mut self)(arg.pass(), &input.6), (&mut self)(arg.pass(), &input.7), (&mut self)(arg.pass(), &input.8), (&mut self)(arg.pass(), &input.9), (&mut self)(arg.pass(), &input.10), (&mut self)(arg.pass(), &input.11), (&mut self)(arg.pass(), &input.12))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &mut T) -> U> TupleUniformMapperBy<&mut (T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &mut (T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &mut input.0), (&mut self)(arg.pass(), &mut input.1), (&mut self)(arg.pass(), &mut input.2), (&mut self)(arg.pass(), &mut input.3), (&mut self)(arg.pass(), &mut input.4), (&mut self)(arg.pass(), &mut input.5), (&mut self)(arg.pass(), &mut input.6), (&mut self)(arg.pass(), &mut input.7), (&mut self)(arg.pass(), &mut input.8), (&mut self)(arg.pass(), &mut input.9), (&mut self)(arg.pass(), &mut input.10), (&mut self)(arg.pass(), &mut input.11), (&mut self)(arg.pass(), &mut input.12))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, F0: for<'s> FnOnce(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, T12) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, F0: for<'s> FnMut(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, T12) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, F0: for<'s> Fn(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, T12) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &T12) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, F0: for<'s> FnMut(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &T12) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, F0: for<'s> Fn(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &T12) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T12) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, F0: for<'s> FnMut(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &mut T12) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, F0: for<'s> Fn(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &mut T12) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, T) -> U> TupleUniformMapperBy<(T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: (T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), input.0), (&mut self)(arg.pass(), input.1), (&mut self)(arg.pass(), input.2), (&mut self)(arg.pass(), input.3), (&mut self)(arg.pass(), input.4), (&mut self)(arg.pass(), input.5), (&mut self)(arg.pass(), input.6), (&mut self)(arg.pass(), input.7), (&mut self)(arg.pass(), input.8), (&mut self)(arg.pass(), input.9), (&mut self)(arg.pass(), input.10), (&mut self)(arg.pass(), input.11), (&mut self)(arg.pass(), input.12), (&mut self)(arg.pass(), input.13))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &T) -> U> TupleUniformMapperBy<&(T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &(T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &input.0), (&mut self)(arg.pass(), &input.1), (&mut self)(arg.pass(), &input.2), (&mut self)(arg.pass(), &input.3), (&mut self)(arg.pass(), &input.4), (&mut self)(arg.pass(), &input.5), (&mut self)(arg.pass(), &input.6), (&mut self)(arg.pass(), &input.7), (&mut self)(arg.pass(), &input.8), (&mut self)(arg.pass(), &input.9), (&mut self)(arg.pass(), &input.10), (&mut self)(arg.pass(), &input.11), (&mut self)(arg.pass(), &input.12), (&mut self)(arg.pass(), &input.13))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &mut T) -> U> TupleUniformMapperBy<&mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &mut input.0), (&mut self)(arg.pass(), &mut input.1), (&mut self)(arg.pass(), &mut input.2), (&mut self)(arg.pass(), &mut input.3), (&mut self)(arg.pass(), &mut input.4), (&mut self)(arg.pass(), &mut input.5), (&mut self)(arg.pass(), &mut input.6), (&mut self)(arg.pass(), &mut input.7), (&mut self)(arg.pass(), &mut input.8), (&mut self)(arg.pass(), &mut input.9), (&mut self)(arg.pass(), &mut input.10), (&mut self)(arg.pass(), &mut input.11), (&mut self)(arg.pass(), &mut input.12), (&mut self)(arg.pass(), &mut input.13))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, F0: for<'s> FnOnce(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, T13) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, F0: for<'s> FnMut(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, T13) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, F0: for<'s> Fn(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, T13) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &T13) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, F0: for<'s> FnMut(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &T13) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, F0: for<'s> Fn(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &T13) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T13) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, F0: for<'s> FnMut(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &mut T13) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, F0: for<'s> Fn(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &mut T13) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, T) -> U> TupleUniformMapperBy<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), input.0), (&mut self)(arg.pass(), input.1), (&mut self)(arg.pass(), input.2), (&mut self)(arg.pass(), input.3), (&mut self)(arg.pass(), input.4), (&mut self)(arg.pass(), input.5), (&mut self)(arg.pass(), input.6), (&mut self)(arg.pass(), input.7), (&mut self)(arg.pass(), input.8), (&mut self)(arg.pass(), input.9), (&mut self)(arg.pass(), input.10), (&mut self)(arg.pass(), input.11), (&mut self)(arg.pass(), input.12), (&mut self)(arg.pass(), input.13), (&mut self)(arg.pass(), input.14))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &T) -> U> TupleUniformMapperBy<&(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &input.0), (&mut self)(arg.pass(), &input.1), (&mut self)(arg.pass(), &input.2), (&mut self)(arg.pass(), &input.3), (&mut self)(arg.pass(), &input.4), (&mut self)(arg.pass(), &input.5), (&mut self)(arg.pass(), &input.6), (&mut self)(arg.pass(), &input.7), (&mut self)(arg.pass(), &input.8), (&mut self)(arg.pass(), &input.9), (&mut self)(arg.pass(), &input.10), (&mut self)(arg.pass(), &input.11), (&mut self)(arg.pass(), &input.12), (&mut self)(arg.pass(), &input.13), (&mut self)(arg.pass(), &input.14))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &mut T) -> U> TupleUniformMapperBy<&mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &mut input.0), (&mut self)(arg.pass(), &mut input.1), (&mut self)(arg.pass(), &mut input.2), (&mut self)(arg.pass(), &mut input.3), (&mut self)(arg.pass(), &mut input.4), (&mut self)(arg.pass(), &mut input.5), (&mut self)(arg.pass(), &mut input.6), (&mut self)(arg.pass(), &mut input.7), (&mut self)(arg.pass(), &mut input.8), (&mut self)(arg.pass(), &mut input.9), (&mut self)(arg.pass(), &mut input.10), (&mut self)(arg.pass(), &mut input.11), (&mut self)(arg.pass(), &mut input.12), (&mut self)(arg.pass(), &mut input.13), (&mut self)(arg.pass(), &mut input.14))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, F0: for<'s> FnOnce(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, T14) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, F0: for<'s> FnMut(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, T14) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, F0: for<'s> Fn(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, T14) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &T14) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, F0: for<'s> FnMut(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &T14) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, F0: for<'s> Fn(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &T14) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T14) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, F0: for<'s> FnMut(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &mut T14) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, F0: for<'s> Fn(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &mut T14) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, T) -> U> TupleUniformMapperBy<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), input.0), (&mut self)(arg.pass(), input.1), (&mut self)(arg.pass(), input.2), (&mut self)(arg.pass(), input.3), (&mut self)(arg.pass(), input.4), (&mut self)(arg.pass(), input.5), (&mut self)(arg.pass(), input.6), (&mut self)(arg.pass(), input.7), (&mut self)(arg.pass(), input.8), (&mut self)(arg.pass(), input.9), (&mut self)(arg.pass(), input.10), (&mut self)(arg.pass(), input.11), (&mut self)(arg.pass(), input.12), (&mut self)(arg.pass(), input.13), (&mut self)(arg.pass(), input.14), (&mut self)(arg.pass(), input.15))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &T) -> U> TupleUniformMapperBy<&(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &input.0), (&mut self)(arg.pass(), &input.1), (&mut self)(arg.pass(), &input.2), (&mut self)(arg.pass(), &input.3), (&mut self)(arg.pass(), &input.4), (&mut self)(arg.pass(), &input.5), (&mut self)(arg.pass(), &input.6), (&mut self)(arg.pass(), &input.7), (&mut self)(arg.pass(), &input.8), (&mut self)(arg.pass(), &input.9), (&mut self)(arg.pass(), &input.10), (&mut self)(arg.pass(), &input.11), (&mut self)(arg.pass(), &input.12), (&mut self)(arg.pass(), &input.13), (&mut self)(arg.pass(), &input.14), (&mut self)(arg.pass(), &input.15))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &mut T) -> U> TupleUniformMapperBy<&mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &mut input.0), (&mut self)(arg.pass(), &mut input.1), (&mut self)(arg.pass(), &mut input.2), (&mut self)(arg.pass(), &mut input.3), (&mut self)(arg.pass(), &mut input.4), (&mut self)(arg.pass(), &mut input.5), (&mut self)(arg.pass(), &mut input.6), (&mut self)(arg.pass(), &mut input.7), (&mut self)(arg.pass(), &mut input.8), (&mut self)(arg.pass(), &mut input.9), (&mut self)(arg.pass(), &mut input.10), (&mut self)(arg.pass(), &mut input.11), (&mut self)(arg.pass(), &mut input.12), (&mut self)(arg.pass(), &mut input.13), (&mut self)(arg.pass(), &mut input.14), (&mut self)(arg.pass(), &mut input.15))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, F0: for<'s> FnOnce(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, T15) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, F0: for<'s> FnMut(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, T15) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, F0: for<'s> Fn(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, T15) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, &T15) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, F0: for<'s> FnMut(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, &T15) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, F0: for<'s> Fn(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, &T15) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T15) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, F0: for<'s> FnMut(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, &mut T15) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, F0: for<'s> Fn(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, &mut T15) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, T) -> U> TupleUniformMapperBy<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), input.0), (&mut self)(arg.pass(), input.1), (&mut self)(arg.pass(), input.2), (&mut self)(arg.pass(), input.3), (&mut self)(arg.pass(), input.4), (&mut self)(arg.pass(), input.5), (&mut self)(arg.pass(), input.6), (&mut self)(arg.pass(), input.7), (&mut self)(arg.pass(), input.8), (&mut self)(arg.pass(), input.9), (&mut self)(arg.pass(), input.10), (&mut self)(arg.pass(), input.11), (&mut self)(arg.pass(), input.12), (&mut self)(arg.pass(), input.13), (&mut self)(arg.pass(), input.14), (&mut self)(arg.pass(), input.15), (&mut self)(arg.pass(), input.16))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &T) -> U> TupleUniformMapperBy<&(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &input.0), (&mut self)(arg.pass(), &input.1), (&mut self)(arg.pass(), &input.2), (&mut self)(arg.pass(), &input.3), (&mut self)(arg.pass(), &input.4), (&mut self)(arg.pass(), &input.5), (&mut self)(arg.pass(), &input.6), (&mut self)(arg.pass(), &input.7), (&mut self)(arg.pass(), &input.8), (&mut self)(arg.pass(), &input.9), (&mut self)(arg.pass(), &input.10), (&mut self)(arg.pass(), &input.11), (&mut self)(arg.pass(), &input.12), (&mut self)(arg.pass(), &input.13), (&mut self)(arg.pass(), &input.14), (&mut self)(arg.pass(), &input.15), (&mut self)(arg.pass(), &input.16))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &mut T) -> U> TupleUniformMapperBy<&mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &mut input.0), (&mut self)(arg.pass(), &mut input.1), (&mut self)(arg.pass(), &mut input.2), (&mut self)(arg.pass(), &mut input.3), (&mut self)(arg.pass(), &mut input.4), (&mut self)(arg.pass(), &mut input.5), (&mut self)(arg.pass(), &mut input.6), (&mut self)(arg.pass(), &mut input.7), (&mut self)(arg.pass(), &mut input.8), (&mut self)(arg.pass(), &mut input.9), (&mut self)(arg.pass(), &mut input.10), (&mut self)(arg.pass(), &mut input.11), (&mut self)(arg.pass(), &mut input.12), (&mut self)(arg.pass(), &mut input.13), (&mut self)(arg.pass(), &mut input.14), (&mut self)(arg.pass(), &mut input.15), (&mut self)(arg.pass(), &mut input.16))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, F0: for<'s> FnOnce(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, T16) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, F0: for<'s> FnMut(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, T16) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, F0: for<'s> Fn(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, T16) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, &T16) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, F0: for<'s> FnMut(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, &T16) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, F0: for<'s> Fn(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, &T16) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T16) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, F0: for<'s> FnMut(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, &mut T16) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, F0: for<'s> Fn(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, &mut T16) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, T) -> U> TupleUniformMapperBy<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), input.0), (&mut self)(arg.pass(), input.1), (&mut self)(arg.pass(), input.2), (&mut self)(arg.pass(), input.3), (&mut self)(arg.pass(), input.4), (&mut self)(arg.pass(), input.5), (&mut self)(arg.pass(), input.6), (&mut self)(arg.pass(), input.7), (&mut self)(arg.pass(), input.8), (&mut self)(arg.pass(), input.9), (&mut self)(arg.pass(), input.10), (&mut self)(arg.pass(), input.11), (&mut self)(arg.pass(), input.12), (&mut self)(arg.pass(), input.13), (&mut self)(arg.pass(), input.14), (&mut self)(arg.pass(), input.15), (&mut self)(arg.pass(), input.16), (&mut self)(arg.pass(), input.17))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &T) -> U> TupleUniformMapperBy<&(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &input.0), (&mut self)(arg.pass(), &input.1), (&mut self)(arg.pass(), &input.2), (&mut self)(arg.pass(), &input.3), (&mut self)(arg.pass(), &input.4), (&mut self)(arg.pass(), &input.5), (&mut self)(arg.pass(), &input.6), (&mut self)(arg.pass(), &input.7), (&mut self)(arg.pass(), &input.8), (&mut self)(arg.pass(), &input.9), (&mut self)(arg.pass(), &input.10), (&mut self)(arg.pass(), &input.11), (&mut self)(arg.pass(), &input.12), (&mut self)(arg.pass(), &input.13), (&mut self)(arg.pass(), &input.14), (&mut self)(arg.pass(), &input.15), (&mut self)(arg.pass(), &input.16), (&mut self)(arg.pass(), &input.17))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &mut T) -> U> TupleUniformMapperBy<&mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &mut input.0), (&mut self)(arg.pass(), &mut input.1), (&mut self)(arg.pass(), &mut input.2), (&mut self)(arg.pass(), &mut input.3), (&mut self)(arg.pass(), &mut input.4), (&mut self)(arg.pass(), &mut input.5), (&mut self)(arg.pass(), &mut input.6), (&mut self)(arg.pass(), &mut input.7), (&mut self)(arg.pass(), &mut input.8), (&mut self)(arg.pass(), &mut input.9), (&mut self)(arg.pass(), &mut input.10), (&mut self)(arg.pass(), &mut input.11), (&mut self)(arg.pass(), &mut input.12), (&mut self)(arg.pass(), &mut input.13), (&mut self)(arg.pass(), &mut input.14), (&mut self)(arg.pass(), &mut input.15), (&mut self)(arg.pass(), &mut input.16), (&mut self)(arg.pass(), &mut input.17))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, F0: for<'s> FnOnce(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, T17) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, F0: for<'s> FnMut(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, T17) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, F0: for<'s> Fn(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, T17) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, &T17) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, F0: for<'s> FnMut(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, &T17) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, F0: for<'s> Fn(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, &T17) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T17) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, F0: for<'s> FnMut(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, &mut T17) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, F0: for<'s> Fn(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, &mut T17) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, T) -> U> TupleUniformMapperBy<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), input.0), (&mut self)(arg.pass(), input.1), (&mut self)(arg.pass(), input.2), (&mut self)(arg.pass(), input.3), (&mut self)(arg.pass(), input.4), (&mut self)(arg.pass(), input.5), (&mut self)(arg.pass(), input.6), (&mut self)(arg.pass(), input.7), (&mut self)(arg.pass(), input.8), (&mut self)(arg.pass(), input.9), (&mut self)(arg.pass(), input.10), (&mut self)(arg.pass(), input.11), (&mut self)(arg.pass(), input.12), (&mut self)(arg.pass(), input.13), (&mut self)(arg.pass(), input.14), (&mut self)(arg.pass(), input.15), (&mut self)(arg.pass(), input.16), (&mut self)(arg.pass(), input.17), (&mut self)(arg.pass(), input.18))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &T) -> U> TupleUniformMapperBy<&(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &input.0), (&mut self)(arg.pass(), &input.1), (&mut self)(arg.pass(), &input.2), (&mut self)(arg.pass(), &input.3), (&mut self)(arg.pass(), &input.4), (&mut self)(arg.pass(), &input.5), (&mut self)(arg.pass(), &input.6), (&mut self)(arg.pass(), &input.7), (&mut self)(arg.pass(), &input.8), (&mut self)(arg.pass(), &input.9), (&mut self)(arg.pass(), &input.10), (&mut self)(arg.pass(), &input.11), (&mut self)(arg.pass(), &input.12), (&mut self)(arg.pass(), &input.13), (&mut self)(arg.pass(), &input.14), (&mut self)(arg.pass(), &input.15), (&mut self)(arg.pass(), &input.16), (&mut self)(arg.pass(), &input.17), (&mut self)(arg.pass(), &input.18))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &mut T) -> U> TupleUniformMapperBy<&mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &mut input.0), (&mut self)(arg.pass(), &mut input.1), (&mut self)(arg.pass(), &mut input.2), (&mut self)(arg.pass(), &mut input.3), (&mut self)(arg.pass(), &mut input.4), (&mut self)(arg.pass(), &mut input.5), (&mut self)(arg.pass(), &mut input.6), (&mut self)(arg.pass(), &mut input.7), (&mut self)(arg.pass(), &mut input.8), (&mut self)(arg.pass(), &mut input.9), (&mut self)(arg.pass(), &mut input.10), (&mut self)(arg.pass(), &mut input.11), (&mut self)(arg.pass(), &mut input.12), (&mut self)(arg.pass(), &mut input.13), (&mut self)(arg.pass(), &mut input.14), (&mut self)(arg.pass(), &mut input.15), (&mut self)(arg.pass(), &mut input.16), (&mut self)(arg.pass(), &mut input.17), (&mut self)(arg.pass(), &mut input.18))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, F0: for<'s> FnOnce(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, T18) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, F0: for<'s> FnMut(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, T18) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, F0: for<'s> Fn(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, T18) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, &T18) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, F0: for<'s> FnMut(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, &T18) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, F0: for<'s> Fn(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, &T18) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T18) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, F0: for<'s> FnMut(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, &mut T18) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, F0: for<'s> Fn(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, &mut T18) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, T) -> U> TupleUniformMapperBy<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), input.0), (&mut self)(arg.pass(), input.1), (&mut self)(arg.pass(), input.2), (&mut self)(arg.pass(), input.3), (&mut self)(arg.pass(), input.4), (&mut self)(arg.pass(), input.5), (&mut self)(arg.pass(), input.6), (&mut self)(arg.pass(), input.7), (&mut self)(arg.pass(), input.8), (&mut self)(arg.pass(), input.9), (&mut self)(arg.pass(), input.10), (&mut self)(arg.pass(), input.11), (&mut self)(arg.pass(), input.12), (&mut self)(arg.pass(), input.13), (&mut self)(arg.pass(), input.14), (&mut self)(arg.pass(), input.15), (&mut self)(arg.pass(), input.16), (&mut self)(arg.pass(), input.17), (&mut self)(arg.pass(), input.18), (&mut self)(arg.pass(), input.19))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &T) -> U> TupleUniformMapperBy<&(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &input.0), (&mut self)(arg.pass(), &input.1), (&mut self)(arg.pass(), &input.2), (&mut self)(arg.pass(), &input.3), (&mut self)(arg.pass(), &input.4), (&mut self)(arg.pass(), &input.5), (&mut self)(arg.pass(), &input.6), (&mut self)(arg.pass(), &input.7), (&mut self)(arg.pass(), &input.8), (&mut self)(arg.pass(), &input.9), (&mut self)(arg.pass(), &input.10), (&mut self)(arg.pass(), &input.11), (&mut self)(arg.pass(), &input.12), (&mut self)(arg.pass(), &input.13), (&mut self)(arg.pass(), &input.14), (&mut self)(arg.pass(), &input.15), (&mut self)(arg.pass(), &input.16), (&mut self)(arg.pass(), &input.17), (&mut self)(arg.pass(), &input.18), (&mut self)(arg.pass(), &input.19))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &mut T) -> U> TupleUniformMapperBy<&mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &mut input.0), (&mut self)(arg.pass(), &mut input.1), (&mut self)(arg.pass(), &mut input.2), (&mut self)(arg.pass(), &mut input.3), (&mut self)(arg.pass(), &mut input.4), (&mut self)(arg.pass(), &mut input.5), (&mut self)(arg.pass(), &mut input.6), (&mut self)(arg.pass(), &mut input.7), (&mut self)(arg.pass(), &mut input.8), (&mut self)(arg.pass(), &mut input.9), (&mut self)(arg.pass(), &mut input.10), (&mut self)(arg.pass(), &mut input.11), (&mut self)(arg.pass(), &mut input.12), (&mut self)(arg.pass(), &mut input.13), (&mut self)(arg.pass(), &mut input.14), (&mut self)(arg.pass(), &mut input.15), (&mut self)(arg.pass(), &mut input.16), (&mut self)(arg.pass(), &mut input.17), (&mut self)(arg.pass(), &mut input.18), (&mut self)(arg.pass(), &mut input.19))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, F0: for<'s> FnOnce(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, T19) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, F0: for<'s> FnMut(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, T19) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, F0: for<'s> Fn(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, T19) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, &T19) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, F0: for<'s> FnMut(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, &T19) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, F0: for<'s> Fn(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, &T19) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T19) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, F0: for<'s> FnMut(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, &mut T19) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, F0: for<'s> Fn(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, &mut T19) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, T) -> U> TupleUniformMapperBy<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), input.0), (&mut self)(arg.pass(), input.1), (&mut self)(arg.pass(), input.2), (&mut self)(arg.pass(), input.3), (&mut self)(arg.pass(), input.4), (&mut self)(arg.pass(), input.5), (&mut self)(arg.pass(), input.6), (&mut self)(arg.pass(), input.7), (&mut self)(arg.pass(), input.8), (&mut self)(arg.pass(), input.9), (&mut self)(arg.pass(), input.10), (&mut self)(arg.pass(), input.11), (&mut self)(arg.pass(), input.12), (&mut self)(arg.pass(), input.13), (&mut self)(arg.pass(), input.14), (&mut self)(arg.pass(), input.15), (&mut self)(arg.pass(), input.16), (&mut self)(arg.pass(), input.17), (&mut self)(arg.pass(), input.18), (&mut self)(arg.pass(), input.19), (&mut self)(arg.pass(), input.20))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &T) -> U> TupleUniformMapperBy<&(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &input.0), (&mut self)(arg.pass(), &input.1), (&mut self)(arg.pass(), &input.2), (&mut self)(arg.pass(), &input.3), (&mut self)(arg.pass(), &input.4), (&mut self)(arg.pass(), &input.5), (&mut self)(arg.pass(), &input.6), (&mut self)(arg.pass(), &input.7), (&mut self)(arg.pass(), &input.8), (&mut self)(arg.pass(), &input.9), (&mut self)(arg.pass(), &input.10), (&mut self)(arg.pass(), &input.11), (&mut self)(arg.pass(), &input.12), (&mut self)(arg.pass(), &input.13), (&mut self)(arg.pass(), &input.14), (&mut self)(arg.pass(), &input.15), (&mut self)(arg.pass(), &input.16), (&mut self)(arg.pass(), &input.17), (&mut self)(arg.pass(), &input.18), (&mut self)(arg.pass(), &input.19), (&mut self)(arg.pass(), &input.20))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &mut T) -> U> TupleUniformMapperBy<&mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &mut input.0), (&mut self)(arg.pass(), &mut input.1), (&mut self)(arg.pass(), &mut input.2), (&mut self)(arg.pass(), &mut input.3), (&mut self)(arg.pass(), &mut input.4), (&mut self)(arg.pass(), &mut input.5), (&mut self)(arg.pass(), &mut input.6), (&mut self)(arg.pass(), &mut input.7), (&mut self)(arg.pass(), &mut input.8), (&mut self)(arg.pass(), &mut input.9), (&mut self)(arg.pass(), &mut input.10), (&mut self)(arg.pass(), &mut input.11), (&mut self)(arg.pass(), &mut input.12), (&mut self)(arg.pass(), &mut input.13), (&mut self)(arg.pass(), &mut input.14), (&mut self)(arg.pass(), &mut input.15), (&mut self)(arg.pass(), &mut input.16), (&mut self)(arg.pass(), &mut input.17), (&mut self)(arg.pass(), &mut input.18), (&mut self)(arg.pass(), &mut input.19), (&mut self)(arg.pass(), &mut input.20))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, F0: for<'s> FnOnce(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, T20) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, F0: for<'s> FnMut(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, T20) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, F0: for<'s> Fn(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, T20) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, &T20) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, F0: for<'s> FnMut(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, &T20) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, F0: for<'s> Fn(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, &T20) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T20) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, F0: for<'s> FnMut(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, &mut T20) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, F0: for<'s> Fn(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, &mut T20) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, T) -> U> TupleUniformMapperBy<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), input.0), (&mut self)(arg.pass(), input.1), (&mut self)(arg.pass(), input.2), (&mut self)(arg.pass(), input.3), (&mut self)(arg.pass(), input.4), (&mut self)(arg.pass(), input.5), (&mut self)(arg.pass(), input.6), (&mut self)(arg.pass(), input.7), (&mut self)(arg.pass(), input.8), (&mut self)(arg.pass(), input.9), (&mut self)(arg.pass(), input.10), (&mut self)(arg.pass(), input.11), (&mut self)(arg.pass(), input.12), (&mut self)(arg.pass(), input.13), (&mut self)(arg.pass(), input.14), (&mut self)(arg.pass(), input.15), (&mut self)(arg.pass(), input.16), (&mut self)(arg.pass(), input.17), (&mut self)(arg.pass(), input.18), (&mut self)(arg.pass(), input.19), (&mut self)(arg.pass(), input.20), (&mut self)(arg.pass(), input.21))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &T) -> U> TupleUniformMapperBy<&(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &input.0), (&mut self)(arg.pass(), &input.1), (&mut self)(arg.pass(), &input.2), (&mut self)(arg.pass(), &input.3), (&mut self)(arg.pass(), &input.4), (&mut self)(arg.pass(), &input.5), (&mut self)(arg.pass(), &input.6), (&mut self)(arg.pass(), &input.7), (&mut self)(arg.pass(), &input.8), (&mut self)(arg.pass(), &input.9), (&mut self)(arg.pass(), &input.10), (&mut self)(arg.pass(), &input.11), (&mut self)(arg.pass(), &input.12), (&mut self)(arg.pass(), &input.13), (&mut self)(arg.pass(), &input.14), (&mut self)(arg.pass(), &input.15), (&mut self)(arg.pass(), &input.16), (&mut self)(arg.pass(), &input.17), (&mut self)(arg.pass(), &input.18), (&mut self)(arg.pass(), &input.19), (&mut self)(arg.pass(), &input.20), (&mut self)(arg.pass(), &input.21))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &mut T) -> U> TupleUniformMapperBy<&mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &mut input.0), (&mut self)(arg.pass(), &mut input.1), (&mut self)(arg.pass(), &mut input.2), (&mut self)(arg.pass(), &mut input.3), (&mut self)(arg.pass(), &mut input.4), (&mut self)(arg.pass(), &mut input.5), (&mut self)(arg.pass(), &mut input.6), (&mut self)(arg.pass(), &mut input.7), (&mut self)(arg.pass(), &mut input.8), (&mut self)(arg.pass(), &mut input.9), (&mut self)(arg.pass(), &mut input.10), (&mut self)(arg.pass(), &mut input.11), (&mut self)(arg.pass(), &mut input.12), (&mut self)(arg.pass(), &mut input.13), (&mut self)(arg.pass(), &mut input.14), (&mut self)(arg.pass(), &mut input.15), (&mut self)(arg.pass(), &mut input.16), (&mut self)(arg.pass(), &mut input.17), (&mut self)(arg.pass(), &mut input.18), (&mut self)(arg.pass(), &mut input.19), (&mut self)(arg.pass(), &mut input.20), (&mut self)(arg.pass(), &mut input.21))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, F0: for<'s> FnOnce(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, T20) -> U, F21: for<'s> FnOnce(<A as Param<'s>>::Target, T21) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20), (self.21)(arg.pass(), input.21))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, F0: for<'s> FnMut(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, T20) -> U, F21: for<'s> FnMut(<A as Param<'s>>::Target, T21) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20), (self.21)(arg.pass(), input.21))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, F0: for<'s> Fn(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, T20) -> U, F21: for<'s> Fn(<A as Param<'s>>::Target, T21) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20), (self.21)(arg.pass(), input.21))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, &T20) -> U, F21: for<'s> FnOnce(<A as Param<'s>>::Target, &T21) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20), (self.21)(arg.pass(), &input.21))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, F0: for<'s> FnMut(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, &T20) -> U, F21: for<'s> FnMut(<A as Param<'s>>::Target, &T21) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20), (self.21)(arg.pass(), &input.21))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, F0: for<'s> Fn(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, &T20) -> U, F21: for<'s> Fn(<A as Param<'s>>::Target, &T21) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20), (self.21)(arg.pass(), &input.21))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T20) -> U, F21: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T21) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20), (self.21)(arg.pass(), &mut input.21))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, F0: for<'s> FnMut(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, &mut T20) -> U, F21: for<'s> FnMut(<A as Param<'s>>::Target, &mut T21) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20), (self.21)(arg.pass(), &mut input.21))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, F0: for<'s> Fn(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, &mut T20) -> U, F21: for<'s> Fn(<A as Param<'s>>::Target, &mut T21) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20), (self.21)(arg.pass(), &mut input.21))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, T) -> U> TupleUniformMapperBy<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), input.0), (&mut self)(arg.pass(), input.1), (&mut self)(arg.pass(), input.2), (&mut self)(arg.pass(), input.3), (&mut self)(arg.pass(), input.4), (&mut self)(arg.pass(), input.5), (&mut self)(arg.pass(), input.6), (&mut self)(arg.pass(), input.7), (&mut self)(arg.pass(), input.8), (&mut self)(arg.pass(), input.9), (&mut self)(arg.pass(), input.10), (&mut self)(arg.pass(), input.11), (&mut self)(arg.pass(), input.12), (&mut self)(arg.pass(), input.13), (&mut self)(arg.pass(), input.14), (&mut self)(arg.pass(), input.15), (&mut self)(arg.pass(), input.16), (&mut self)(arg.pass(), input.17), (&mut self)(arg.pass(), input.18), (&mut self)(arg.pass(), input.19), (&mut self)(arg.pass(), input.20), (&mut self)(arg.pass(), input.21), (&mut self)(arg.pass(), input.22))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &T) -> U> TupleUniformMapperBy<&(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &input.0), (&mut self)(arg.pass(), &input.1), (&mut self)(arg.pass(), &input.2), (&mut self)(arg.pass(), &input.3), (&mut self)(arg.pass(), &input.4), (&mut self)(arg.pass(), &input.5), (&mut self)(arg.pass(), &input.6), (&mut self)(arg.pass(), &input.7), (&mut self)(arg.pass(), &input.8), (&mut self)(arg.pass(), &input.9), (&mut self)(arg.pass(), &input.10), (&mut self)(arg.pass(), &input.11), (&mut self)(arg.pass(), &input.12), (&mut self)(arg.pass(), &input.13), (&mut self)(arg.pass(), &input.14), (&mut self)(arg.pass(), &input.15), (&mut self)(arg.pass(), &input.16), (&mut self)(arg.pass(), &input.17), (&mut self)(arg.pass(), &input.18), (&mut self)(arg.pass(), &input.19), (&mut self)(arg.pass(), &input.20), (&mut self)(arg.pass(), &input.21), (&mut self)(arg.pass(), &input.22))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &mut T) -> U> TupleUniformMapperBy<&mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &mut input.0), (&mut self)(arg.pass(), &mut input.1), (&mut self)(arg.pass(), &mut input.2), (&mut self)(arg.pass(), &mut input.3), (&mut self)(arg.pass(), &mut input.4), (&mut self)(arg.pass(), &mut input.5), (&mut self)(arg.pass(), &mut input.6), (&mut self)(arg.pass(), &mut input.7), (&mut self)(arg.pass(), &mut input.8), (&mut self)(arg.pass(), &mut input.9), (&mut self)(arg.pass(), &mut input.10), (&mut self)(arg.pass(), &mut input.11), (&mut self)(arg.pass(), &mut input.12), (&mut self)(arg.pass(), &mut input.13), (&mut self)(arg.pass(), &mut input.14), (&mut self)(arg.pass(), &mut input.15), (&mut self)(arg.pass(), &mut input.16), (&mut self)(arg.pass(), &mut input.17), (&mut self)(arg.pass(), &mut input.18), (&mut self)(arg.pass(), &mut input.19), (&mut self)(arg.pass(), &mut input.20), (&mut self)(arg.pass(), &mut input.21), (&mut self)(arg.pass(), &mut input.22))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, F0: for<'s> FnOnce(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, T20) -> U, F21: for<'s> FnOnce(<A as Param<'s>>::Target, T21) -> U, F22: for<'s> FnOnce(<A as Param<'s>>::Target, T22) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20), (self.21)(arg.pass(), input.21), (self.22)(arg.pass(), input.22))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, F0: for<'s> FnMut(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, T20) -> U, F21: for<'s> FnMut(<A as Param<'s>>::Target, T21) -> U, F22: for<'s> FnMut(<A as Param<'s>>::Target, T22) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20), (self.21)(arg.pass(), input.21), (self.22)(arg.pass(), input.22))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, F0: for<'s> Fn(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, T20) -> U, F21: for<'s> Fn(<A as Param<'s>>::Target, T21) -> U, F22: for<'s> Fn(<A as Param<'s>>::Target, T22) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20), (self.21)(arg.pass(), input.21), (self.22)(arg.pass(), input.22))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, &T20) -> U, F21: for<'s> FnOnce(<A as Param<'s>>::Target, &T21) -> U, F22: for<'s> FnOnce(<A as Param<'s>>::Target, &T22) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20), (self.21)(arg.pass(), &input.21), (self.22)(arg.pass(), &input.22))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, F0: for<'s> FnMut(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, &T20) -> U, F21: for<'s> FnMut(<A as Param<'s>>::Target, &T21) -> U, F22: for<'s> FnMut(<A as Param<'s>>::Target, &T22) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20), (self.21)(arg.pass(), &input.21), (self.22)(arg.pass(), &input.22))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, F0: for<'s> Fn(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, &T20) -> U, F21: for<'s> Fn(<A as Param<'s>>::Target, &T21) -> U, F22: for<'s> Fn(<A as Param<'s>>::Target, &T22) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20), (self.21)(arg.pass(), &input.21), (self.22)(arg.pass(), &input.22))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T20) -> U, F21: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T21) -> U, F22: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T22) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20), (self.21)(arg.pass(), &mut input.21), (self.22)(arg.pass(), &mut input.22))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, F0: for<'s> FnMut(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, &mut T20) -> U, F21: for<'s> FnMut(<A as Param<'s>>::Target, &mut T21) -> U, F22: for<'s> FnMut(<A as Param<'s>>::Target, &mut T22) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20), (self.21)(arg.pass(), &mut input.21), (self.22)(arg.pass(), &mut input.22))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, F0: for<'s> Fn(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, &mut T20) -> U, F21: for<'s> Fn(<A as Param<'s>>::Target, &mut T21) -> U, F22: for<'s> Fn(<A as Param<'s>>::Target, &mut T22) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20), (self.21)(arg.pass(), &mut input.21), (self.22)(arg.pass(), &mut input.22))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, T) -> U> TupleUniformMapperBy<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), input.0), (&mut self)(arg.pass(), input.1), (&mut self)(arg.pass(), input.2), (&mut self)(arg.pass(), input.3), (&mut self)(arg.pass(), input.4), (&mut self)(arg.pass(), input.5), (&mut self)(arg.pass(), input.6), (&mut self)(arg.pass(), input.7), (&mut self)(arg.pass(), input.8), (&mut self)(arg.pass(), input.9), (&mut self)(arg.pass(), input.10), (&mut self)(arg.pass(), input.11), (&mut self)(arg.pass(), input.12), (&mut self)(arg.pass(), input.13), (&mut self)(arg.pass(), input.14), (&mut self)(arg.pass(), input.15), (&mut self)(arg.pass(), input.16), (&mut self)(arg.pass(), input.17), (&mut self)(arg.pass(), input.18), (&mut self)(arg.pass(), input.19), (&mut self)(arg.pass(), input.20), (&mut self)(arg.pass(), input.21), (&mut self)(arg.pass(), input.22), (&mut self)(arg.pass(), input.23))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &T) -> U> TupleUniformMapperBy<&(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &input.0), (&mut self)(arg.pass(), &input.1), (&mut self)(arg.pass(), &input.2), (&mut self)(arg.pass(), &input.3), (&mut self)(arg.pass(), &input.4), (&mut self)(arg.pass(), &input.5), (&mut self)(arg.pass(), &input.6), (&mut self)(arg.pass(), &input.7), (&mut self)(arg.pass(), &input.8), (&mut self)(arg.pass(), &input.9), (&mut self)(arg.pass(), &input.10), (&mut self)(arg.pass(), &input.11), (&mut self)(arg.pass(), &input.12), (&mut self)(arg.pass(), &input.13), (&mut self)(arg.pass(), &input.14), (&mut self)(arg.pass(), &input.15), (&mut self)(arg.pass(), &input.16), (&mut self)(arg.pass(), &input.17), (&mut self)(arg.pass(), &input.18), (&mut self)(arg.pass(), &input.19), (&mut self)(arg.pass(), &input.20), (&mut self)(arg.pass(), &input.21), (&mut self)(arg.pass(), &input.22), (&mut self)(arg.pass(), &input.23))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &mut T) -> U> TupleUniformMapperBy<&mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &mut input.0), (&mut self)(arg.pass(), &mut input.1), (&mut self)(arg.pass(), &mut input.2), (&mut self)(arg.pass(), &mut input.3), (&mut self)(arg.pass(), &mut input.4), (&mut self)(arg.pass(), &mut input.5), (&mut self)(arg.pass(), &mut input.6), (&mut self)(arg.pass(), &mut input.7), (&mut self)(arg.pass(), &mut input.8), (&mut self)(arg.pass(), &mut input.9), (&mut self)(arg.pass(), &mut input.10), (&mut self)(arg.pass(), &mut input.11), (&mut self)(arg.pass(), &mut input.12), (&mut self)(arg.pass(), &mut input.13), (&mut self)(arg.pass(), &mut input.14), (&mut self)(arg.pass(), &mut input.15), (&mut self)(arg.pass(), &mut input.16), (&mut self)(arg.pass(), &mut input.17), (&mut self)(arg.pass(), &mut input.18), (&mut self)(arg.pass(), &mut input.19), (&mut self)(arg.pass(), &mut input.20), (&mut self)(arg.pass(), &mut input.21), (&mut self)(arg.pass(), &mut input.22), (&mut self)(arg.pass(), &mut input.23))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, F0: for<'s> FnOnce(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, T20) -> U, F21: for<'s> FnOnce(<A as Param<'s>>::Target, T21) -> U, F22: for<'s> FnOnce(<A as Param<'s>>::Target, T22) -> U, F23: for<'s> FnOnce(<A as Param<'s>>::Target, T23) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20), (self.21)(arg.pass(), input.21), (self.22)(arg.pass(), input.22), (self.23)(arg.pass(), input.23))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, F0: for<'s> FnMut(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, T20) -> U, F21: for<'s> FnMut(<A as Param<'s>>::Target, T21) -> U, F22: for<'s> FnMut(<A as Param<'s>>::Target, T22) -> U, F23: for<'s> FnMut(<A as Param<'s>>::Target, T23) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20), (self.21)(arg.pass(), input.21), (self.22)(arg.pass(), input.22), (self.23)(arg.pass(), input.23))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, F0: for<'s> Fn(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, T20) -> U, F21: for<'s> Fn(<A as Param<'s>>::Target, T21) -> U, F22: for<'s> Fn(<A as Param<'s>>::Target, T22) -> U, F23: for<'s> Fn(<A as Param<'s>>::Target, T23) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20), (self.21)(arg.pass(), input.21), (self.22)(arg.pass(), input.22), (self.23)(arg.pass(), input.23))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, &T20) -> U, F21: for<'s> FnOnce(<A as Param<'s>>::Target, &T21) -> U, F22: for<'s> FnOnce(<A as Param<'s>>::Target, &T22) -> U, F23: for<'s> FnOnce(<A as Param<'s>>::Target, &T23) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20), (self.21)(arg.pass(), &input.21), (self.22)(arg.pass(), &input.22), (self.23)(arg.pass(), &input.23))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, F0: for<'s> FnMut(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, &T20) -> U, F21: for<'s> FnMut(<A as Param<'s>>::Target, &T21) -> U, F22: for<'s> FnMut(<A as Param<'s>>::Target, &T22) -> U, F23: for<'s> FnMut(<A as Param<'s>>::Target, &T23) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20), (self.21)(arg.pass(), &input.21), (self.22)(arg.pass(), &input.22), (self.23)(arg.pass(), &input.23))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, F0: for<'s> Fn(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, &T20) -> U, F21: for<'s> Fn(<A as Param<'s>>::Target, &T21) -> U, F22: for<'s> Fn(<A as Param<'s>>::Target, &T22) -> U, F23: for<'s> Fn(<A as Param<'s>>::Target, &T23) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20), (self.21)(arg.pass(), &input.21), (self.22)(arg.pass(), &input.22), (self.23)(arg.pass(), &input.23))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T20) -> U, F21: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T21) -> U, F22: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T22) -> U, F23: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T23) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20), (self.21)(arg.pass(), &mut input.21), (self.22)(arg.pass(), &mut input.22), (self.23)(arg.pass(), &mut input.23))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, F0: for<'s> FnMut(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, &mut T20) -> U, F21: for<'s> FnMut(<A as Param<'s>>::Target, &mut T21) -> U, F22: for<'s> FnMut(<A as Param<'s>>::Target, &mut T22) -> U, F23: for<'s> FnMut(<A as Param<'s>>::Target, &mut T23) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20), (self.21)(arg.pass(), &mut input.21), (self.22)(arg.pass(), &mut input.22), (self.23)(arg.pass(), &mut input.23))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, F0: for<'s> Fn(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, &mut T20) -> U, F21: for<'s> Fn(<A as Param<'s>>::Target, &mut T21) -> U, F22: for<'s> Fn(<A as Param<'s>>::Target, &mut T22) -> U, F23: for<'s> Fn(<A as Param<'s>>::Target, &mut T23) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20), (self.21)(arg.pass(), &mut input.21), (self.22)(arg.pass(), &mut input.22), (self.23)(arg.pass(), &mut input.23))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, T) -> U> TupleUniformMapperBy<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), input.0), (&mut self)(arg.pass(), input.1), (&mut self)(arg.pass(), input.2), (&mut self)(arg.pass(), input.3), (&mut self)(arg.pass(), input.4), (&mut self)(arg.pass(), input.5), (&mut self)(arg.pass(), input.6), (&mut self)(arg.pass(), input.7), (&mut self)(arg.pass(), input.8), (&mut self)(arg.pass(), input.9), (&mut self)(arg.pass(), input.10), (&mut self)(arg.pass(), input.11), (&mut self)(arg.pass(), input.12), (&mut self)(arg.pass(), input.13), (&mut self)(arg.pass(), input.14), (&mut self)(arg.pass(), input.15), (&mut self)(arg.pass(), input.16), (&mut self)(arg.pass(), input.17), (&mut self)(arg.pass(), input.18), (&mut self)(arg.pass(), input.19), (&mut self)(arg.pass(), input.20), (&mut self)(arg.pass(), input.21), (&mut self)(arg.pass(), input.22), (&mut self)(arg.pass(), input.23), (&mut self)(arg.pass(), input.24))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &T) -> U> TupleUniformMapperBy<&(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &input.0), (&mut self)(arg.pass(), &input.1), (&mut self)(arg.pass(), &input.2), (&mut self)(arg.pass(), &input.3), (&mut self)(arg.pass(), &input.4), (&mut self)(arg.pass(), &input.5), (&mut self)(arg.pass(), &input.6), (&mut self)(arg.pass(), &input.7), (&mut self)(arg.pass(), &input.8), (&mut self)(arg.pass(), &input.9), (&mut self)(arg.pass(), &input.10), (&mut self)(arg.pass(), &input.11), (&mut self)(arg.pass(), &input.12), (&mut self)(arg.pass(), &input.13), (&mut self)(arg.pass(), &input.14), (&mut self)(arg.pass(), &input.15), (&mut self)(arg.pass(), &input.16), (&mut self)(arg.pass(), &input.17), (&mut self)(arg.pass(), &input.18), (&mut self)(arg.pass(), &input.19), (&mut self)(arg.pass(), &input.20), (&mut self)(arg.pass(), &input.21), (&mut self)(arg.pass(), &input.22), (&mut self)(arg.pass(), &input.23), (&mut self)(arg.pass(), &input.24))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &mut T) -> U> TupleUniformMapperBy<&mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &mut input.0), (&mut self)(arg.pass(), &mut input.1), (&mut self)(arg.pass(), &mut input.2), (&mut self)(arg.pass(), &mut input.3), (&mut self)(arg.pass(), &mut input.4), (&mut self)(arg.pass(), &mut input.5), (&mut self)(arg.pass(), &mut input.6), (&mut self)(arg.pass(), &mut input.7), (&mut self)(arg.pass(), &mut input.8), (&mut self)(arg.pass(), &mut input.9), (&mut self)(arg.pass(), &mut input.10), (&mut self)(arg.pass(), &mut input.11), (&mut self)(arg.pass(), &mut input.12), (&mut self)(arg.pass(), &mut input.13), (&mut self)(arg.pass(), &mut input.14), (&mut self)(arg.pass(), &mut input.15), (&mut self)(arg.pass(), &mut input.16), (&mut self)(arg.pass(), &mut input.17), (&mut self)(arg.pass(), &mut input.18), (&mut self)(arg.pass(), &mut input.19), (&mut self)(arg.pass(), &mut input.20), (&mut self)(arg.pass(), &mut input.21), (&mut self)(arg.pass(), &mut input.22), (&mut self)(arg.pass(), &mut input.23), (&mut self)(arg.pass(), &mut input.24))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, F0: for<'s> FnOnce(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, T20) -> U, F21: for<'s> FnOnce(<A as Param<'s>>::Target, T21) -> U, F22: for<'s> FnOnce(<A as Param<'s>>::Target, T22) -> U, F23: for<'s> FnOnce(<A as Param<'s>>::Target, T23) -> U, F24: for<'s> FnOnce(<A as Param<'s>>::Target, T24) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20), (self.21)(arg.pass(), input.21), (self.22)(arg.pass(), input.22), (self.23)(arg.pass(), input.23), (self.24)(arg.pass(), input.24))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, F0: for<'s> FnMut(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, T20) -> U, F21: for<'s> FnMut(<A as Param<'s>>::Target, T21) -> U, F22: for<'s> FnMut(<A as Param<'s>>::Target, T22) -> U, F23: for<'s> FnMut(<A as Param<'s>>::Target, T23) -> U, F24: for<'s> FnMut(<A as Param<'s>>::Target, T24) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20), (self.21)(arg.pass(), input.21), (self.22)(arg.pass(), input.22), (self.23)(arg.pass(), input.23), (self.24)(arg.pass(), input.24))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, F0: for<'s> Fn(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, T20) -> U, F21: for<'s> Fn(<A as Param<'s>>::Target, T21) -> U, F22: for<'s> Fn(<A as Param<'s>>::Target, T22) -> U, F23: for<'s> Fn(<A as Param<'s>>::Target, T23) -> U, F24: for<'s> Fn(<A as Param<'s>>::Target, T24) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20), (self.21)(arg.pass(), input.21), (self.22)(arg.pass(), input.22), (self.23)(arg.pass(), input.23), (self.24)(arg.pass(), input.24))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, &T20) -> U, F21: for<'s> FnOnce(<A as Param<'s>>::Target, &T21) -> U, F22: for<'s> FnOnce(<A as Param<'s>>::Target, &T22) -> U, F23: for<'s> FnOnce(<A as Param<'s>>::Target, &T23) -> U, F24: for<'s> FnOnce(<A as Param<'s>>::Target, &T24) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20), (self.21)(arg.pass(), &input.21), (self.22)(arg.pass(), &input.22), (self.23)(arg.pass(), &input.23), (self.24)(arg.pass(), &input.24))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, F0: for<'s> FnMut(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, &T20) -> U, F21: for<'s> FnMut(<A as Param<'s>>::Target, &T21) -> U, F22: for<'s> FnMut(<A as Param<'s>>::Target, &T22) -> U, F23: for<'s> FnMut(<A as Param<'s>>::Target, &T23) -> U, F24: for<'s> FnMut(<A as Param<'s>>::Target, &T24) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20), (self.21)(arg.pass(), &input.21), (self.22)(arg.pass(), &input.22), (self.23)(arg.pass(), &input.23), (self.24)(arg.pass(), &input.24))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, F0: for<'s> Fn(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, &T20) -> U, F21: for<'s> Fn(<A as Param<'s>>::Target, &T21) -> U, F22: for<'s> Fn(<A as Param<'s>>::Target, &T22) -> U, F23: for<'s> Fn(<A as Param<'s>>::Target, &T23) -> U, F24: for<'s> Fn(<A as Param<'s>>::Target, &T24) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20), (self.21)(arg.pass(), &input.21), (self.22)(arg.pass(), &input.22), (self.23)(arg.pass(), &input.23), (self.24)(arg.pass(), &input.24))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T20) -> U, F21: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T21) -> U, F22: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T22) -> U, F23: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T23) -> U, F24: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T24) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20), (self.21)(arg.pass(), &mut input.21), (self.22)(arg.pass(), &mut input.22), (self.23)(arg.pass(), &mut input.23), (self.24)(arg.pass(), &mut input.24))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, F0: for<'s> FnMut(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, &mut T20) -> U, F21: for<'s> FnMut(<A as Param<'s>>::Target, &mut T21) -> U, F22: for<'s> FnMut(<A as Param<'s>>::Target, &mut T22) -> U, F23: for<'s> FnMut(<A as Param<'s>>::Target, &mut T23) -> U, F24: for<'s> FnMut(<A as Param<'s>>::Target, &mut T24) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20), (self.21)(arg.pass(), &mut input.21), (self.22)(arg.pass(), &mut input.22), (self.23)(arg.pass(), &mut input.23), (self.24)(arg.pass(), &mut input.24))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, F0: for<'s> Fn(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, &mut T20) -> U, F21: for<'s> Fn(<A as Param<'s>>::Target, &mut T21) -> U, F22: for<'s> Fn(<A as Param<'s>>::Target, &mut T22) -> U, F23: for<'s> Fn(<A as Param<'s>>::Target, &mut T23) -> U, F24: for<'s> Fn(<A as Param<'s>>::Target, &mut T24) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20), (self.21)(arg.pass(), &mut input.21), (self.22)(arg.pass(), &mut input.22), (self.23)(arg.pass(), &mut input.23), (self.24)(arg.pass(), &mut input.24))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, T) -> U> TupleUniformMapperBy<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), input.0), (&mut self)(arg.pass(), input.1), (&mut self)(arg.pass(), input.2), (&mut self)(arg.pass(), input.3), (&mut self)(arg.pass(), input.4), (&mut self)(arg.pass(), input.5), (&mut self)(arg.pass(), input.6), (&mut self)(arg.pass(), input.7), (&mut self)(arg.pass(), input.8), (&mut self)(arg.pass(), input.9), (&mut self)(arg.pass(), input.10), (&mut self)(arg.pass(), input.11), (&mut self)(arg.pass(), input.12), (&mut self)(arg.pass(), input.13), (&mut self)(arg.pass(), input.14), (&mut self)(arg.pass(), input.15), (&mut self)(arg.pass(), input.16), (&mut self)(arg.pass(), input.17), (&mut self)(arg.pass(), input.18), (&mut self)(arg.pass(), input.19), (&mut self)(arg.pass(), input.20), (&mut self)(arg.pass(), input.21), (&mut self)(arg.pass(), input.22), (&mut self)(arg.pass(), input.23), (&mut self)(arg.pass(), input.24), (&mut self)(arg.pass(), input.25))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &T) -> U> TupleUniformMapperBy<&(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &input.0), (&mut self)(arg.pass(), &input.1), (&mut self)(arg.pass(), &input.2), (&mut self)(arg.pass(), &input.3), (&mut self)(arg.pass(), &input.4), (&mut self)(arg.pass(), &input.5), (&mut self)(arg.pass(), &input.6), (&mut self)(arg.pass(), &input.7), (&mut self)(arg.pass(), &input.8), (&mut self)(arg.pass(), &input.9), (&mut self)(arg.pass(), &input.10), (&mut self)(arg.pass(), &input.11), (&mut self)(arg.pass(), &input.12), (&mut self)(arg.pass(), &input.13), (&mut self)(arg.pass(), &input.14), (&mut self)(arg.pass(), &input.15), (&mut self)(arg.pass(), &input.16), (&mut self)(arg.pass(), &input.17), (&mut self)(arg.pass(), &input.18), (&mut self)(arg.pass(), &input.19), (&mut self)(arg.pass(), &input.20), (&mut self)(arg.pass(), &input.21), (&mut self)(arg.pass(), &input.22), (&mut self)(arg.pass(), &input.23), (&mut self)(arg.pass(), &input.24), (&mut self)(arg.pass(), &input.25))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &mut T) -> U> TupleUniformMapperBy<&mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &mut input.0), (&mut self)(arg.pass(), &mut input.1), (&mut self)(arg.pass(), &mut input.2), (&mut self)(arg.pass(), &mut input.3), (&mut self)(arg.pass(), &mut input.4), (&mut self)(arg.pass(), &mut input.5), (&mut self)(arg.pass(), &mut input.6), (&mut self)(arg.pass(), &mut input.7), (&mut self)(arg.pass(), &mut input.8), (&mut self)(arg.pass(), &mut input.9), (&mut self)(arg.pass(), &mut input.10), (&mut self)(arg.pass(), &mut input.11), (&mut self)(arg.pass(), &mut input.12), (&mut self)(arg.pass(), &mut input.13), (&mut self)(arg.pass(), &mut input.14), (&mut self)(arg.pass(), &mut input.15), (&mut self)(arg.pass(), &mut input.16), (&mut self)(arg.pass(), &mut input.17), (&mut self)(arg.pass(), &mut input.18), (&mut self)(arg.pass(), &mut input.19), (&mut self)(arg.pass(), &mut input.20), (&mut self)(arg.pass(), &mut input.21), (&mut self)(arg.pass(), &mut input.22), (&mut self)(arg.pass(), &mut input.23), (&mut self)(arg.pass(), &mut input.24), (&mut self)(arg.pass(), &mut input.25))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, F0: for<'s> FnOnce(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, T20) -> U, F21: for<'s> FnOnce(<A as Param<'s>>::Target, T21) -> U, F22: for<'s> FnOnce(<A as Param<'s>>::Target, T22) -> U, F23: for<'s> FnOnce(<A as Param<'s>>::Target, T23) -> U, F24: for<'s> FnOnce(<A as Param<'s>>::Target, T24) -> U, F25: for<'s> FnOnce(<A as Param<'s>>::Target, T25) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20), (self.21)(arg.pass(), input.21), (self.22)(arg.pass(), input.22), (self.23)(arg.pass(), input.23), (self.24)(arg.pass(), input.24), (self.25)(arg.pass(), input.25))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, F0: for<'s> FnMut(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, T20) -> U, F21: for<'s> FnMut(<A as Param<'s>>::Target, T21) -> U, F22: for<'s> FnMut(<A as Param<'s>>::Target, T22) -> U, F23: for<'s> FnMut(<A as Param<'s>>::Target, T23) -> U, F24: for<'s> FnMut(<A as Param<'s>>::Target, T24) -> U, F25: for<'s> FnMut(<A as Param<'s>>::Target, T25) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20), (self.21)(arg.pass(), input.21), (self.22)(arg.pass(), input.22), (self.23)(arg.pass(), input.23), (self.24)(arg.pass(), input.24), (self.25)(arg.pass(), input.25))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, F0: for<'s> Fn(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, T20) -> U, F21: for<'s> Fn(<A as Param<'s>>::Target, T21) -> U, F22: for<'s> Fn(<A as Param<'s>>::Target, T22) -> U, F23: for<'s> Fn(<A as Param<'s>>::Target, T23) -> U, F24: for<'s> Fn(<A as Param<'s>>::Target, T24) -> U, F25: for<'s> Fn(<A as Param<'s>>::Target, T25) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20), (self.21)(arg.pass(), input.21), (self.22)(arg.pass(), input.22), (self.23)(arg.pass(), input.23), (self.24)(arg.pass(), input.24), (self.25)(arg.pass(), input.25))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, &T20) -> U, F21: for<'s> FnOnce(<A as Param<'s>>::Target, &T21) -> U, F22: for<'s> FnOnce(<A as Param<'s>>::Target, &T22) -> U, F23: for<'s> FnOnce(<A as Param<'s>>::Target, &T23) -> U, F24: for<'s> FnOnce(<A as Param<'s>>::Target, &T24) -> U, F25: for<'s> FnOnce(<A as Param<'s>>::Target, &T25) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20), (self.21)(arg.pass(), &input.21), (self.22)(arg.pass(), &input.22), (self.23)(arg.pass(), &input.23), (self.24)(arg.pass(), &input.24), (self.25)(arg.pass(), &input.25))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, F0: for<'s> FnMut(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, &T20) -> U, F21: for<'s> FnMut(<A as Param<'s>>::Target, &T21) -> U, F22: for<'s> FnMut(<A as Param<'s>>::Target, &T22) -> U, F23: for<'s> FnMut(<A as Param<'s>>::Target, &T23) -> U, F24: for<'s> FnMut(<A as Param<'s>>::Target, &T24) -> U, F25: for<'s> FnMut(<A as Param<'s>>::Target, &T25) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20), (self.21)(arg.pass(), &input.21), (self.22)(arg.pass(), &input.22), (self.23)(arg.pass(), &input.23), (self.24)(arg.pass(), &input.24), (self.25)(arg.pass(), &input.25))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, F0: for<'s> Fn(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, &T20) -> U, F21: for<'s> Fn(<A as Param<'s>>::Target, &T21) -> U, F22: for<'s> Fn(<A as Param<'s>>::Target, &T22) -> U, F23: for<'s> Fn(<A as Param<'s>>::Target, &T23) -> U, F24: for<'s> Fn(<A as Param<'s>>::Target, &T24) -> U, F25: for<'s> Fn(<A as Param<'s>>::Target, &T25) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20), (self.21)(arg.pass(), &input.21), (self.22)(arg.pass(), &input.22), (self.23)(arg.pass(), &input.23), (self.24)(arg.pass(), &input.24), (self.25)(arg.pass(), &input.25))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T20) -> U, F21: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T21) -> U, F22: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T22) -> U, F23: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T23) -> U, F24: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T24) -> U, F25: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T25) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20), (self.21)(arg.pass(), &mut input.21), (self.22)(arg.pass(), &mut input.22), (self.23)(arg.pass(), &mut input.23), (self.24)(arg.pass(), &mut input.24), (self.25)(arg.pass(), &mut input.25))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, F0: for<'s> FnMut(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, &mut T20) -> U, F21: for<'s> FnMut(<A as Param<'s>>::Target, &mut T21) -> U, F22: for<'s> FnMut(<A as Param<'s>>::Target, &mut T22) -> U, F23: for<'s> FnMut(<A as Param<'s>>::Target, &mut T23) -> U, F24: for<'s> FnMut(<A as Param<'s>>::Target, &mut T24) -> U, F25: for<'s> FnMut(<A as Param<'s>>::Target, &mut T25) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20), (self.21)(arg.pass(), &mut input.21), (self.22)(arg.pass(), &mut input.22), (self.23)(arg.pass(), &mut input.23), (self.24)(arg.pass(), &mut input.24), (self.25)(arg.pass(), &mut input.25))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, F0: for<'s> Fn(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, &mut T20) -> U, F21: for<'s> Fn(<A as Param<'s>>::Target, &mut T21) -> U, F22: for<'s> Fn(<A as Param<'s>>::Target, &mut T22) -> U, F23: for<'s> Fn(<A as Param<'s>>::Target, &mut T23) -> U, F24: for<'s> Fn(<A as Param<'s>>::Target, &mut T24) -> U, F25: for<'s> Fn(<A as Param<'s>>::Target, &mut T25) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20), (self.21)(arg.pass(), &mut input.21), (self.22)(arg.pass(), &mut input.22), (self.23)(arg.pass(), &mut input.23), (self.24)(arg.pass(), &mut input.24), (self.25)(arg.pass(), &mut input.25))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, T) -> U> TupleUniformMapperBy<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), input.0), (&mut self)(arg.pass(), input.1), (&mut self)(arg.pass(), input.2), (&mut self)(arg.pass(), input.3), (&mut self)(arg.pass(), input.4), (&mut self)(arg.pass(), input.5), (&mut self)(arg.pass(), input.6), (&mut self)(arg.pass(), input.7), (&mut self)(arg.pass(), input.8), (&mut self)(arg.pass(), input.9), (&mut self)(arg.pass(), input.10), (&mut self)(arg.pass(), input.11), (&mut self)(arg.pass(), input.12), (&mut self)(arg.pass(), input.13), (&mut self)(arg.pass(), input.14), (&mut self)(arg.pass(), input.15), (&mut self)(arg.pass(), input.16), (&mut self)(arg.pass(), input.17), (&mut self)(arg.pass(), input.18), (&mut self)(arg.pass(), input.19), (&mut self)(arg.pass(), input.20), (&mut self)(arg.pass(), input.21), (&mut self)(arg.pass(), input.22), (&mut self)(arg.pass(), input.23), (&mut self)(arg.pass(), input.24), (&mut self)(arg.pass(), input.25), (&mut self)(arg.pass(), input.26))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &T) -> U> TupleUniformMapperBy<&(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &input.0), (&mut self)(arg.pass(), &input.1), (&mut self)(arg.pass(), &input.2), (&mut self)(arg.pass(), &input.3), (&mut self)(arg.pass(), &input.4), (&mut self)(arg.pass(), &input.5), (&mut self)(arg.pass(), &input.6), (&mut self)(arg.pass(), &input.7), (&mut self)(arg.pass(), &input.8), (&mut self)(arg.pass(), &input.9), (&mut self)(arg.pass(), &input.10), (&mut self)(arg.pass(), &input.11), (&mut self)(arg.pass(), &input.12), (&mut self)(arg.pass(), &input.13), (&mut self)(arg.pass(), &input.14), (&mut self)(arg.pass(), &input.15), (&mut self)(arg.pass(), &input.16), (&mut self)(arg.pass(), &input.17), (&mut self)(arg.pass(), &input.18), (&mut self)(arg.pass(), &input.19), (&mut self)(arg.pass(), &input.20), (&mut self)(arg.pass(), &input.21), (&mut self)(arg.pass(), &input.22), (&mut self)(arg.pass(), &input.23), (&mut self)(arg.pass(), &input.24), (&mut self)(arg.pass(), &input.25), (&mut self)(arg.pass(), &input.26))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &mut T) -> U> TupleUniformMapperBy<&mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &mut input.0), (&mut self)(arg.pass(), &mut input.1), (&mut self)(arg.pass(), &mut input.2), (&mut self)(arg.pass(), &mut input.3), (&mut self)(arg.pass(), &mut input.4), (&mut self)(arg.pass(), &mut input.5), (&mut self)(arg.pass(), &mut input.6), (&mut self)(arg.pass(), &mut input.7), (&mut self)(arg.pass(), &mut input.8), (&mut self)(arg.pass(), &mut input.9), (&mut self)(arg.pass(), &mut input.10), (&mut self)(arg.pass(), &mut input.11), (&mut self)(arg.pass(), &mut input.12), (&mut self)(arg.pass(), &mut input.13), (&mut self)(arg.pass(), &mut input.14), (&mut self)(arg.pass(), &mut input.15), (&mut self)(arg.pass(), &mut input.16), (&mut self)(arg.pass(), &mut input.17), (&mut self)(arg.pass(), &mut input.18), (&mut self)(arg.pass(), &mut input.19), (&mut self)(arg.pass(), &mut input.20), (&mut self)(arg.pass(), &mut input.21), (&mut self)(arg.pass(), &mut input.22), (&mut self)(arg.pass(), &mut input.23), (&mut self)(arg.pass(), &mut input.24), (&mut self)(arg.pass(), &mut input.25), (&mut self)(arg.pass(), &mut input.26))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, F0: for<'s> FnOnce(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, T20) -> U, F21: for<'s> FnOnce(<A as Param<'s>>::Target, T21) -> U, F22: for<'s> FnOnce(<A as Param<'s>>::Target, T22) -> U, F23: for<'s> FnOnce(<A as Param<'s>>::Target, T23) -> U, F24: for<'s> FnOnce(<A as Param<'s>>::Target, T24) -> U, F25: for<'s> FnOnce(<A as Param<'s>>::Target, T25) -> U, F26: for<'s> FnOnce(<A as Param<'s>>::Target, T26) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20), (self.21)(arg.pass(), input.21), (self.22)(arg.pass(), input.22), (self.23)(arg.pass(), input.23), (self.24)(arg.pass(), input.24), (self.25)(arg.pass(), input.25), (self.26)(arg.pass(), input.26))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, F0: for<'s> FnMut(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, T20) -> U, F21: for<'s> FnMut(<A as Param<'s>>::Target, T21) -> U, F22: for<'s> FnMut(<A as Param<'s>>::Target, T22) -> U, F23: for<'s> FnMut(<A as Param<'s>>::Target, T23) -> U, F24: for<'s> FnMut(<A as Param<'s>>::Target, T24) -> U, F25: for<'s> FnMut(<A as Param<'s>>::Target, T25) -> U, F26: for<'s> FnMut(<A as Param<'s>>::Target, T26) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20), (self.21)(arg.pass(), input.21), (self.22)(arg.pass(), input.22), (self.23)(arg.pass(), input.23), (self.24)(arg.pass(), input.24), (self.25)(arg.pass(), input.25), (self.26)(arg.pass(), input.26))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, F0: for<'s> Fn(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, T20) -> U, F21: for<'s> Fn(<A as Param<'s>>::Target, T21) -> U, F22: for<'s> Fn(<A as Param<'s>>::Target, T22) -> U, F23: for<'s> Fn(<A as Param<'s>>::Target, T23) -> U, F24: for<'s> Fn(<A as Param<'s>>::Target, T24) -> U, F25: for<'s> Fn(<A as Param<'s>>::Target, T25) -> U, F26: for<'s> Fn(<A as Param<'s>>::Target, T26) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20), (self.21)(arg.pass(), input.21), (self.22)(arg.pass(), input.22), (self.23)(arg.pass(), input.23), (self.24)(arg.pass(), input.24), (self.25)(arg.pass(), input.25), (self.26)(arg.pass(), input.26))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, &T20) -> U, F21: for<'s> FnOnce(<A as Param<'s>>::Target, &T21) -> U, F22: for<'s> FnOnce(<A as Param<'s>>::Target, &T22) -> U, F23: for<'s> FnOnce(<A as Param<'s>>::Target, &T23) -> U, F24: for<'s> FnOnce(<A as Param<'s>>::Target, &T24) -> U, F25: for<'s> FnOnce(<A as Param<'s>>::Target, &T25) -> U, F26: for<'s> FnOnce(<A as Param<'s>>::Target, &T26) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20), (self.21)(arg.pass(), &input.21), (self.22)(arg.pass(), &input.22), (self.23)(arg.pass(), &input.23), (self.24)(arg.pass(), &input.24), (self.25)(arg.pass(), &input.25), (self.26)(arg.pass(), &input.26))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, F0: for<'s> FnMut(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, &T20) -> U, F21: for<'s> FnMut(<A as Param<'s>>::Target, &T21) -> U, F22: for<'s> FnMut(<A as Param<'s>>::Target, &T22) -> U, F23: for<'s> FnMut(<A as Param<'s>>::Target, &T23) -> U, F24: for<'s> FnMut(<A as Param<'s>>::Target, &T24) -> U, F25: for<'s> FnMut(<A as Param<'s>>::Target, &T25) -> U, F26: for<'s> FnMut(<A as Param<'s>>::Target, &T26) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20), (self.21)(arg.pass(), &input.21), (self.22)(arg.pass(), &input.22), (self.23)(arg.pass(), &input.23), (self.24)(arg.pass(), &input.24), (self.25)(arg.pass(), &input.25), (self.26)(arg.pass(), &input.26))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, F0: for<'s> Fn(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, &T20) -> U, F21: for<'s> Fn(<A as Param<'s>>::Target, &T21) -> U, F22: for<'s> Fn(<A as Param<'s>>::Target, &T22) -> U, F23: for<'s> Fn(<A as Param<'s>>::Target, &T23) -> U, F24: for<'s> Fn(<A as Param<'s>>::Target, &T24) -> U, F25: for<'s> Fn(<A as Param<'s>>::Target, &T25) -> U, F26: for<'s> Fn(<A as Param<'s>>::Target, &T26) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20), (self.21)(arg.pass(), &input.21), (self.22)(arg.pass(), &input.22), (self.23)(arg.pass(), &input.23), (self.24)(arg.pass(), &input.24), (self.25)(arg.pass(), &input.25), (self.26)(arg.pass(), &input.26))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T20) -> U, F21: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T21) -> U, F22: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T22) -> U, F23: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T23) -> U, F24: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T24) -> U, F25: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T25) -> U, F26: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T26) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20), (self.21)(arg.pass(), &mut input.21), (self.22)(arg.pass(), &mut input.22), (self.23)(arg.pass(), &mut input.23), (self.24)(arg.pass(), &mut input.24), (self.25)(arg.pass(), &mut input.25), (self.26)(arg.pass(), &mut input.26))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, F0: for<'s> FnMut(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, &mut T20) -> U, F21: for<'s> FnMut(<A as Param<'s>>::Target, &mut T21) -> U, F22: for<'s> FnMut(<A as Param<'s>>::Target, &mut T22) -> U, F23: for<'s> FnMut(<A as Param<'s>>::Target, &mut T23) -> U, F24: for<'s> FnMut(<A as Param<'s>>::Target, &mut T24) -> U, F25: for<'s> FnMut(<A as Param<'s>>::Target, &mut T25) -> U, F26: for<'s> FnMut(<A as Param<'s>>::Target, &mut T26) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20), (self.21)(arg.pass(), &mut input.21), (self.22)(arg.pass(), &mut input.22), (self.23)(arg.pass(), &mut input.23), (self.24)(arg.pass(), &mut input.24), (self.25)(arg.pass(), &mut input.25), (self.26)(arg.pass(), &mut input.26))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, F0: for<'s> Fn(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, &mut T20) -> U, F21: for<'s> Fn(<A as Param<'s>>::Target, &mut T21) -> U, F22: for<'s> Fn(<A as Param<'s>>::Target, &mut T22) -> U, F23: for<'s> Fn(<A as Param<'s>>::Target, &mut T23) -> U, F24: for<'s> Fn(<A as Param<'s>>::Target, &mut T24) -> U, F25: for<'s> Fn(<A as Param<'s>>::Target, &mut T25) -> U, F26: for<'s> Fn(<A as Param<'s>>::Target, &mut T26) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20), (self.21)(arg.pass(), &mut input.21), (self.22)(arg.pass(), &mut input.22), (self.23)(arg.pass(), &mut input.23), (self.24)(arg.pass(), &mut input.24), (self.25)(arg.pass(), &mut input.25), (self.26)(arg.pass(), &mut input.26))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, T) -> U> TupleUniformMapperBy<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), input.0), (&mut self)(arg.pass(), input.1), (&mut self)(arg.pass(), input.2), (&mut self)(arg.pass(), input.3), (&mut self)(arg.pass(), input.4), (&mut self)(arg.pass(), input.5), (&mut self)(arg.pass(), input.6), (&mut self)(arg.pass(), input.7), (&mut self)(arg.pass(), input.8), (&mut self)(arg.pass(), input.9), (&mut self)(arg.pass(), input.10), (&mut self)(arg.pass(), input.11), (&mut self)(arg.pass(), input.12), (&mut self)(arg.pass(), input.13), (&mut self)(arg.pass(), input.14), (&mut self)(arg.pass(), input.15), (&mut self)(arg.pass(), input.16), (&mut self)(arg.pass(), input.17), (&mut self)(arg.pass(), input.18), (&mut self)(arg.pass(), input.19), (&mut self)(arg.pass(), input.20), (&mut self)(arg.pass(), input.21), (&mut self)(arg.pass(), input.22), (&mut self)(arg.pass(), input.23), (&mut self)(arg.pass(), input.24), (&mut self)(arg.pass(), input.25), (&mut self)(arg.pass(), input.26), (&mut self)(arg.pass(), input.27))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &T) -> U> TupleUniformMapperBy<&(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &input.0), (&mut self)(arg.pass(), &input.1), (&mut self)(arg.pass(), &input.2), (&mut self)(arg.pass(), &input.3), (&mut self)(arg.pass(), &input.4), (&mut self)(arg.pass(), &input.5), (&mut self)(arg.pass(), &input.6), (&mut self)(arg.pass(), &input.7), (&mut self)(arg.pass(), &input.8), (&mut self)(arg.pass(), &input.9), (&mut self)(arg.pass(), &input.10), (&mut self)(arg.pass(), &input.11), (&mut self)(arg.pass(), &input.12), (&mut self)(arg.pass(), &input.13), (&mut self)(arg.pass(), &input.14), (&mut self)(arg.pass(), &input.15), (&mut self)(arg.pass(), &input.16), (&mut self)(arg.pass(), &input.17), (&mut self)(arg.pass(), &input.18), (&mut self)(arg.pass(), &input.19), (&mut self)(arg.pass(), &input.20), (&mut self)(arg.pass(), &input.21), (&mut self)(arg.pass(), &input.22), (&mut self)(arg.pass(), &input.23), (&mut self)(arg.pass(), &input.24), (&mut self)(arg.pass(), &input.25), (&mut self)(arg.pass(), &input.26), (&mut self)(arg.pass(), &input.27))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &mut T) -> U> TupleUniformMapperBy<&mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &mut input.0), (&mut self)(arg.pass(), &mut input.1), (&mut self)(arg.pass(), &mut input.2), (&mut self)(arg.pass(), &mut input.3), (&mut self)(arg.pass(), &mut input.4), (&mut self)(arg.pass(), &mut input.5), (&mut self)(arg.pass(), &mut input.6), (&mut self)(arg.pass(), &mut input.7), (&mut self)(arg.pass(), &mut input.8), (&mut self)(arg.pass(), &mut input.9), (&mut self)(arg.pass(), &mut input.10), (&mut self)(arg.pass(), &mut input.11), (&mut self)(arg.pass(), &mut input.12), (&mut self)(arg.pass(), &mut input.13), (&mut self)(arg.pass(), &mut input.14), (&mut self)(arg.pass(), &mut input.15), (&mut self)(arg.pass(), &mut input.16), (&mut self)(arg.pass(), &mut input.17), (&mut self)(arg.pass(), &mut input.18), (&mut self)(arg.pass(), &mut input.19), (&mut self)(arg.pass(), &mut input.20), (&mut self)(arg.pass(), &mut input.21), (&mut self)(arg.pass(), &mut input.22), (&mut self)(arg.pass(), &mut input.23), (&mut self)(arg.pass(), &mut input.24), (&mut self)(arg.pass(), &mut input.25), (&mut self)(arg.pass(), &mut input.26), (&mut self)(arg.pass(), &mut input.27))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, F0: for<'s> FnOnce(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, T20) -> U, F21: for<'s> FnOnce(<A as Param<'s>>::Target, T21) -> U, F22: for<'s> FnOnce(<A as Param<'s>>::Target, T22) -> U, F23: for<'s> FnOnce(<A as Param<'s>>::Target, T23) -> U, F24: for<'s> FnOnce(<A as Param<'s>>::Target, T24) -> U, F25: for<'s> FnOnce(<A as Param<'s>>::Target, T25) -> U, F26: for<'s> FnOnce(<A as Param<'s>>::Target, T26) -> U, F27: for<'s> FnOnce(<A as Param<'s>>::Target, T27) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20), (self.21)(arg.pass(), input.21), (self.22)(arg.pass(), input.22), (self.23)(arg.pass(), input.23), (self.24)(arg.pass(), input.24), (self.25)(arg.pass(), input.25), (self.26)(arg.pass(), input.26), (self.27)(arg.pass(), input.27))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, F0: for<'s> FnMut(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, T20) -> U, F21: for<'s> FnMut(<A as Param<'s>>::Target, T21) -> U, F22: for<'s> FnMut(<A as Param<'s>>::Target, T22) -> U, F23: for<'s> FnMut(<A as Param<'s>>::Target, T23) -> U, F24: for<'s> FnMut(<A as Param<'s>>::Target, T24) -> U, F25: for<'s> FnMut(<A as Param<'s>>::Target, T25) -> U, F26: for<'s> FnMut(<A as Param<'s>>::Target, T26) -> U, F27: for<'s> FnMut(<A as Param<'s>>::Target, T27) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20), (self.21)(arg.pass(), input.21), (self.22)(arg.pass(), input.22), (self.23)(arg.pass(), input.23), (self.24)(arg.pass(), input.24), (self.25)(arg.pass(), input.25), (self.26)(arg.pass(), input.26), (self.27)(arg.pass(), input.27))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, F0: for<'s> Fn(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, T20) -> U, F21: for<'s> Fn(<A as Param<'s>>::Target, T21) -> U, F22: for<'s> Fn(<A as Param<'s>>::Target, T22) -> U, F23: for<'s> Fn(<A as Param<'s>>::Target, T23) -> U, F24: for<'s> Fn(<A as Param<'s>>::Target, T24) -> U, F25: for<'s> Fn(<A as Param<'s>>::Target, T25) -> U, F26: for<'s> Fn(<A as Param<'s>>::Target, T26) -> U, F27: for<'s> Fn(<A as Param<'s>>::Target, T27) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20), (self.21)(arg.pass(), input.21), (self.22)(arg.pass(), input.22), (self.23)(arg.pass(), input.23), (self.24)(arg.pass(), input.24), (self.25)(arg.pass(), input.25), (self.26)(arg.pass(), input.26), (self.27)(arg.pass(), input.27))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, &T20) -> U, F21: for<'s> FnOnce(<A as Param<'s>>::Target, &T21) -> U, F22: for<'s> FnOnce(<A as Param<'s>>::Target, &T22) -> U, F23: for<'s> FnOnce(<A as Param<'s>>::Target, &T23) -> U, F24: for<'s> FnOnce(<A as Param<'s>>::Target, &T24) -> U, F25: for<'s> FnOnce(<A as Param<'s>>::Target, &T25) -> U, F26: for<'s> FnOnce(<A as Param<'s>>::Target, &T26) -> U, F27: for<'s> FnOnce(<A as Param<'s>>::Target, &T27) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20), (self.21)(arg.pass(), &input.21), (self.22)(arg.pass(), &input.22), (self.23)(arg.pass(), &input.23), (self.24)(arg.pass(), &input.24), (self.25)(arg.pass(), &input.25), (self.26)(arg.pass(), &input.26), (self.27)(arg.pass(), &input.27))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, F0: for<'s> FnMut(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, &T20) -> U, F21: for<'s> FnMut(<A as Param<'s>>::Target, &T21) -> U, F22: for<'s> FnMut(<A as Param<'s>>::Target, &T22) -> U, F23: for<'s> FnMut(<A as Param<'s>>::Target, &T23) -> U, F24: for<'s> FnMut(<A as Param<'s>>::Target, &T24) -> U, F25: for<'s> FnMut(<A as Param<'s>>::Target, &T25) -> U, F26: for<'s> FnMut(<A as Param<'s>>::Target, &T26) -> U, F27: for<'s> FnMut(<A as Param<'s>>::Target, &T27) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20), (self.21)(arg.pass(), &input.21), (self.22)(arg.pass(), &input.22), (self.23)(arg.pass(), &input.23), (self.24)(arg.pass(), &input.24), (self.25)(arg.pass(), &input.25), (self.26)(arg.pass(), &input.26), (self.27)(arg.pass(), &input.27))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, F0: for<'s> Fn(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, &T20) -> U, F21: for<'s> Fn(<A as Param<'s>>::Target, &T21) -> U, F22: for<'s> Fn(<A as Param<'s>>::Target, &T22) -> U, F23: for<'s> Fn(<A as Param<'s>>::Target, &T23) -> U, F24: for<'s> Fn(<A as Param<'s>>::Target, &T24) -> U, F25: for<'s> Fn(<A as Param<'s>>::Target, &T25) -> U, F26: for<'s> Fn(<A as Param<'s>>::Target, &T26) -> U, F27: for<'s> Fn(<A as Param<'s>>::Target, &T27) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20), (self.21)(arg.pass(), &input.21), (self.22)(arg.pass(), &input.22), (self.23)(arg.pass(), &input.23), (self.24)(arg.pass(), &input.24), (self.25)(arg.pass(), &input.25), (self.26)(arg.pass(), &input.26), (self.27)(arg.pass(), &input.27))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T20) -> U, F21: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T21) -> U, F22: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T22) -> U, F23: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T23) -> U, F24: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T24) -> U, F25: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T25) -> U, F26: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T26) -> U, F27: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T27) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20), (self.21)(arg.pass(), &mut input.21), (self.22)(arg.pass(), &mut input.22), (self.23)(arg.pass(), &mut input.23), (self.24)(arg.pass(), &mut input.24), (self.25)(arg.pass(), &mut input.25), (self.26)(arg.pass(), &mut input.26), (self.27)(arg.pass(), &mut input.27))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, F0: for<'s> FnMut(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, &mut T20) -> U, F21: for<'s> FnMut(<A as Param<'s>>::Target, &mut T21) -> U, F22: for<'s> FnMut(<A as Param<'s>>::Target, &mut T22) -> U, F23: for<'s> FnMut(<A as Param<'s>>::Target, &mut T23) -> U, F24: for<'s> FnMut(<A as Param<'s>>::Target, &mut T24) -> U, F25: for<'s> FnMut(<A as Param<'s>>::Target, &mut T25) -> U, F26: for<'s> FnMut(<A as Param<'s>>::Target, &mut T26) -> U, F27: for<'s> FnMut(<A as Param<'s>>::Target, &mut T27) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20), (self.21)(arg.pass(), &mut input.21), (self.22)(arg.pass(), &mut input.22), (self.23)(arg.pass(), &mut input.23), (self.24)(arg.pass(), &mut input.24), (self.25)(arg.pass(), &mut input.25), (self.26)(arg.pass(), &mut input.26), (self.27)(arg.pass(), &mut input.27))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, F0: for<'s> Fn(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, &mut T20) -> U, F21: for<'s> Fn(<A as Param<'s>>::Target, &mut T21) -> U, F22: for<'s> Fn(<A as Param<'s>>::Target, &mut T22) -> U, F23: for<'s> Fn(<A as Param<'s>>::Target, &mut T23) -> U, F24: for<'s> Fn(<A as Param<'s>>::Target, &mut T24) -> U, F25: for<'s> Fn(<A as Param<'s>>::Target, &mut T25) -> U, F26: for<'s> Fn(<A as Param<'s>>::Target, &mut T26) -> U, F27: for<'s> Fn(<A as Param<'s>>::Target, &mut T27) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20), (self.21)(arg.pass(), &mut input.21), (self.22)(arg.pass(), &mut input.22), (self.23)(arg.pass(), &mut input.23), (self.24)(arg.pass(), &mut input.24), (self.25)(arg.pass(), &mut input.25), (self.26)(arg.pass(), &mut input.26), (self.27)(arg.pass(), &mut input.27))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, T) -> U> TupleUniformMapperBy<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), input.0), (&mut self)(arg.pass(), input.1), (&mut self)(arg.pass(), input.2), (&mut self)(arg.pass(), input.3), (&mut self)(arg.pass(), input.4), (&mut self)(arg.pass(), input.5), (&mut self)(arg.pass(), input.6), (&mut self)(arg.pass(), input.7), (&mut self)(arg.pass(), input.8), (&mut self)(arg.pass(), input.9), (&mut self)(arg.pass(), input.10), (&mut self)(arg.pass(), input.11), (&mut self)(arg.pass(), input.12), (&mut self)(arg.pass(), input.13), (&mut self)(arg.pass(), input.14), (&mut self)(arg.pass(), input.15), (&mut self)(arg.pass(), input.16), (&mut self)(arg.pass(), input.17), (&mut self)(arg.pass(), input.18), (&mut self)(arg.pass(), input.19), (&mut self)(arg.pass(), input.20), (&mut self)(arg.pass(), input.21), (&mut self)(arg.pass(), input.22), (&mut self)(arg.pass(), input.23), (&mut self)(arg.pass(), input.24), (&mut self)(arg.pass(), input.25), (&mut self)(arg.pass(), input.26), (&mut self)(arg.pass(), input.27), (&mut self)(arg.pass(), input.28))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &T) -> U> TupleUniformMapperBy<&(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &input.0), (&mut self)(arg.pass(), &input.1), (&mut self)(arg.pass(), &input.2), (&mut self)(arg.pass(), &input.3), (&mut self)(arg.pass(), &input.4), (&mut self)(arg.pass(), &input.5), (&mut self)(arg.pass(), &input.6), (&mut self)(arg.pass(), &input.7), (&mut self)(arg.pass(), &input.8), (&mut self)(arg.pass(), &input.9), (&mut self)(arg.pass(), &input.10), (&mut self)(arg.pass(), &input.11), (&mut self)(arg.pass(), &input.12), (&mut self)(arg.pass(), &input.13), (&mut self)(arg.pass(), &input.14), (&mut self)(arg.pass(), &input.15), (&mut self)(arg.pass(), &input.16), (&mut self)(arg.pass(), &input.17), (&mut self)(arg.pass(), &input.18), (&mut self)(arg.pass(), &input.19), (&mut self)(arg.pass(), &input.20), (&mut self)(arg.pass(), &input.21), (&mut self)(arg.pass(), &input.22), (&mut self)(arg.pass(), &input.23), (&mut self)(arg.pass(), &input.24), (&mut self)(arg.pass(), &input.25), (&mut self)(arg.pass(), &input.26), (&mut self)(arg.pass(), &input.27), (&mut self)(arg.pass(), &input.28))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &mut T) -> U> TupleUniformMapperBy<&mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &mut input.0), (&mut self)(arg.pass(), &mut input.1), (&mut self)(arg.pass(), &mut input.2), (&mut self)(arg.pass(), &mut input.3), (&mut self)(arg.pass(), &mut input.4), (&mut self)(arg.pass(), &mut input.5), (&mut self)(arg.pass(), &mut input.6), (&mut self)(arg.pass(), &mut input.7), (&mut self)(arg.pass(), &mut input.8), (&mut self)(arg.pass(), &mut input.9), (&mut self)(arg.pass(), &mut input.10), (&mut self)(arg.pass(), &mut input.11), (&mut self)(arg.pass(), &mut input.12), (&mut self)(arg.pass(), &mut input.13), (&mut self)(arg.pass(), &mut input.14), (&mut self)(arg.pass(), &mut input.15), (&mut self)(arg.pass(), &mut input.16), (&mut self)(arg.pass(), &mut input.17), (&mut self)(arg.pass(), &mut input.18), (&mut self)(arg.pass(), &mut input.19), (&mut self)(arg.pass(), &mut input.20), (&mut self)(arg.pass(), &mut input.21), (&mut self)(arg.pass(), &mut input.22), (&mut self)(arg.pass(), &mut input.23), (&mut self)(arg.pass(), &mut input.24), (&mut self)(arg.pass(), &mut input.25), (&mut self)(arg.pass(), &mut input.26), (&mut self)(arg.pass(), &mut input.27), (&mut self)(arg.pass(), &mut input.28))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, F0: for<'s> FnOnce(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, T20) -> U, F21: for<'s> FnOnce(<A as Param<'s>>::Target, T21) -> U, F22: for<'s> FnOnce(<A as Param<'s>>::Target, T22) -> U, F23: for<'s> FnOnce(<A as Param<'s>>::Target, T23) -> U, F24: for<'s> FnOnce(<A as Param<'s>>::Target, T24) -> U, F25: for<'s> FnOnce(<A as Param<'s>>::Target, T25) -> U, F26: for<'s> FnOnce(<A as Param<'s>>::Target, T26) -> U, F27: for<'s> FnOnce(<A as Param<'s>>::Target, T27) -> U, F28: for<'s> FnOnce(<A as Param<'s>>::Target, T28) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20), (self.21)(arg.pass(), input.21), (self.22)(arg.pass(), input.22), (self.23)(arg.pass(), input.23), (self.24)(arg.pass(), input.24), (self.25)(arg.pass(), input.25), (self.26)(arg.pass(), input.26), (self.27)(arg.pass(), input.27), (self.28)(arg.pass(), input.28))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, F0: for<'s> FnMut(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, T20) -> U, F21: for<'s> FnMut(<A as Param<'s>>::Target, T21) -> U, F22: for<'s> FnMut(<A as Param<'s>>::Target, T22) -> U, F23: for<'s> FnMut(<A as Param<'s>>::Target, T23) -> U, F24: for<'s> FnMut(<A as Param<'s>>::Target, T24) -> U, F25: for<'s> FnMut(<A as Param<'s>>::Target, T25) -> U, F26: for<'s> FnMut(<A as Param<'s>>::Target, T26) -> U, F27: for<'s> FnMut(<A as Param<'s>>::Target, T27) -> U, F28: for<'s> FnMut(<A as Param<'s>>::Target, T28) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20), (self.21)(arg.pass(), input.21), (self.22)(arg.pass(), input.22), (self.23)(arg.pass(), input.23), (self.24)(arg.pass(), input.24), (self.25)(arg.pass(), input.25), (self.26)(arg.pass(), input.26), (self.27)(arg.pass(), input.27), (self.28)(arg.pass(), input.28))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, F0: for<'s> Fn(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, T20) -> U, F21: for<'s> Fn(<A as Param<'s>>::Target, T21) -> U, F22: for<'s> Fn(<A as Param<'s>>::Target, T22) -> U, F23: for<'s> Fn(<A as Param<'s>>::Target, T23) -> U, F24: for<'s> Fn(<A as Param<'s>>::Target, T24) -> U, F25: for<'s> Fn(<A as Param<'s>>::Target, T25) -> U, F26: for<'s> Fn(<A as Param<'s>>::Target, T26) -> U, F27: for<'s> Fn(<A as Param<'s>>::Target, T27) -> U, F28: for<'s> Fn(<A as Param<'s>>::Target, T28) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20), (self.21)(arg.pass(), input.21), (self.22)(arg.pass(), input.22), (self.23)(arg.pass(), input.23), (self.24)(arg.pass(), input.24), (self.25)(arg.pass(), input.25), (self.26)(arg.pass(), input.26), (self.27)(arg.pass(), input.27), (self.28)(arg.pass(), input.28))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, &T20) -> U, F21: for<'s> FnOnce(<A as Param<'s>>::Target, &T21) -> U, F22: for<'s> FnOnce(<A as Param<'s>>::Target, &T22) -> U, F23: for<'s> FnOnce(<A as Param<'s>>::Target, &T23) -> U, F24: for<'s> FnOnce(<A as Param<'s>>::Target, &T24) -> U, F25: for<'s> FnOnce(<A as Param<'s>>::Target, &T25) -> U, F26: for<'s> FnOnce(<A as Param<'s>>::Target, &T26) -> U, F27: for<'s> FnOnce(<A as Param<'s>>::Target, &T27) -> U, F28: for<'s> FnOnce(<A as Param<'s>>::Target, &T28) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20), (self.21)(arg.pass(), &input.21), (self.22)(arg.pass(), &input.22), (self.23)(arg.pass(), &input.23), (self.24)(arg.pass(), &input.24), (self.25)(arg.pass(), &input.25), (self.26)(arg.pass(), &input.26), (self.27)(arg.pass(), &input.27), (self.28)(arg.pass(), &input.28))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, F0: for<'s> FnMut(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, &T20) -> U, F21: for<'s> FnMut(<A as Param<'s>>::Target, &T21) -> U, F22: for<'s> FnMut(<A as Param<'s>>::Target, &T22) -> U, F23: for<'s> FnMut(<A as Param<'s>>::Target, &T23) -> U, F24: for<'s> FnMut(<A as Param<'s>>::Target, &T24) -> U, F25: for<'s> FnMut(<A as Param<'s>>::Target, &T25) -> U, F26: for<'s> FnMut(<A as Param<'s>>::Target, &T26) -> U, F27: for<'s> FnMut(<A as Param<'s>>::Target, &T27) -> U, F28: for<'s> FnMut(<A as Param<'s>>::Target, &T28) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20), (self.21)(arg.pass(), &input.21), (self.22)(arg.pass(), &input.22), (self.23)(arg.pass(), &input.23), (self.24)(arg.pass(), &input.24), (self.25)(arg.pass(), &input.25), (self.26)(arg.pass(), &input.26), (self.27)(arg.pass(), &input.27), (self.28)(arg.pass(), &input.28))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, F0: for<'s> Fn(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, &T20) -> U, F21: for<'s> Fn(<A as Param<'s>>::Target, &T21) -> U, F22: for<'s> Fn(<A as Param<'s>>::Target, &T22) -> U, F23: for<'s> Fn(<A as Param<'s>>::Target, &T23) -> U, F24: for<'s> Fn(<A as Param<'s>>::Target, &T24) -> U, F25: for<'s> Fn(<A as Param<'s>>::Target, &T25) -> U, F26: for<'s> Fn(<A as Param<'s>>::Target, &T26) -> U, F27: for<'s> Fn(<A as Param<'s>>::Target, &T27) -> U, F28: for<'s> Fn(<A as Param<'s>>::Target, &T28) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20), (self.21)(arg.pass(), &input.21), (self.22)(arg.pass(), &input.22), (self.23)(arg.pass(), &input.23), (self.24)(arg.pass(), &input.24), (self.25)(arg.pass(), &input.25), (self.26)(arg.pass(), &input.26), (self.27)(arg.pass(), &input.27), (self.28)(arg.pass(), &input.28))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T20) -> U, F21: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T21) -> U, F22: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T22) -> U, F23: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T23) -> U, F24: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T24) -> U, F25: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T25) -> U, F26: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T26) -> U, F27: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T27) -> U, F28: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T28) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20), (self.21)(arg.pass(), &mut input.21), (self.22)(arg.pass(), &mut input.22), (self.23)(arg.pass(), &mut input.23), (self.24)(arg.pass(), &mut input.24), (self.25)(arg.pass(), &mut input.25), (self.26)(arg.pass(), &mut input.26), (self.27)(arg.pass(), &mut input.27), (self.28)(arg.pass(), &mut input.28))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, F0: for<'s> FnMut(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, &mut T20) -> U, F21: for<'s> FnMut(<A as Param<'s>>::Target, &mut T21) -> U, F22: for<'s> FnMut(<A as Param<'s>>::Target, &mut T22) -> U, F23: for<'s> FnMut(<A as Param<'s>>::Target, &mut T23) -> U, F24: for<'s> FnMut(<A as Param<'s>>::Target, &mut T24) -> U, F25: for<'s> FnMut(<A as Param<'s>>::Target, &mut T25) -> U, F26: for<'s> FnMut(<A as Param<'s>>::Target, &mut T26) -> U, F27: for<'s> FnMut(<A as Param<'s>>::Target, &mut T27) -> U, F28: for<'s> FnMut(<A as Param<'s>>::Target, &mut T28) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20), (self.21)(arg.pass(), &mut input.21), (self.22)(arg.pass(), &mut input.22), (self.23)(arg.pass(), &mut input.23), (self.24)(arg.pass(), &mut input.24), (self.25)(arg.pass(), &mut input.25), (self.26)(arg.pass(), &mut input.26), (self.27)(arg.pass(), &mut input.27), (self.28)(arg.pass(), &mut input.28))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, F0: for<'s> Fn(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, &mut T20) -> U, F21: for<'s> Fn(<A as Param<'s>>::Target, &mut T21) -> U, F22: for<'s> Fn(<A as Param<'s>>::Target, &mut T22) -> U, F23: for<'s> Fn(<A as Param<'s>>::Target, &mut T23) -> U, F24: for<'s> Fn(<A as Param<'s>>::Target, &mut T24) -> U, F25: for<'s> Fn(<A as Param<'s>>::Target, &mut T25) -> U, F26: for<'s> Fn(<A as Param<'s>>::Target, &mut T26) -> U, F27: for<'s> Fn(<A as Param<'s>>::Target, &mut T27) -> U, F28: for<'s> Fn(<A as Param<'s>>::Target, &mut T28) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20), (self.21)(arg.pass(), &mut input.21), (self.22)(arg.pass(), &mut input.22), (self.23)(arg.pass(), &mut input.23), (self.24)(arg.pass(), &mut input.24), (self.25)(arg.pass(), &mut input.25), (self.26)(arg.pass(), &mut input.26), (self.27)(arg.pass(), &mut input.27), (self.28)(arg.pass(), &mut input.28))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, T) -> U> TupleUniformMapperBy<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), input.0), (&mut self)(arg.pass(), input.1), (&mut self)(arg.pass(), input.2), (&mut self)(arg.pass(), input.3), (&mut self)(arg.pass(), input.4), (&mut self)(arg.pass(), input.5), (&mut self)(arg.pass(), input.6), (&mut self)(arg.pass(), input.7), (&mut self)(arg.pass(), input.8), (&mut self)(arg.pass(), input.9), (&mut self)(arg.pass(), input.10), (&mut self)(arg.pass(), input.11), (&mut self)(arg.pass(), input.12), (&mut self)(arg.pass(), input.13), (&mut self)(arg.pass(), input.14), (&mut self)(arg.pass(), input.15), (&mut self)(arg.pass(), input.16), (&mut self)(arg.pass(), input.17), (&mut self)(arg.pass(), input.18), (&mut self)(arg.pass(), input.19), (&mut self)(arg.pass(), input.20), (&mut self)(arg.pass(), input.21), (&mut self)(arg.pass(), input.22), (&mut self)(arg.pass(), input.23), (&mut self)(arg.pass(), input.24), (&mut self)(arg.pass(), input.25), (&mut self)(arg.pass(), input.26), (&mut self)(arg.pass(), input.27), (&mut self)(arg.pass(), input.28), (&mut self)(arg.pass(), input.29))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &T) -> U> TupleUniformMapperBy<&(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &input.0), (&mut self)(arg.pass(), &input.1), (&mut self)(arg.pass(), &input.2), (&mut self)(arg.pass(), &input.3), (&mut self)(arg.pass(), &input.4), (&mut self)(arg.pass(), &input.5), (&mut self)(arg.pass(), &input.6), (&mut self)(arg.pass(), &input.7), (&mut self)(arg.pass(), &input.8), (&mut self)(arg.pass(), &input.9), (&mut self)(arg.pass(), &input.10), (&mut self)(arg.pass(), &input.11), (&mut self)(arg.pass(), &input.12), (&mut self)(arg.pass(), &input.13), (&mut self)(arg.pass(), &input.14), (&mut self)(arg.pass(), &input.15), (&mut self)(arg.pass(), &input.16), (&mut self)(arg.pass(), &input.17), (&mut self)(arg.pass(), &input.18), (&mut self)(arg.pass(), &input.19), (&mut self)(arg.pass(), &input.20), (&mut self)(arg.pass(), &input.21), (&mut self)(arg.pass(), &input.22), (&mut self)(arg.pass(), &input.23), (&mut self)(arg.pass(), &input.24), (&mut self)(arg.pass(), &input.25), (&mut self)(arg.pass(), &input.26), (&mut self)(arg.pass(), &input.27), (&mut self)(arg.pass(), &input.28), (&mut self)(arg.pass(), &input.29))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &mut T) -> U> TupleUniformMapperBy<&mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &mut input.0), (&mut self)(arg.pass(), &mut input.1), (&mut self)(arg.pass(), &mut input.2), (&mut self)(arg.pass(), &mut input.3), (&mut self)(arg.pass(), &mut input.4), (&mut self)(arg.pass(), &mut input.5), (&mut self)(arg.pass(), &mut input.6), (&mut self)(arg.pass(), &mut input.7), (&mut self)(arg.pass(), &mut input.8), (&mut self)(arg.pass(), &mut input.9), (&mut self)(arg.pass(), &mut input.10), (&mut self)(arg.pass(), &mut input.11), (&mut self)(arg.pass(), &mut input.12), (&mut self)(arg.pass(), &mut input.13), (&mut self)(arg.pass(), &mut input.14), (&mut self)(arg.pass(), &mut input.15), (&mut self)(arg.pass(), &mut input.16), (&mut self)(arg.pass(), &mut input.17), (&mut self)(arg.pass(), &mut input.18), (&mut self)(arg.pass(), &mut input.19), (&mut self)(arg.pass(), &mut input.20), (&mut self)(arg.pass(), &mut input.21), (&mut self)(arg.pass(), &mut input.22), (&mut self)(arg.pass(), &mut input.23), (&mut self)(arg.pass(), &mut input.24), (&mut self)(arg.pass(), &mut input.25), (&mut self)(arg.pass(), &mut input.26), (&mut self)(arg.pass(), &mut input.27), (&mut self)(arg.pass(), &mut input.28), (&mut self)(arg.pass(), &mut input.29))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, F0: for<'s> FnOnce(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, T20) -> U, F21: for<'s> FnOnce(<A as Param<'s>>::Target, T21) -> U, F22: for<'s> FnOnce(<A as Param<'s>>::Target, T22) -> U, F23: for<'s> FnOnce(<A as Param<'s>>::Target, T23) -> U, F24: for<'s> FnOnce(<A as Param<'s>>::Target, T24) -> U, F25: for<'s> FnOnce(<A as Param<'s>>::Target, T25) -> U, F26: for<'s> FnOnce(<A as Param<'s>>::Target, T26) -> U, F27: for<'s> FnOnce(<A as Param<'s>>::Target, T27) -> U, F28: for<'s> FnOnce(<A as Param<'s>>::Target, T28) -> U, F29: for<'s> FnOnce(<A as Param<'s>>::Target, T29) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28, F29)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20), (self.21)(arg.pass(), input.21), (self.22)(arg.pass(), input.22), (self.23)(arg.pass(), input.23), (self.24)(arg.pass(), input.24), (self.25)(arg.pass(), input.25), (self.26)(arg.pass(), input.26), (self.27)(arg.pass(), input.27), (self.28)(arg.pass(), input.28), (self.29)(arg.pass(), input.29))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, F0: for<'s> FnMut(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, T20) -> U, F21: for<'s> FnMut(<A as Param<'s>>::Target, T21) -> U, F22: for<'s> FnMut(<A as Param<'s>>::Target, T22) -> U, F23: for<'s> FnMut(<A as Param<'s>>::Target, T23) -> U, F24: for<'s> FnMut(<A as Param<'s>>::Target, T24) -> U, F25: for<'s> FnMut(<A as Param<'s>>::Target, T25) -> U, F26: for<'s> FnMut(<A as Param<'s>>::Target, T26) -> U, F27: for<'s> FnMut(<A as Param<'s>>::Target, T27) -> U, F28: for<'s> FnMut(<A as Param<'s>>::Target, T28) -> U, F29: for<'s> FnMut(<A as Param<'s>>::Target, T29) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28, F29)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20), (self.21)(arg.pass(), input.21), (self.22)(arg.pass(), input.22), (self.23)(arg.pass(), input.23), (self.24)(arg.pass(), input.24), (self.25)(arg.pass(), input.25), (self.26)(arg.pass(), input.26), (self.27)(arg.pass(), input.27), (self.28)(arg.pass(), input.28), (self.29)(arg.pass(), input.29))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, F0: for<'s> Fn(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, T20) -> U, F21: for<'s> Fn(<A as Param<'s>>::Target, T21) -> U, F22: for<'s> Fn(<A as Param<'s>>::Target, T22) -> U, F23: for<'s> Fn(<A as Param<'s>>::Target, T23) -> U, F24: for<'s> Fn(<A as Param<'s>>::Target, T24) -> U, F25: for<'s> Fn(<A as Param<'s>>::Target, T25) -> U, F26: for<'s> Fn(<A as Param<'s>>::Target, T26) -> U, F27: for<'s> Fn(<A as Param<'s>>::Target, T27) -> U, F28: for<'s> Fn(<A as Param<'s>>::Target, T28) -> U, F29: for<'s> Fn(<A as Param<'s>>::Target, T29) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28, F29)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20), (self.21)(arg.pass(), input.21), (self.22)(arg.pass(), input.22), (self.23)(arg.pass(), input.23), (self.24)(arg.pass(), input.24), (self.25)(arg.pass(), input.25), (self.26)(arg.pass(), input.26), (self.27)(arg.pass(), input.27), (self.28)(arg.pass(), input.28), (self.29)(arg.pass(), input.29))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, &T20) -> U, F21: for<'s> FnOnce(<A as Param<'s>>::Target, &T21) -> U, F22: for<'s> FnOnce(<A as Param<'s>>::Target, &T22) -> U, F23: for<'s> FnOnce(<A as Param<'s>>::Target, &T23) -> U, F24: for<'s> FnOnce(<A as Param<'s>>::Target, &T24) -> U, F25: for<'s> FnOnce(<A as Param<'s>>::Target, &T25) -> U, F26: for<'s> FnOnce(<A as Param<'s>>::Target, &T26) -> U, F27: for<'s> FnOnce(<A as Param<'s>>::Target, &T27) -> U, F28: for<'s> FnOnce(<A as Param<'s>>::Target, &T28) -> U, F29: for<'s> FnOnce(<A as Param<'s>>::Target, &T29) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28, F29)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20), (self.21)(arg.pass(), &input.21), (self.22)(arg.pass(), &input.22), (self.23)(arg.pass(), &input.23), (self.24)(arg.pass(), &input.24), (self.25)(arg.pass(), &input.25), (self.26)(arg.pass(), &input.26), (self.27)(arg.pass(), &input.27), (self.28)(arg.pass(), &input.28), (self.29)(arg.pass(), &input.29))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, F0: for<'s> FnMut(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, &T20) -> U, F21: for<'s> FnMut(<A as Param<'s>>::Target, &T21) -> U, F22: for<'s> FnMut(<A as Param<'s>>::Target, &T22) -> U, F23: for<'s> FnMut(<A as Param<'s>>::Target, &T23) -> U, F24: for<'s> FnMut(<A as Param<'s>>::Target, &T24) -> U, F25: for<'s> FnMut(<A as Param<'s>>::Target, &T25) -> U, F26: for<'s> FnMut(<A as Param<'s>>::Target, &T26) -> U, F27: for<'s> FnMut(<A as Param<'s>>::Target, &T27) -> U, F28: for<'s> FnMut(<A as Param<'s>>::Target, &T28) -> U, F29: for<'s> FnMut(<A as Param<'s>>::Target, &T29) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28, F29)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20), (self.21)(arg.pass(), &input.21), (self.22)(arg.pass(), &input.22), (self.23)(arg.pass(), &input.23), (self.24)(arg.pass(), &input.24), (self.25)(arg.pass(), &input.25), (self.26)(arg.pass(), &input.26), (self.27)(arg.pass(), &input.27), (self.28)(arg.pass(), &input.28), (self.29)(arg.pass(), &input.29))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, F0: for<'s> Fn(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, &T20) -> U, F21: for<'s> Fn(<A as Param<'s>>::Target, &T21) -> U, F22: for<'s> Fn(<A as Param<'s>>::Target, &T22) -> U, F23: for<'s> Fn(<A as Param<'s>>::Target, &T23) -> U, F24: for<'s> Fn(<A as Param<'s>>::Target, &T24) -> U, F25: for<'s> Fn(<A as Param<'s>>::Target, &T25) -> U, F26: for<'s> Fn(<A as Param<'s>>::Target, &T26) -> U, F27: for<'s> Fn(<A as Param<'s>>::Target, &T27) -> U, F28: for<'s> Fn(<A as Param<'s>>::Target, &T28) -> U, F29: for<'s> Fn(<A as Param<'s>>::Target, &T29) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28, F29)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20), (self.21)(arg.pass(), &input.21), (self.22)(arg.pass(), &input.22), (self.23)(arg.pass(), &input.23), (self.24)(arg.pass(), &input.24), (self.25)(arg.pass(), &input.25), (self.26)(arg.pass(), &input.26), (self.27)(arg.pass(), &input.27), (self.28)(arg.pass(), &input.28), (self.29)(arg.pass(), &input.29))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T20) -> U, F21: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T21) -> U, F22: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T22) -> U, F23: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T23) -> U, F24: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T24) -> U, F25: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T25) -> U, F26: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T26) -> U, F27: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T27) -> U, F28: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T28) -> U, F29: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T29) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28, F29)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20), (self.21)(arg.pass(), &mut input.21), (self.22)(arg.pass(), &mut input.22), (self.23)(arg.pass(), &mut input.23), (self.24)(arg.pass(), &mut input.24), (self.25)(arg.pass(), &mut input.25), (self.26)(arg.pass(), &mut input.26), (self.27)(arg.pass(), &mut input.27), (self.28)(arg.pass(), &mut input.28), (self.29)(arg.pass(), &mut input.29))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, F0: for<'s> FnMut(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, &mut T20) -> U, F21: for<'s> FnMut(<A as Param<'s>>::Target, &mut T21) -> U, F22: for<'s> FnMut(<A as Param<'s>>::Target, &mut T22) -> U, F23: for<'s> FnMut(<A as Param<'s>>::Target, &mut T23) -> U, F24: for<'s> FnMut(<A as Param<'s>>::Target, &mut T24) -> U, F25: for<'s> FnMut(<A as Param<'s>>::Target, &mut T25) -> U, F26: for<'s> FnMut(<A as Param<'s>>::Target, &mut T26) -> U, F27: for<'s> FnMut(<A as Param<'s>>::Target, &mut T27) -> U, F28: for<'s> FnMut(<A as Param<'s>>::Target, &mut T28) -> U, F29: for<'s> FnMut(<A as Param<'s>>::Target, &mut T29) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28, F29)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20), (self.21)(arg.pass(), &mut input.21), (self.22)(arg.pass(), &mut input.22), (self.23)(arg.pass(), &mut input.23), (self.24)(arg.pass(), &mut input.24), (self.25)(arg.pass(), &mut input.25), (self.26)(arg.pass(), &mut input.26), (self.27)(arg.pass(), &mut input.27), (self.28)(arg.pass(), &mut input.28), (self.29)(arg.pass(), &mut input.29))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, F0: for<'s> Fn(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, &mut T20) -> U, F21: for<'s> Fn(<A as Param<'s>>::Target, &mut T21) -> U, F22: for<'s> Fn(<A as Param<'s>>::Target, &mut T22) -> U, F23: for<'s> Fn(<A as Param<'s>>::Target, &mut T23) -> U, F24: for<'s> Fn(<A as Param<'s>>::Target, &mut T24) -> U, F25: for<'s> Fn(<A as Param<'s>>::Target, &mut T25) -> U, F26: for<'s> Fn(<A as Param<'s>>::Target, &mut T26) -> U, F27: for<'s> Fn(<A as Param<'s>>::Target, &mut T27) -> U, F28: for<'s> Fn(<A as Param<'s>>::Target, &mut T28) -> U, F29: for<'s> Fn(<A as Param<'s>>::Target, &mut T29) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28, F29)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20), (self.21)(arg.pass(), &mut input.21), (self.22)(arg.pass(), &mut input.22), (self.23)(arg.pass(), &mut input.23), (self.24)(arg.pass(), &mut input.24), (self.25)(arg.pass(), &mut input.25), (self.26)(arg.pass(), &mut input.26), (self.27)(arg.pass(), &mut input.27), (self.28)(arg.pass(), &mut input.28), (self.29)(arg.pass(), &mut input.29))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, T) -> U> TupleUniformMapperBy<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), input.0), (&mut self)(arg.pass(), input.1), (&mut self)(arg.pass(), input.2), (&mut self)(arg.pass(), input.3), (&mut self)(arg.pass(), input.4), (&mut self)(arg.pass(), input.5), (&mut self)(arg.pass(), input.6), (&mut self)(arg.pass(), input.7), (&mut self)(arg.pass(), input.8), (&mut self)(arg.pass(), input.9), (&mut self)(arg.pass(), input.10), (&mut self)(arg.pass(), input.11), (&mut self)(arg.pass(), input.12), (&mut self)(arg.pass(), input.13), (&mut self)(arg.pass(), input.14), (&mut self)(arg.pass(), input.15), (&mut self)(arg.pass(), input.16), (&mut self)(arg.pass(), input.17), (&mut self)(arg.pass(), input.18), (&mut self)(arg.pass(), input.19), (&mut self)(arg.pass(), input.20), (&mut self)(arg.pass(), input.21), (&mut self)(arg.pass(), input.22), (&mut self)(arg.pass(), input.23), (&mut self)(arg.pass(), input.24), (&mut self)(arg.pass(), input.25), (&mut self)(arg.pass(), input.26), (&mut self)(arg.pass(), input.27), (&mut self)(arg.pass(), input.28), (&mut self)(arg.pass(), input.29), (&mut self)(arg.pass(), input.30))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &T) -> U> TupleUniformMapperBy<&(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &input.0), (&mut self)(arg.pass(), &input.1), (&mut self)(arg.pass(), &input.2), (&mut self)(arg.pass(), &input.3), (&mut self)(arg.pass(), &input.4), (&mut self)(arg.pass(), &input.5), (&mut self)(arg.pass(), &input.6), (&mut self)(arg.pass(), &input.7), (&mut self)(arg.pass(), &input.8), (&mut self)(arg.pass(), &input.9), (&mut self)(arg.pass(), &input.10), (&mut self)(arg.pass(), &input.11), (&mut self)(arg.pass(), &input.12), (&mut self)(arg.pass(), &input.13), (&mut self)(arg.pass(), &input.14), (&mut self)(arg.pass(), &input.15), (&mut self)(arg.pass(), &input.16), (&mut self)(arg.pass(), &input.17), (&mut self)(arg.pass(), &input.18), (&mut self)(arg.pass(), &input.19), (&mut self)(arg.pass(), &input.20), (&mut self)(arg.pass(), &input.21), (&mut self)(arg.pass(), &input.22), (&mut self)(arg.pass(), &input.23), (&mut self)(arg.pass(), &input.24), (&mut self)(arg.pass(), &input.25), (&mut self)(arg.pass(), &input.26), (&mut self)(arg.pass(), &input.27), (&mut self)(arg.pass(), &input.28), (&mut self)(arg.pass(), &input.29), (&mut self)(arg.pass(), &input.30))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &mut T) -> U> TupleUniformMapperBy<&mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &mut input.0), (&mut self)(arg.pass(), &mut input.1), (&mut self)(arg.pass(), &mut input.2), (&mut self)(arg.pass(), &mut input.3), (&mut self)(arg.pass(), &mut input.4), (&mut self)(arg.pass(), &mut input.5), (&mut self)(arg.pass(), &mut input.6), (&mut self)(arg.pass(), &mut input.7), (&mut self)(arg.pass(), &mut input.8), (&mut self)(arg.pass(), &mut input.9), (&mut self)(arg.pass(), &mut input.10), (&mut self)(arg.pass(), &mut input.11), (&mut self)(arg.pass(), &mut input.12), (&mut self)(arg.pass(), &mut input.13), (&mut self)(arg.pass(), &mut input.14), (&mut self)(arg.pass(), &mut input.15), (&mut self)(arg.pass(), &mut input.16), (&mut self)(arg.pass(), &mut input.17), (&mut self)(arg.pass(), &mut input.18), (&mut self)(arg.pass(), &mut input.19), (&mut self)(arg.pass(), &mut input.20), (&mut self)(arg.pass(), &mut input.21), (&mut self)(arg.pass(), &mut input.22), (&mut self)(arg.pass(), &mut input.23), (&mut self)(arg.pass(), &mut input.24), (&mut self)(arg.pass(), &mut input.25), (&mut self)(arg.pass(), &mut input.26), (&mut self)(arg.pass(), &mut input.27), (&mut self)(arg.pass(), &mut input.28), (&mut self)(arg.pass(), &mut input.29), (&mut self)(arg.pass(), &mut input.30))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, F0: for<'s> FnOnce(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, T20) -> U, F21: for<'s> FnOnce(<A as Param<'s>>::Target, T21) -> U, F22: for<'s> FnOnce(<A as Param<'s>>::Target, T22) -> U, F23: for<'s> FnOnce(<A as Param<'s>>::Target, T23) -> U, F24: for<'s> FnOnce(<A as Param<'s>>::Target, T24) -> U, F25: for<'s> FnOnce(<A as Param<'s>>::Target, T25) -> U, F26: for<'s> FnOnce(<A as Param<'s>>::Target, T26) -> U, F27: for<'s> FnOnce(<A as Param<'s>>::Target, T27) -> U, F28: for<'s> FnOnce(<A as Param<'s>>::Target, T28) -> U, F29: for<'s> FnOnce(<A as Param<'s>>::Target, T29) -> U, F30: for<'s> FnOnce(<A as Param<'s>>::Target, T30) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28, F29, F30)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20), (self.21)(arg.pass(), input.21), (self.22)(arg.pass(), input.22), (self.23)(arg.pass(), input.23), (self.24)(arg.pass(), input.24), (self.25)(arg.pass(), input.25), (self.26)(arg.pass(), input.26), (self.27)(arg.pass(), input.27), (self.28)(arg.pass(), input.28), (self.29)(arg.pass(), input.29), (self.30)(arg.pass(), input.30))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, F0: for<'s> FnMut(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, T20) -> U, F21: for<'s> FnMut(<A as Param<'s>>::Target, T21) -> U, F22: for<'s> FnMut(<A as Param<'s>>::Target, T22) -> U, F23: for<'s> FnMut(<A as Param<'s>>::Target, T23) -> U, F24: for<'s> FnMut(<A as Param<'s>>::Target, T24) -> U, F25: for<'s> FnMut(<A as Param<'s>>::Target, T25) -> U, F26: for<'s> FnMut(<A as Param<'s>>::Target, T26) -> U, F27: for<'s> FnMut(<A as Param<'s>>::Target, T27) -> U, F28: for<'s> FnMut(<A as Param<'s>>::Target, T28) -> U, F29: for<'s> FnMut(<A as Param<'s>>::Target, T29) -> U, F30: for<'s> FnMut(<A as Param<'s>>::Target, T30) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28, F29, F30)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20), (self.21)(arg.pass(), input.21), (self.22)(arg.pass(), input.22), (self.23)(arg.pass(), input.23), (self.24)(arg.pass(), input.24), (self.25)(arg.pass(), input.25), (self.26)(arg.pass(), input.26), (self.27)(arg.pass(), input.27), (self.28)(arg.pass(), input.28), (self.29)(arg.pass(), input.29), (self.30)(arg.pass(), input.30))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, F0: for<'s> Fn(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, T20) -> U, F21: for<'s> Fn(<A as Param<'s>>::Target, T21) -> U, F22: for<'s> Fn(<A as Param<'s>>::Target, T22) -> U, F23: for<'s> Fn(<A as Param<'s>>::Target, T23) -> U, F24: for<'s> Fn(<A as Param<'s>>::Target, T24) -> U, F25: for<'s> Fn(<A as Param<'s>>::Target, T25) -> U, F26: for<'s> Fn(<A as Param<'s>>::Target, T26) -> U, F27: for<'s> Fn(<A as Param<'s>>::Target, T27) -> U, F28: for<'s> Fn(<A as Param<'s>>::Target, T28) -> U, F29: for<'s> Fn(<A as Param<'s>>::Target, T29) -> U, F30: for<'s> Fn(<A as Param<'s>>::Target, T30) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28, F29, F30)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20), (self.21)(arg.pass(), input.21), (self.22)(arg.pass(), input.22), (self.23)(arg.pass(), input.23), (self.24)(arg.pass(), input.24), (self.25)(arg.pass(), input.25), (self.26)(arg.pass(), input.26), (self.27)(arg.pass(), input.27), (self.28)(arg.pass(), input.28), (self.29)(arg.pass(), input.29), (self.30)(arg.pass(), input.30))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, &T20) -> U, F21: for<'s> FnOnce(<A as Param<'s>>::Target, &T21) -> U, F22: for<'s> FnOnce(<A as Param<'s>>::Target, &T22) -> U, F23: for<'s> FnOnce(<A as Param<'s>>::Target, &T23) -> U, F24: for<'s> FnOnce(<A as Param<'s>>::Target, &T24) -> U, F25: for<'s> FnOnce(<A as Param<'s>>::Target, &T25) -> U, F26: for<'s> FnOnce(<A as Param<'s>>::Target, &T26) -> U, F27: for<'s> FnOnce(<A as Param<'s>>::Target, &T27) -> U, F28: for<'s> FnOnce(<A as Param<'s>>::Target, &T28) -> U, F29: for<'s> FnOnce(<A as Param<'s>>::Target, &T29) -> U, F30: for<'s> FnOnce(<A as Param<'s>>::Target, &T30) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28, F29, F30)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20), (self.21)(arg.pass(), &input.21), (self.22)(arg.pass(), &input.22), (self.23)(arg.pass(), &input.23), (self.24)(arg.pass(), &input.24), (self.25)(arg.pass(), &input.25), (self.26)(arg.pass(), &input.26), (self.27)(arg.pass(), &input.27), (self.28)(arg.pass(), &input.28), (self.29)(arg.pass(), &input.29), (self.30)(arg.pass(), &input.30))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, F0: for<'s> FnMut(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, &T20) -> U, F21: for<'s> FnMut(<A as Param<'s>>::Target, &T21) -> U, F22: for<'s> FnMut(<A as Param<'s>>::Target, &T22) -> U, F23: for<'s> FnMut(<A as Param<'s>>::Target, &T23) -> U, F24: for<'s> FnMut(<A as Param<'s>>::Target, &T24) -> U, F25: for<'s> FnMut(<A as Param<'s>>::Target, &T25) -> U, F26: for<'s> FnMut(<A as Param<'s>>::Target, &T26) -> U, F27: for<'s> FnMut(<A as Param<'s>>::Target, &T27) -> U, F28: for<'s> FnMut(<A as Param<'s>>::Target, &T28) -> U, F29: for<'s> FnMut(<A as Param<'s>>::Target, &T29) -> U, F30: for<'s> FnMut(<A as Param<'s>>::Target, &T30) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28, F29, F30)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20), (self.21)(arg.pass(), &input.21), (self.22)(arg.pass(), &input.22), (self.23)(arg.pass(), &input.23), (self.24)(arg.pass(), &input.24), (self.25)(arg.pass(), &input.25), (self.26)(arg.pass(), &input.26), (self.27)(arg.pass(), &input.27), (self.28)(arg.pass(), &input.28), (self.29)(arg.pass(), &input.29), (self.30)(arg.pass(), &input.30))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, F0: for<'s> Fn(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, &T20) -> U, F21: for<'s> Fn(<A as Param<'s>>::Target, &T21) -> U, F22: for<'s> Fn(<A as Param<'s>>::Target, &T22) -> U, F23: for<'s> Fn(<A as Param<'s>>::Target, &T23) -> U, F24: for<'s> Fn(<A as Param<'s>>::Target, &T24) -> U, F25: for<'s> Fn(<A as Param<'s>>::Target, &T25) -> U, F26: for<'s> Fn(<A as Param<'s>>::Target, &T26) -> U, F27: for<'s> Fn(<A as Param<'s>>::Target, &T27) -> U, F28: for<'s> Fn(<A as Param<'s>>::Target, &T28) -> U, F29: for<'s> Fn(<A as Param<'s>>::Target, &T29) -> U, F30: for<'s> Fn(<A as Param<'s>>::Target, &T30) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28, F29, F30)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20), (self.21)(arg.pass(), &input.21), (self.22)(arg.pass(), &input.22), (self.23)(arg.pass(), &input.23), (self.24)(arg.pass(), &input.24), (self.25)(arg.pass(), &input.25), (self.26)(arg.pass(), &input.26), (self.27)(arg.pass(), &input.27), (self.28)(arg.pass(), &input.28), (self.29)(arg.pass(), &input.29), (self.30)(arg.pass(), &input.30))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T20) -> U, F21: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T21) -> U, F22: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T22) -> U, F23: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T23) -> U, F24: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T24) -> U, F25: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T25) -> U, F26: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T26) -> U, F27: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T27) -> U, F28: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T28) -> U, F29: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T29) -> U, F30: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T30) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28, F29, F30)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20), (self.21)(arg.pass(), &mut input.21), (self.22)(arg.pass(), &mut input.22), (self.23)(arg.pass(), &mut input.23), (self.24)(arg.pass(), &mut input.24), (self.25)(arg.pass(), &mut input.25), (self.26)(arg.pass(), &mut input.26), (self.27)(arg.pass(), &mut input.27), (self.28)(arg.pass(), &mut input.28), (self.29)(arg.pass(), &mut input.29), (self.30)(arg.pass(), &mut input.30))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, F0: for<'s> FnMut(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, &mut T20) -> U, F21: for<'s> FnMut(<A as Param<'s>>::Target, &mut T21) -> U, F22: for<'s> FnMut(<A as Param<'s>>::Target, &mut T22) -> U, F23: for<'s> FnMut(<A as Param<'s>>::Target, &mut T23) -> U, F24: for<'s> FnMut(<A as Param<'s>>::Target, &mut T24) -> U, F25: for<'s> FnMut(<A as Param<'s>>::Target, &mut T25) -> U, F26: for<'s> FnMut(<A as Param<'s>>::Target, &mut T26) -> U, F27: for<'s> FnMut(<A as Param<'s>>::Target, &mut T27) -> U, F28: for<'s> FnMut(<A as Param<'s>>::Target, &mut T28) -> U, F29: for<'s> FnMut(<A as Param<'s>>::Target, &mut T29) -> U, F30: for<'s> FnMut(<A as Param<'s>>::Target, &mut T30) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28, F29, F30)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20), (self.21)(arg.pass(), &mut input.21), (self.22)(arg.pass(), &mut input.22), (self.23)(arg.pass(), &mut input.23), (self.24)(arg.pass(), &mut input.24), (self.25)(arg.pass(), &mut input.25), (self.26)(arg.pass(), &mut input.26), (self.27)(arg.pass(), &mut input.27), (self.28)(arg.pass(), &mut input.28), (self.29)(arg.pass(), &mut input.29), (self.30)(arg.pass(), &mut input.30))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, F0: for<'s> Fn(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, &mut T20) -> U, F21: for<'s> Fn(<A as Param<'s>>::Target, &mut T21) -> U, F22: for<'s> Fn(<A as Param<'s>>::Target, &mut T22) -> U, F23: for<'s> Fn(<A as Param<'s>>::Target, &mut T23) -> U, F24: for<'s> Fn(<A as Param<'s>>::Target, &mut T24) -> U, F25: for<'s> Fn(<A as Param<'s>>::Target, &mut T25) -> U, F26: for<'s> Fn(<A as Param<'s>>::Target, &mut T26) -> U, F27: for<'s> Fn(<A as Param<'s>>::Target, &mut T27) -> U, F28: for<'s> Fn(<A as Param<'s>>::Target, &mut T28) -> U, F29: for<'s> Fn(<A as Param<'s>>::Target, &mut T29) -> U, F30: for<'s> Fn(<A as Param<'s>>::Target, &mut T30) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28, F29, F30)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20), (self.21)(arg.pass(), &mut input.21), (self.22)(arg.pass(), &mut input.22), (self.23)(arg.pass(), &mut input.23), (self.24)(arg.pass(), &mut input.24), (self.25)(arg.pass(), &mut input.25), (self.26)(arg.pass(), &mut input.26), (self.27)(arg.pass(), &mut input.27), (self.28)(arg.pass(), &mut input.28), (self.29)(arg.pass(), &mut input.29), (self.30)(arg.pass(), &mut input.30))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, T) -> U> TupleUniformMapperBy<(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), input.0), (&mut self)(arg.pass(), input.1), (&mut self)(arg.pass(), input.2), (&mut self)(arg.pass(), input.3), (&mut self)(arg.pass(), input.4), (&mut self)(arg.pass(), input.5), (&mut self)(arg.pass(), input.6), (&mut self)(arg.pass(), input.7), (&mut self)(arg.pass(), input.8), (&mut self)(arg.pass(), input.9), (&mut self)(arg.pass(), input.10), (&mut self)(arg.pass(), input.11), (&mut self)(arg.pass(), input.12), (&mut self)(arg.pass(), input.13), (&mut self)(arg.pass(), input.14), (&mut self)(arg.pass(), input.15), (&mut self)(arg.pass(), input.16), (&mut self)(arg.pass(), input.17), (&mut self)(arg.pass(), input.18), (&mut self)(arg.pass(), input.19), (&mut self)(arg.pass(), input.20), (&mut self)(arg.pass(), input.21), (&mut self)(arg.pass(), input.22), (&mut self)(arg.pass(), input.23), (&mut self)(arg.pass(), input.24), (&mut self)(arg.pass(), input.25), (&mut self)(arg.pass(), input.26), (&mut self)(arg.pass(), input.27), (&mut self)(arg.pass(), input.28), (&mut self)(arg.pass(), input.29), (&mut self)(arg.pass(), input.30), (&mut self)(arg.pass(), input.31))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &T) -> U> TupleUniformMapperBy<&(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &(T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &input.0), (&mut self)(arg.pass(), &input.1), (&mut self)(arg.pass(), &input.2), (&mut self)(arg.pass(), &input.3), (&mut self)(arg.pass(), &input.4), (&mut self)(arg.pass(), &input.5), (&mut self)(arg.pass(), &input.6), (&mut self)(arg.pass(), &input.7), (&mut self)(arg.pass(), &input.8), (&mut self)(arg.pass(), &input.9), (&mut self)(arg.pass(), &input.10), (&mut self)(arg.pass(), &input.11), (&mut self)(arg.pass(), &input.12), (&mut self)(arg.pass(), &input.13), (&mut self)(arg.pass(), &input.14), (&mut self)(arg.pass(), &input.15), (&mut self)(arg.pass(), &input.16), (&mut self)(arg.pass(), &input.17), (&mut self)(arg.pass(), &input.18), (&mut self)(arg.pass(), &input.19), (&mut self)(arg.pass(), &input.20), (&mut self)(arg.pass(), &input.21), (&mut self)(arg.pass(), &input.22), (&mut self)(arg.pass(), &input.23), (&mut self)(arg.pass(), &input.24), (&mut self)(arg.pass(), &input.25), (&mut self)(arg.pass(), &input.26), (&mut self)(arg.pass(), &input.27), (&mut self)(arg.pass(), &input.28), (&mut self)(arg.pass(), &input.29), (&mut self)(arg.pass(), &input.30), (&mut self)(arg.pass(), &input.31))
    }
}
impl<A, U, T, F: for<'s> FnMut(<A as Param<'s>>::Target, &mut T) -> U> TupleUniformMapperBy<&mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T), U, A> for F
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(mut self, mut arg: A, input: &mut (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T)) -> Self::Output {
        ((&mut self)(arg.pass(), &mut input.0), (&mut self)(arg.pass(), &mut input.1), (&mut self)(arg.pass(), &mut input.2), (&mut self)(arg.pass(), &mut input.3), (&mut self)(arg.pass(), &mut input.4), (&mut self)(arg.pass(), &mut input.5), (&mut self)(arg.pass(), &mut input.6), (&mut self)(arg.pass(), &mut input.7), (&mut self)(arg.pass(), &mut input.8), (&mut self)(arg.pass(), &mut input.9), (&mut self)(arg.pass(), &mut input.10), (&mut self)(arg.pass(), &mut input.11), (&mut self)(arg.pass(), &mut input.12), (&mut self)(arg.pass(), &mut input.13), (&mut self)(arg.pass(), &mut input.14), (&mut self)(arg.pass(), &mut input.15), (&mut self)(arg.pass(), &mut input.16), (&mut self)(arg.pass(), &mut input.17), (&mut self)(arg.pass(), &mut input.18), (&mut self)(arg.pass(), &mut input.19), (&mut self)(arg.pass(), &mut input.20), (&mut self)(arg.pass(), &mut input.21), (&mut self)(arg.pass(), &mut input.22), (&mut self)(arg.pass(), &mut input.23), (&mut self)(arg.pass(), &mut input.24), (&mut self)(arg.pass(), &mut input.25), (&mut self)(arg.pass(), &mut input.26), (&mut self)(arg.pass(), &mut input.27), (&mut self)(arg.pass(), &mut input.28), (&mut self)(arg.pass(), &mut input.29), (&mut self)(arg.pass(), &mut input.30), (&mut self)(arg.pass(), &mut input.31))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, F0: for<'s> FnOnce(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, T20) -> U, F21: for<'s> FnOnce(<A as Param<'s>>::Target, T21) -> U, F22: for<'s> FnOnce(<A as Param<'s>>::Target, T22) -> U, F23: for<'s> FnOnce(<A as Param<'s>>::Target, T23) -> U, F24: for<'s> FnOnce(<A as Param<'s>>::Target, T24) -> U, F25: for<'s> FnOnce(<A as Param<'s>>::Target, T25) -> U, F26: for<'s> FnOnce(<A as Param<'s>>::Target, T26) -> U, F27: for<'s> FnOnce(<A as Param<'s>>::Target, T27) -> U, F28: for<'s> FnOnce(<A as Param<'s>>::Target, T28) -> U, F29: for<'s> FnOnce(<A as Param<'s>>::Target, T29) -> U, F30: for<'s> FnOnce(<A as Param<'s>>::Target, T30) -> U, F31: for<'s> FnOnce(<A as Param<'s>>::Target, T31) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28, F29, F30, F31)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20), (self.21)(arg.pass(), input.21), (self.22)(arg.pass(), input.22), (self.23)(arg.pass(), input.23), (self.24)(arg.pass(), input.24), (self.25)(arg.pass(), input.25), (self.26)(arg.pass(), input.26), (self.27)(arg.pass(), input.27), (self.28)(arg.pass(), input.28), (self.29)(arg.pass(), input.29), (self.30)(arg.pass(), input.30), (self.31)(arg.pass(), input.31))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, F0: for<'s> FnMut(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, T20) -> U, F21: for<'s> FnMut(<A as Param<'s>>::Target, T21) -> U, F22: for<'s> FnMut(<A as Param<'s>>::Target, T22) -> U, F23: for<'s> FnMut(<A as Param<'s>>::Target, T23) -> U, F24: for<'s> FnMut(<A as Param<'s>>::Target, T24) -> U, F25: for<'s> FnMut(<A as Param<'s>>::Target, T25) -> U, F26: for<'s> FnMut(<A as Param<'s>>::Target, T26) -> U, F27: for<'s> FnMut(<A as Param<'s>>::Target, T27) -> U, F28: for<'s> FnMut(<A as Param<'s>>::Target, T28) -> U, F29: for<'s> FnMut(<A as Param<'s>>::Target, T29) -> U, F30: for<'s> FnMut(<A as Param<'s>>::Target, T30) -> U, F31: for<'s> FnMut(<A as Param<'s>>::Target, T31) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28, F29, F30, F31)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20), (self.21)(arg.pass(), input.21), (self.22)(arg.pass(), input.22), (self.23)(arg.pass(), input.23), (self.24)(arg.pass(), input.24), (self.25)(arg.pass(), input.25), (self.26)(arg.pass(), input.26), (self.27)(arg.pass(), input.27), (self.28)(arg.pass(), input.28), (self.29)(arg.pass(), input.29), (self.30)(arg.pass(), input.30), (self.31)(arg.pass(), input.31))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, F0: for<'s> Fn(<A as Param<'s>>::Target, T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, T20) -> U, F21: for<'s> Fn(<A as Param<'s>>::Target, T21) -> U, F22: for<'s> Fn(<A as Param<'s>>::Target, T22) -> U, F23: for<'s> Fn(<A as Param<'s>>::Target, T23) -> U, F24: for<'s> Fn(<A as Param<'s>>::Target, T24) -> U, F25: for<'s> Fn(<A as Param<'s>>::Target, T25) -> U, F26: for<'s> Fn(<A as Param<'s>>::Target, T26) -> U, F27: for<'s> Fn(<A as Param<'s>>::Target, T27) -> U, F28: for<'s> Fn(<A as Param<'s>>::Target, T28) -> U, F29: for<'s> Fn(<A as Param<'s>>::Target, T29) -> U, F30: for<'s> Fn(<A as Param<'s>>::Target, T30) -> U, F31: for<'s> Fn(<A as Param<'s>>::Target, T31) -> U> TupleUniformMapperBy<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28, F29, F30, F31)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31)) -> Self::Output {
        ((self.0)(arg.pass(), input.0), (self.1)(arg.pass(), input.1), (self.2)(arg.pass(), input.2), (self.3)(arg.pass(), input.3), (self.4)(arg.pass(), input.4), (self.5)(arg.pass(), input.5), (self.6)(arg.pass(), input.6), (self.7)(arg.pass(), input.7), (self.8)(arg.pass(), input.8), (self.9)(arg.pass(), input.9), (self.10)(arg.pass(), input.10), (self.11)(arg.pass(), input.11), (self.12)(arg.pass(), input.12), (self.13)(arg.pass(), input.13), (self.14)(arg.pass(), input.14), (self.15)(arg.pass(), input.15), (self.16)(arg.pass(), input.16), (self.17)(arg.pass(), input.17), (self.18)(arg.pass(), input.18), (self.19)(arg.pass(), input.19), (self.20)(arg.pass(), input.20), (self.21)(arg.pass(), input.21), (self.22)(arg.pass(), input.22), (self.23)(arg.pass(), input.23), (self.24)(arg.pass(), input.24), (self.25)(arg.pass(), input.25), (self.26)(arg.pass(), input.26), (self.27)(arg.pass(), input.27), (self.28)(arg.pass(), input.28), (self.29)(arg.pass(), input.29), (self.30)(arg.pass(), input.30), (self.31)(arg.pass(), input.31))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, &T20) -> U, F21: for<'s> FnOnce(<A as Param<'s>>::Target, &T21) -> U, F22: for<'s> FnOnce(<A as Param<'s>>::Target, &T22) -> U, F23: for<'s> FnOnce(<A as Param<'s>>::Target, &T23) -> U, F24: for<'s> FnOnce(<A as Param<'s>>::Target, &T24) -> U, F25: for<'s> FnOnce(<A as Param<'s>>::Target, &T25) -> U, F26: for<'s> FnOnce(<A as Param<'s>>::Target, &T26) -> U, F27: for<'s> FnOnce(<A as Param<'s>>::Target, &T27) -> U, F28: for<'s> FnOnce(<A as Param<'s>>::Target, &T28) -> U, F29: for<'s> FnOnce(<A as Param<'s>>::Target, &T29) -> U, F30: for<'s> FnOnce(<A as Param<'s>>::Target, &T30) -> U, F31: for<'s> FnOnce(<A as Param<'s>>::Target, &T31) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28, F29, F30, F31)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20), (self.21)(arg.pass(), &input.21), (self.22)(arg.pass(), &input.22), (self.23)(arg.pass(), &input.23), (self.24)(arg.pass(), &input.24), (self.25)(arg.pass(), &input.25), (self.26)(arg.pass(), &input.26), (self.27)(arg.pass(), &input.27), (self.28)(arg.pass(), &input.28), (self.29)(arg.pass(), &input.29), (self.30)(arg.pass(), &input.30), (self.31)(arg.pass(), &input.31))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, F0: for<'s> FnMut(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, &T20) -> U, F21: for<'s> FnMut(<A as Param<'s>>::Target, &T21) -> U, F22: for<'s> FnMut(<A as Param<'s>>::Target, &T22) -> U, F23: for<'s> FnMut(<A as Param<'s>>::Target, &T23) -> U, F24: for<'s> FnMut(<A as Param<'s>>::Target, &T24) -> U, F25: for<'s> FnMut(<A as Param<'s>>::Target, &T25) -> U, F26: for<'s> FnMut(<A as Param<'s>>::Target, &T26) -> U, F27: for<'s> FnMut(<A as Param<'s>>::Target, &T27) -> U, F28: for<'s> FnMut(<A as Param<'s>>::Target, &T28) -> U, F29: for<'s> FnMut(<A as Param<'s>>::Target, &T29) -> U, F30: for<'s> FnMut(<A as Param<'s>>::Target, &T30) -> U, F31: for<'s> FnMut(<A as Param<'s>>::Target, &T31) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28, F29, F30, F31)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20), (self.21)(arg.pass(), &input.21), (self.22)(arg.pass(), &input.22), (self.23)(arg.pass(), &input.23), (self.24)(arg.pass(), &input.24), (self.25)(arg.pass(), &input.25), (self.26)(arg.pass(), &input.26), (self.27)(arg.pass(), &input.27), (self.28)(arg.pass(), &input.28), (self.29)(arg.pass(), &input.29), (self.30)(arg.pass(), &input.30), (self.31)(arg.pass(), &input.31))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, F0: for<'s> Fn(<A as Param<'s>>::Target, &T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, &T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, &T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, &T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, &T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, &T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, &T20) -> U, F21: for<'s> Fn(<A as Param<'s>>::Target, &T21) -> U, F22: for<'s> Fn(<A as Param<'s>>::Target, &T22) -> U, F23: for<'s> Fn(<A as Param<'s>>::Target, &T23) -> U, F24: for<'s> Fn(<A as Param<'s>>::Target, &T24) -> U, F25: for<'s> Fn(<A as Param<'s>>::Target, &T25) -> U, F26: for<'s> Fn(<A as Param<'s>>::Target, &T26) -> U, F27: for<'s> Fn(<A as Param<'s>>::Target, &T27) -> U, F28: for<'s> Fn(<A as Param<'s>>::Target, &T28) -> U, F29: for<'s> Fn(<A as Param<'s>>::Target, &T29) -> U, F30: for<'s> Fn(<A as Param<'s>>::Target, &T30) -> U, F31: for<'s> Fn(<A as Param<'s>>::Target, &T31) -> U> TupleUniformMapperBy<&(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28, F29, F30, F31)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31)) -> Self::Output {
        ((self.0)(arg.pass(), &input.0), (self.1)(arg.pass(), &input.1), (self.2)(arg.pass(), &input.2), (self.3)(arg.pass(), &input.3), (self.4)(arg.pass(), &input.4), (self.5)(arg.pass(), &input.5), (self.6)(arg.pass(), &input.6), (self.7)(arg.pass(), &input.7), (self.8)(arg.pass(), &input.8), (self.9)(arg.pass(), &input.9), (self.10)(arg.pass(), &input.10), (self.11)(arg.pass(), &input.11), (self.12)(arg.pass(), &input.12), (self.13)(arg.pass(), &input.13), (self.14)(arg.pass(), &input.14), (self.15)(arg.pass(), &input.15), (self.16)(arg.pass(), &input.16), (self.17)(arg.pass(), &input.17), (self.18)(arg.pass(), &input.18), (self.19)(arg.pass(), &input.19), (self.20)(arg.pass(), &input.20), (self.21)(arg.pass(), &input.21), (self.22)(arg.pass(), &input.22), (self.23)(arg.pass(), &input.23), (self.24)(arg.pass(), &input.24), (self.25)(arg.pass(), &input.25), (self.26)(arg.pass(), &input.26), (self.27)(arg.pass(), &input.27), (self.28)(arg.pass(), &input.28), (self.29)(arg.pass(), &input.29), (self.30)(arg.pass(), &input.30), (self.31)(arg.pass(), &input.31))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, F0: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T20) -> U, F21: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T21) -> U, F22: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T22) -> U, F23: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T23) -> U, F24: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T24) -> U, F25: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T25) -> U, F26: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T26) -> U, F27: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T27) -> U, F28: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T28) -> U, F29: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T29) -> U, F30: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T30) -> U, F31: for<'s> FnOnce(<A as Param<'s>>::Target, &mut T31) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31), U, A> for (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28, F29, F30, F31)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20), (self.21)(arg.pass(), &mut input.21), (self.22)(arg.pass(), &mut input.22), (self.23)(arg.pass(), &mut input.23), (self.24)(arg.pass(), &mut input.24), (self.25)(arg.pass(), &mut input.25), (self.26)(arg.pass(), &mut input.26), (self.27)(arg.pass(), &mut input.27), (self.28)(arg.pass(), &mut input.28), (self.29)(arg.pass(), &mut input.29), (self.30)(arg.pass(), &mut input.30), (self.31)(arg.pass(), &mut input.31))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, F0: for<'s> FnMut(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> FnMut(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> FnMut(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> FnMut(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> FnMut(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> FnMut(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> FnMut(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> FnMut(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> FnMut(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> FnMut(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> FnMut(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> FnMut(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> FnMut(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> FnMut(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> FnMut(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> FnMut(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> FnMut(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> FnMut(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> FnMut(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> FnMut(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> FnMut(<A as Param<'s>>::Target, &mut T20) -> U, F21: for<'s> FnMut(<A as Param<'s>>::Target, &mut T21) -> U, F22: for<'s> FnMut(<A as Param<'s>>::Target, &mut T22) -> U, F23: for<'s> FnMut(<A as Param<'s>>::Target, &mut T23) -> U, F24: for<'s> FnMut(<A as Param<'s>>::Target, &mut T24) -> U, F25: for<'s> FnMut(<A as Param<'s>>::Target, &mut T25) -> U, F26: for<'s> FnMut(<A as Param<'s>>::Target, &mut T26) -> U, F27: for<'s> FnMut(<A as Param<'s>>::Target, &mut T27) -> U, F28: for<'s> FnMut(<A as Param<'s>>::Target, &mut T28) -> U, F29: for<'s> FnMut(<A as Param<'s>>::Target, &mut T29) -> U, F30: for<'s> FnMut(<A as Param<'s>>::Target, &mut T30) -> U, F31: for<'s> FnMut(<A as Param<'s>>::Target, &mut T31) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31), U, A> for &mut (F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28, F29, F30, F31)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20), (self.21)(arg.pass(), &mut input.21), (self.22)(arg.pass(), &mut input.22), (self.23)(arg.pass(), &mut input.23), (self.24)(arg.pass(), &mut input.24), (self.25)(arg.pass(), &mut input.25), (self.26)(arg.pass(), &mut input.26), (self.27)(arg.pass(), &mut input.27), (self.28)(arg.pass(), &mut input.28), (self.29)(arg.pass(), &mut input.29), (self.30)(arg.pass(), &mut input.30), (self.31)(arg.pass(), &mut input.31))
    }
}
impl<A, U, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, F0: for<'s> Fn(<A as Param<'s>>::Target, &mut T0) -> U, F1: for<'s> Fn(<A as Param<'s>>::Target, &mut T1) -> U, F2: for<'s> Fn(<A as Param<'s>>::Target, &mut T2) -> U, F3: for<'s> Fn(<A as Param<'s>>::Target, &mut T3) -> U, F4: for<'s> Fn(<A as Param<'s>>::Target, &mut T4) -> U, F5: for<'s> Fn(<A as Param<'s>>::Target, &mut T5) -> U, F6: for<'s> Fn(<A as Param<'s>>::Target, &mut T6) -> U, F7: for<'s> Fn(<A as Param<'s>>::Target, &mut T7) -> U, F8: for<'s> Fn(<A as Param<'s>>::Target, &mut T8) -> U, F9: for<'s> Fn(<A as Param<'s>>::Target, &mut T9) -> U, F10: for<'s> Fn(<A as Param<'s>>::Target, &mut T10) -> U, F11: for<'s> Fn(<A as Param<'s>>::Target, &mut T11) -> U, F12: for<'s> Fn(<A as Param<'s>>::Target, &mut T12) -> U, F13: for<'s> Fn(<A as Param<'s>>::Target, &mut T13) -> U, F14: for<'s> Fn(<A as Param<'s>>::Target, &mut T14) -> U, F15: for<'s> Fn(<A as Param<'s>>::Target, &mut T15) -> U, F16: for<'s> Fn(<A as Param<'s>>::Target, &mut T16) -> U, F17: for<'s> Fn(<A as Param<'s>>::Target, &mut T17) -> U, F18: for<'s> Fn(<A as Param<'s>>::Target, &mut T18) -> U, F19: for<'s> Fn(<A as Param<'s>>::Target, &mut T19) -> U, F20: for<'s> Fn(<A as Param<'s>>::Target, &mut T20) -> U, F21: for<'s> Fn(<A as Param<'s>>::Target, &mut T21) -> U, F22: for<'s> Fn(<A as Param<'s>>::Target, &mut T22) -> U, F23: for<'s> Fn(<A as Param<'s>>::Target, &mut T23) -> U, F24: for<'s> Fn(<A as Param<'s>>::Target, &mut T24) -> U, F25: for<'s> Fn(<A as Param<'s>>::Target, &mut T25) -> U, F26: for<'s> Fn(<A as Param<'s>>::Target, &mut T26) -> U, F27: for<'s> Fn(<A as Param<'s>>::Target, &mut T27) -> U, F28: for<'s> Fn(<A as Param<'s>>::Target, &mut T28) -> U, F29: for<'s> Fn(<A as Param<'s>>::Target, &mut T29) -> U, F30: for<'s> Fn(<A as Param<'s>>::Target, &mut T30) -> U, F31: for<'s> Fn(<A as Param<'s>>::Target, &mut T31) -> U> TupleUniformMapperBy<&mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31), U, A> for &(F0, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, F19, F20, F21, F22, F23, F24, F25, F26, F27, F28, F29, F30, F31)
where
    A: for<'s> Param<'s>,
{
    type Output = (U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U);
    fn apply_uniform_map_by(self, mut arg: A, input: &mut (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31)) -> Self::Output {
        ((self.0)(arg.pass(), &mut input.0), (self.1)(arg.pass(), &mut input.1), (self.2)(arg.pass(), &mut input.2), (self.3)(arg.pass(), &mut input.3), (self.4)(arg.pass(), &mut input.4), (self.5)(arg.pass(), &mut input.5), (self.6)(arg.pass(), &mut input.6), (self.7)(arg.pass(), &mut input.7), (self.8)(arg.pass(), &mut input.8), (self.9)(arg.pass(), &mut input.9), (self.10)(arg.pass(), &mut input.10), (self.11)(arg.pass(), &mut input.11), (self.12)(arg.pass(), &mut input.12), (self.13)(arg.pass(), &mut input.13), (self.14)(arg.pass(), &mut input.14), (self.15)(arg.pass(), &mut input.15), (self.16)(arg.pass(), &mut input.16), (self.17)(arg.pass(), &mut input.17), (self.18)(arg.pass(), &mut input.18), (self.19)(arg.pass(), &mut input.19), (self.20)(arg.pass(), &mut input.20), (self.21)(arg.pass(), &mut input.21), (self.22)(arg.pass(), &mut input.22), (self.23)(arg.pass(), &mut input.23), (self.24)(arg.pass(), &mut input.24), (self.25)(arg.pass(), &mut input.25), (self.26)(arg.pass(), &mut input.26), (self.27)(arg.pass(), &mut input.27), (self.28)(arg.pass(), &mut input.28), (self.29)(arg.pass(), &mut input.29), (self.30)(arg.pass(), &mut input.30), (self.31)(arg.pass(), &mut input.31))
    }
}