aoc 2018 d5p1 in rust's type system but macros expanded

expand.rs

// 100,000 isn't actually required unless you're trying to compile with relatively large inputs
// such as the input from AoC
#![recursion_limit = "100000"]
#![allow(dead_code)]
#![allow(non_camel_case_types)]

//! The General Idea
//!
//! Associated typesin traits can be used to make type level functions. A trait of the form shown
//! below can be viewed as a function that takes one type, `Self` and returns a new type, `O`. To
//! apply this function to some type, we would simply write `<SomeType as Tr>::O`.
//! ```
//! trait Tr {
//!     type O;
//! }
//! ```
//! If we want a function that takes more than one type, we can either add them as type parameters
//! to the trait, or make Self a tuple.
//! ```
//! trait Concat<Other> {
//!     type O;
//! }
//! ```
//!
//! The Algorithm
//!
//! This uses the stack based approach to the problem, where for every unit in the polymer, you
//! push it onto the stack, and then check if the top two items of the stack should react or not
//! and remove them if they do.
//!
//! What's with Xx and Xs, why not X and Xs?
//!
//! The name `X` is taken by one of the structs generated in the zst! macro. In fact, A-Z and a-z
//! are all taken, so I can't really use single letter type parameters.

// Lists that should look familiar if you've done any sort of functional programming ;)
struct Cons<Item, Next>(std::marker::PhantomData<(Item, Next)>);
struct Nil;

// Concatenates two lists, what else can I say?
trait Concat<Other> {
    type O;
}
impl<Other> Concat<Other> for Nil {
    type O = Other;
}
// Translated to Haskell:
//
// concat (x:xs) other = x : (concat xs other)
impl<Xx, Other, Xs: Concat<Other>> Concat<Other> for Cons<Xx, Xs> {
    type O = Cons<Xx, Xs::O>;
}

// Janky method of branching
trait React<Other> {
    // Contains [] if the two units reacted, otherwise it contains [Self, Other]
    // This gets pushed to the stack
    type O;
}

// Length of a list
trait Count {
    const N: usize;
}
impl<Item, Next: Count> Count for Cons<Item, Next> {
    const N: usize = Next::N + 1;
}
impl Count for Nil {
    const N: usize = 0;
}

// This is the trait/function that actually solves the problem.
trait Go {
    type O;
}
// If the input is empty, there's nothing to do.
impl Go for Nil {
    type O = Nil;
}
// If the input is not empty, create the stack
impl<Xx, Xs> Go for Cons<Xx, Xs>
where
    (Cons<Xx, Nil>, Xs): Go,
{
    // Create the stack and start solving
    type O = <(Cons<Xx, Nil>, Xs) as Go>::O;
}
// Translated to haskell (yes argument order is backwards but there's no currying so it doesn't
// matter :P)
//
// go (stack, (x:xs)) = go ((push stack x), xs)
impl<Stack, Xx, Xs, StackO> Go for (Stack, Cons<Xx, Xs>)
where
    Stack: Push<Xx, O = StackO>,
    (StackO, Xs): Go,
{
    type O = <(StackO, Xs) as Go>::O;
}
// If there's nothing left in the input, return the stack. The length of the stack is really what
// we need.
impl<Stack> Go for (Stack, Nil) {
    type O = Stack;
}

// Push a unit to the stack and attempt to react the top two elements.
trait Push<Item> {
    type O;
}
// If the stack is empty, there's no reacting to do.
impl<Item> Push<Item> for Nil {
    type O = Cons<Item, Nil>;
}
impl<ItemA, ItemB, Xs> Push<ItemA> for Cons<ItemB, Xs>
where
    ItemA: React<ItemB>, // ItemA::O will either be [] or [ItemA, ItemB] depending on the reaction.
    ItemA::O: Concat<Xs>, // The tail is concatenated to the result of the reaction.
{
    type O = <ItemA::O as Concat<Xs>>::O;
}

fn main() {
    type Input = Cons<
        a,
        Cons<
            a,
            Cons<
                B,
                Cons<
                    c,
                    Cons<C, Cons<c, Cons<b, Cons<B, Cons<C, Cons<d, Cons<D, Cons<f, Nil>>>>>>>>,
                >,
            >,
        >,
    >;

    println!("{}", <Input as Go>::O::N);
}

struct a;
impl React<A> for a {
    type O = Nil;
}
impl React<a> for a {
    type O = Cons<a, Cons<a, Nil>>;
}
impl React<b> for a {
    type O = Cons<a, Cons<b, Nil>>;
}
impl React<c> for a {
    type O = Cons<a, Cons<c, Nil>>;
}
impl React<d> for a {
    type O = Cons<a, Cons<d, Nil>>;
}
impl React<e> for a {
    type O = Cons<a, Cons<e, Nil>>;
}
impl React<f> for a {
    type O = Cons<a, Cons<f, Nil>>;
}
impl React<g> for a {
    type O = Cons<a, Cons<g, Nil>>;
}
impl React<h> for a {
    type O = Cons<a, Cons<h, Nil>>;
}
impl React<i> for a {
    type O = Cons<a, Cons<i, Nil>>;
}
impl React<j> for a {
    type O = Cons<a, Cons<j, Nil>>;
}
impl React<k> for a {
    type O = Cons<a, Cons<k, Nil>>;
}
impl React<l> for a {
    type O = Cons<a, Cons<l, Nil>>;
}
impl React<m> for a {
    type O = Cons<a, Cons<m, Nil>>;
}
impl React<n> for a {
    type O = Cons<a, Cons<n, Nil>>;
}
impl React<o> for a {
    type O = Cons<a, Cons<o, Nil>>;
}
impl React<p> for a {
    type O = Cons<a, Cons<p, Nil>>;
}
impl React<q> for a {
    type O = Cons<a, Cons<q, Nil>>;
}
impl React<r> for a {
    type O = Cons<a, Cons<r, Nil>>;
}
impl React<s> for a {
    type O = Cons<a, Cons<s, Nil>>;
}
impl React<t> for a {
    type O = Cons<a, Cons<t, Nil>>;
}
impl React<u> for a {
    type O = Cons<a, Cons<u, Nil>>;
}
impl React<v> for a {
    type O = Cons<a, Cons<v, Nil>>;
}
impl React<w> for a {
    type O = Cons<a, Cons<w, Nil>>;
}
impl React<x> for a {
    type O = Cons<a, Cons<x, Nil>>;
}
impl React<y> for a {
    type O = Cons<a, Cons<y, Nil>>;
}
impl React<z> for a {
    type O = Cons<a, Cons<z, Nil>>;
}
impl React<B> for a {
    type O = Cons<a, Cons<B, Nil>>;
}
impl React<C> for a {
    type O = Cons<a, Cons<C, Nil>>;
}
impl React<D> for a {
    type O = Cons<a, Cons<D, Nil>>;
}
impl React<E> for a {
    type O = Cons<a, Cons<E, Nil>>;
}
impl React<F> for a {
    type O = Cons<a, Cons<F, Nil>>;
}
impl React<G> for a {
    type O = Cons<a, Cons<G, Nil>>;
}
impl React<H> for a {
    type O = Cons<a, Cons<H, Nil>>;
}
impl React<I> for a {
    type O = Cons<a, Cons<I, Nil>>;
}
impl React<J> for a {
    type O = Cons<a, Cons<J, Nil>>;
}
impl React<K> for a {
    type O = Cons<a, Cons<K, Nil>>;
}
impl React<L> for a {
    type O = Cons<a, Cons<L, Nil>>;
}
impl React<M> for a {
    type O = Cons<a, Cons<M, Nil>>;
}
impl React<N> for a {
    type O = Cons<a, Cons<N, Nil>>;
}
impl React<O> for a {
    type O = Cons<a, Cons<O, Nil>>;
}
impl React<P> for a {
    type O = Cons<a, Cons<P, Nil>>;
}
impl React<Q> for a {
    type O = Cons<a, Cons<Q, Nil>>;
}
impl React<R> for a {
    type O = Cons<a, Cons<R, Nil>>;
}
impl React<S> for a {
    type O = Cons<a, Cons<S, Nil>>;
}
impl React<T> for a {
    type O = Cons<a, Cons<T, Nil>>;
}
impl React<U> for a {
    type O = Cons<a, Cons<U, Nil>>;
}
impl React<V> for a {
    type O = Cons<a, Cons<V, Nil>>;
}
impl React<W> for a {
    type O = Cons<a, Cons<W, Nil>>;
}
impl React<X> for a {
    type O = Cons<a, Cons<X, Nil>>;
}
impl React<Y> for a {
    type O = Cons<a, Cons<Y, Nil>>;
}
impl React<Z> for a {
    type O = Cons<a, Cons<Z, Nil>>;
}
struct b;
impl React<B> for b {
    type O = Nil;
}
impl React<a> for b {
    type O = Cons<b, Cons<a, Nil>>;
}
impl React<b> for b {
    type O = Cons<b, Cons<b, Nil>>;
}
impl React<c> for b {
    type O = Cons<b, Cons<c, Nil>>;
}
impl React<d> for b {
    type O = Cons<b, Cons<d, Nil>>;
}
impl React<e> for b {
    type O = Cons<b, Cons<e, Nil>>;
}
impl React<f> for b {
    type O = Cons<b, Cons<f, Nil>>;
}
impl React<g> for b {
    type O = Cons<b, Cons<g, Nil>>;
}
impl React<h> for b {
    type O = Cons<b, Cons<h, Nil>>;
}
impl React<i> for b {
    type O = Cons<b, Cons<i, Nil>>;
}
impl React<j> for b {
    type O = Cons<b, Cons<j, Nil>>;
}
impl React<k> for b {
    type O = Cons<b, Cons<k, Nil>>;
}
impl React<l> for b {
    type O = Cons<b, Cons<l, Nil>>;
}
impl React<m> for b {
    type O = Cons<b, Cons<m, Nil>>;
}
impl React<n> for b {
    type O = Cons<b, Cons<n, Nil>>;
}
impl React<o> for b {
    type O = Cons<b, Cons<o, Nil>>;
}
impl React<p> for b {
    type O = Cons<b, Cons<p, Nil>>;
}
impl React<q> for b {
    type O = Cons<b, Cons<q, Nil>>;
}
impl React<r> for b {
    type O = Cons<b, Cons<r, Nil>>;
}
impl React<s> for b {
    type O = Cons<b, Cons<s, Nil>>;
}
impl React<t> for b {
    type O = Cons<b, Cons<t, Nil>>;
}
impl React<u> for b {
    type O = Cons<b, Cons<u, Nil>>;
}
impl React<v> for b {
    type O = Cons<b, Cons<v, Nil>>;
}
impl React<w> for b {
    type O = Cons<b, Cons<w, Nil>>;
}
impl React<x> for b {
    type O = Cons<b, Cons<x, Nil>>;
}
impl React<y> for b {
    type O = Cons<b, Cons<y, Nil>>;
}
impl React<z> for b {
    type O = Cons<b, Cons<z, Nil>>;
}
impl React<A> for b {
    type O = Cons<b, Cons<A, Nil>>;
}
impl React<C> for b {
    type O = Cons<b, Cons<C, Nil>>;
}
impl React<D> for b {
    type O = Cons<b, Cons<D, Nil>>;
}
impl React<E> for b {
    type O = Cons<b, Cons<E, Nil>>;
}
impl React<F> for b {
    type O = Cons<b, Cons<F, Nil>>;
}
impl React<G> for b {
    type O = Cons<b, Cons<G, Nil>>;
}
impl React<H> for b {
    type O = Cons<b, Cons<H, Nil>>;
}
impl React<I> for b {
    type O = Cons<b, Cons<I, Nil>>;
}
impl React<J> for b {
    type O = Cons<b, Cons<J, Nil>>;
}
impl React<K> for b {
    type O = Cons<b, Cons<K, Nil>>;
}
impl React<L> for b {
    type O = Cons<b, Cons<L, Nil>>;
}
impl React<M> for b {
    type O = Cons<b, Cons<M, Nil>>;
}
impl React<N> for b {
    type O = Cons<b, Cons<N, Nil>>;
}
impl React<O> for b {
    type O = Cons<b, Cons<O, Nil>>;
}
impl React<P> for b {
    type O = Cons<b, Cons<P, Nil>>;
}
impl React<Q> for b {
    type O = Cons<b, Cons<Q, Nil>>;
}
impl React<R> for b {
    type O = Cons<b, Cons<R, Nil>>;
}
impl React<S> for b {
    type O = Cons<b, Cons<S, Nil>>;
}
impl React<T> for b {
    type O = Cons<b, Cons<T, Nil>>;
}
impl React<U> for b {
    type O = Cons<b, Cons<U, Nil>>;
}
impl React<V> for b {
    type O = Cons<b, Cons<V, Nil>>;
}
impl React<W> for b {
    type O = Cons<b, Cons<W, Nil>>;
}
impl React<X> for b {
    type O = Cons<b, Cons<X, Nil>>;
}
impl React<Y> for b {
    type O = Cons<b, Cons<Y, Nil>>;
}
impl React<Z> for b {
    type O = Cons<b, Cons<Z, Nil>>;
}
struct c;
impl React<C> for c {
    type O = Nil;
}
impl React<a> for c {
    type O = Cons<c, Cons<a, Nil>>;
}
impl React<b> for c {
    type O = Cons<c, Cons<b, Nil>>;
}
impl React<c> for c {
    type O = Cons<c, Cons<c, Nil>>;
}
impl React<d> for c {
    type O = Cons<c, Cons<d, Nil>>;
}
impl React<e> for c {
    type O = Cons<c, Cons<e, Nil>>;
}
impl React<f> for c {
    type O = Cons<c, Cons<f, Nil>>;
}
impl React<g> for c {
    type O = Cons<c, Cons<g, Nil>>;
}
impl React<h> for c {
    type O = Cons<c, Cons<h, Nil>>;
}
impl React<i> for c {
    type O = Cons<c, Cons<i, Nil>>;
}
impl React<j> for c {
    type O = Cons<c, Cons<j, Nil>>;
}
impl React<k> for c {
    type O = Cons<c, Cons<k, Nil>>;
}
impl React<l> for c {
    type O = Cons<c, Cons<l, Nil>>;
}
impl React<m> for c {
    type O = Cons<c, Cons<m, Nil>>;
}
impl React<n> for c {
    type O = Cons<c, Cons<n, Nil>>;
}
impl React<o> for c {
    type O = Cons<c, Cons<o, Nil>>;
}
impl React<p> for c {
    type O = Cons<c, Cons<p, Nil>>;
}
impl React<q> for c {
    type O = Cons<c, Cons<q, Nil>>;
}
impl React<r> for c {
    type O = Cons<c, Cons<r, Nil>>;
}
impl React<s> for c {
    type O = Cons<c, Cons<s, Nil>>;
}
impl React<t> for c {
    type O = Cons<c, Cons<t, Nil>>;
}
impl React<u> for c {
    type O = Cons<c, Cons<u, Nil>>;
}
impl React<v> for c {
    type O = Cons<c, Cons<v, Nil>>;
}
impl React<w> for c {
    type O = Cons<c, Cons<w, Nil>>;
}
impl React<x> for c {
    type O = Cons<c, Cons<x, Nil>>;
}
impl React<y> for c {
    type O = Cons<c, Cons<y, Nil>>;
}
impl React<z> for c {
    type O = Cons<c, Cons<z, Nil>>;
}
impl React<A> for c {
    type O = Cons<c, Cons<A, Nil>>;
}
impl React<B> for c {
    type O = Cons<c, Cons<B, Nil>>;
}
impl React<D> for c {
    type O = Cons<c, Cons<D, Nil>>;
}
impl React<E> for c {
    type O = Cons<c, Cons<E, Nil>>;
}
impl React<F> for c {
    type O = Cons<c, Cons<F, Nil>>;
}
impl React<G> for c {
    type O = Cons<c, Cons<G, Nil>>;
}
impl React<H> for c {
    type O = Cons<c, Cons<H, Nil>>;
}
impl React<I> for c {
    type O = Cons<c, Cons<I, Nil>>;
}
impl React<J> for c {
    type O = Cons<c, Cons<J, Nil>>;
}
impl React<K> for c {
    type O = Cons<c, Cons<K, Nil>>;
}
impl React<L> for c {
    type O = Cons<c, Cons<L, Nil>>;
}
impl React<M> for c {
    type O = Cons<c, Cons<M, Nil>>;
}
impl React<N> for c {
    type O = Cons<c, Cons<N, Nil>>;
}
impl React<O> for c {
    type O = Cons<c, Cons<O, Nil>>;
}
impl React<P> for c {
    type O = Cons<c, Cons<P, Nil>>;
}
impl React<Q> for c {
    type O = Cons<c, Cons<Q, Nil>>;
}
impl React<R> for c {
    type O = Cons<c, Cons<R, Nil>>;
}
impl React<S> for c {
    type O = Cons<c, Cons<S, Nil>>;
}
impl React<T> for c {
    type O = Cons<c, Cons<T, Nil>>;
}
impl React<U> for c {
    type O = Cons<c, Cons<U, Nil>>;
}
impl React<V> for c {
    type O = Cons<c, Cons<V, Nil>>;
}
impl React<W> for c {
    type O = Cons<c, Cons<W, Nil>>;
}
impl React<X> for c {
    type O = Cons<c, Cons<X, Nil>>;
}
impl React<Y> for c {
    type O = Cons<c, Cons<Y, Nil>>;
}
impl React<Z> for c {
    type O = Cons<c, Cons<Z, Nil>>;
}
struct d;
impl React<D> for d {
    type O = Nil;
}
impl React<a> for d {
    type O = Cons<d, Cons<a, Nil>>;
}
impl React<b> for d {
    type O = Cons<d, Cons<b, Nil>>;
}
impl React<c> for d {
    type O = Cons<d, Cons<c, Nil>>;
}
impl React<d> for d {
    type O = Cons<d, Cons<d, Nil>>;
}
impl React<e> for d {
    type O = Cons<d, Cons<e, Nil>>;
}
impl React<f> for d {
    type O = Cons<d, Cons<f, Nil>>;
}
impl React<g> for d {
    type O = Cons<d, Cons<g, Nil>>;
}
impl React<h> for d {
    type O = Cons<d, Cons<h, Nil>>;
}
impl React<i> for d {
    type O = Cons<d, Cons<i, Nil>>;
}
impl React<j> for d {
    type O = Cons<d, Cons<j, Nil>>;
}
impl React<k> for d {
    type O = Cons<d, Cons<k, Nil>>;
}
impl React<l> for d {
    type O = Cons<d, Cons<l, Nil>>;
}
impl React<m> for d {
    type O = Cons<d, Cons<m, Nil>>;
}
impl React<n> for d {
    type O = Cons<d, Cons<n, Nil>>;
}
impl React<o> for d {
    type O = Cons<d, Cons<o, Nil>>;
}
impl React<p> for d {
    type O = Cons<d, Cons<p, Nil>>;
}
impl React<q> for d {
    type O = Cons<d, Cons<q, Nil>>;
}
impl React<r> for d {
    type O = Cons<d, Cons<r, Nil>>;
}
impl React<s> for d {
    type O = Cons<d, Cons<s, Nil>>;
}
impl React<t> for d {
    type O = Cons<d, Cons<t, Nil>>;
}
impl React<u> for d {
    type O = Cons<d, Cons<u, Nil>>;
}
impl React<v> for d {
    type O = Cons<d, Cons<v, Nil>>;
}
impl React<w> for d {
    type O = Cons<d, Cons<w, Nil>>;
}
impl React<x> for d {
    type O = Cons<d, Cons<x, Nil>>;
}
impl React<y> for d {
    type O = Cons<d, Cons<y, Nil>>;
}
impl React<z> for d {
    type O = Cons<d, Cons<z, Nil>>;
}
impl React<A> for d {
    type O = Cons<d, Cons<A, Nil>>;
}
impl React<B> for d {
    type O = Cons<d, Cons<B, Nil>>;
}
impl React<C> for d {
    type O = Cons<d, Cons<C, Nil>>;
}
impl React<E> for d {
    type O = Cons<d, Cons<E, Nil>>;
}
impl React<F> for d {
    type O = Cons<d, Cons<F, Nil>>;
}
impl React<G> for d {
    type O = Cons<d, Cons<G, Nil>>;
}
impl React<H> for d {
    type O = Cons<d, Cons<H, Nil>>;
}
impl React<I> for d {
    type O = Cons<d, Cons<I, Nil>>;
}
impl React<J> for d {
    type O = Cons<d, Cons<J, Nil>>;
}
impl React<K> for d {
    type O = Cons<d, Cons<K, Nil>>;
}
impl React<L> for d {
    type O = Cons<d, Cons<L, Nil>>;
}
impl React<M> for d {
    type O = Cons<d, Cons<M, Nil>>;
}
impl React<N> for d {
    type O = Cons<d, Cons<N, Nil>>;
}
impl React<O> for d {
    type O = Cons<d, Cons<O, Nil>>;
}
impl React<P> for d {
    type O = Cons<d, Cons<P, Nil>>;
}
impl React<Q> for d {
    type O = Cons<d, Cons<Q, Nil>>;
}
impl React<R> for d {
    type O = Cons<d, Cons<R, Nil>>;
}
impl React<S> for d {
    type O = Cons<d, Cons<S, Nil>>;
}
impl React<T> for d {
    type O = Cons<d, Cons<T, Nil>>;
}
impl React<U> for d {
    type O = Cons<d, Cons<U, Nil>>;
}
impl React<V> for d {
    type O = Cons<d, Cons<V, Nil>>;
}
impl React<W> for d {
    type O = Cons<d, Cons<W, Nil>>;
}
impl React<X> for d {
    type O = Cons<d, Cons<X, Nil>>;
}
impl React<Y> for d {
    type O = Cons<d, Cons<Y, Nil>>;
}
impl React<Z> for d {
    type O = Cons<d, Cons<Z, Nil>>;
}
struct e;
impl React<E> for e {
    type O = Nil;
}
impl React<a> for e {
    type O = Cons<e, Cons<a, Nil>>;
}
impl React<b> for e {
    type O = Cons<e, Cons<b, Nil>>;
}
impl React<c> for e {
    type O = Cons<e, Cons<c, Nil>>;
}
impl React<d> for e {
    type O = Cons<e, Cons<d, Nil>>;
}
impl React<e> for e {
    type O = Cons<e, Cons<e, Nil>>;
}
impl React<f> for e {
    type O = Cons<e, Cons<f, Nil>>;
}
impl React<g> for e {
    type O = Cons<e, Cons<g, Nil>>;
}
impl React<h> for e {
    type O = Cons<e, Cons<h, Nil>>;
}
impl React<i> for e {
    type O = Cons<e, Cons<i, Nil>>;
}
impl React<j> for e {
    type O = Cons<e, Cons<j, Nil>>;
}
impl React<k> for e {
    type O = Cons<e, Cons<k, Nil>>;
}
impl React<l> for e {
    type O = Cons<e, Cons<l, Nil>>;
}
impl React<m> for e {
    type O = Cons<e, Cons<m, Nil>>;
}
impl React<n> for e {
    type O = Cons<e, Cons<n, Nil>>;
}
impl React<o> for e {
    type O = Cons<e, Cons<o, Nil>>;
}
impl React<p> for e {
    type O = Cons<e, Cons<p, Nil>>;
}
impl React<q> for e {
    type O = Cons<e, Cons<q, Nil>>;
}
impl React<r> for e {
    type O = Cons<e, Cons<r, Nil>>;
}
impl React<s> for e {
    type O = Cons<e, Cons<s, Nil>>;
}
impl React<t> for e {
    type O = Cons<e, Cons<t, Nil>>;
}
impl React<u> for e {
    type O = Cons<e, Cons<u, Nil>>;
}
impl React<v> for e {
    type O = Cons<e, Cons<v, Nil>>;
}
impl React<w> for e {
    type O = Cons<e, Cons<w, Nil>>;
}
impl React<x> for e {
    type O = Cons<e, Cons<x, Nil>>;
}
impl React<y> for e {
    type O = Cons<e, Cons<y, Nil>>;
}
impl React<z> for e {
    type O = Cons<e, Cons<z, Nil>>;
}
impl React<A> for e {
    type O = Cons<e, Cons<A, Nil>>;
}
impl React<B> for e {
    type O = Cons<e, Cons<B, Nil>>;
}
impl React<C> for e {
    type O = Cons<e, Cons<C, Nil>>;
}
impl React<D> for e {
    type O = Cons<e, Cons<D, Nil>>;
}
impl React<F> for e {
    type O = Cons<e, Cons<F, Nil>>;
}
impl React<G> for e {
    type O = Cons<e, Cons<G, Nil>>;
}
impl React<H> for e {
    type O = Cons<e, Cons<H, Nil>>;
}
impl React<I> for e {
    type O = Cons<e, Cons<I, Nil>>;
}
impl React<J> for e {
    type O = Cons<e, Cons<J, Nil>>;
}
impl React<K> for e {
    type O = Cons<e, Cons<K, Nil>>;
}
impl React<L> for e {
    type O = Cons<e, Cons<L, Nil>>;
}
impl React<M> for e {
    type O = Cons<e, Cons<M, Nil>>;
}
impl React<N> for e {
    type O = Cons<e, Cons<N, Nil>>;
}
impl React<O> for e {
    type O = Cons<e, Cons<O, Nil>>;
}
impl React<P> for e {
    type O = Cons<e, Cons<P, Nil>>;
}
impl React<Q> for e {
    type O = Cons<e, Cons<Q, Nil>>;
}
impl React<R> for e {
    type O = Cons<e, Cons<R, Nil>>;
}
impl React<S> for e {
    type O = Cons<e, Cons<S, Nil>>;
}
impl React<T> for e {
    type O = Cons<e, Cons<T, Nil>>;
}
impl React<U> for e {
    type O = Cons<e, Cons<U, Nil>>;
}
impl React<V> for e {
    type O = Cons<e, Cons<V, Nil>>;
}
impl React<W> for e {
    type O = Cons<e, Cons<W, Nil>>;
}
impl React<X> for e {
    type O = Cons<e, Cons<X, Nil>>;
}
impl React<Y> for e {
    type O = Cons<e, Cons<Y, Nil>>;
}
impl React<Z> for e {
    type O = Cons<e, Cons<Z, Nil>>;
}
struct f;
impl React<F> for f {
    type O = Nil;
}
impl React<a> for f {
    type O = Cons<f, Cons<a, Nil>>;
}
impl React<b> for f {
    type O = Cons<f, Cons<b, Nil>>;
}
impl React<c> for f {
    type O = Cons<f, Cons<c, Nil>>;
}
impl React<d> for f {
    type O = Cons<f, Cons<d, Nil>>;
}
impl React<e> for f {
    type O = Cons<f, Cons<e, Nil>>;
}
impl React<f> for f {
    type O = Cons<f, Cons<f, Nil>>;
}
impl React<g> for f {
    type O = Cons<f, Cons<g, Nil>>;
}
impl React<h> for f {
    type O = Cons<f, Cons<h, Nil>>;
}
impl React<i> for f {
    type O = Cons<f, Cons<i, Nil>>;
}
impl React<j> for f {
    type O = Cons<f, Cons<j, Nil>>;
}
impl React<k> for f {
    type O = Cons<f, Cons<k, Nil>>;
}
impl React<l> for f {
    type O = Cons<f, Cons<l, Nil>>;
}
impl React<m> for f {
    type O = Cons<f, Cons<m, Nil>>;
}
impl React<n> for f {
    type O = Cons<f, Cons<n, Nil>>;
}
impl React<o> for f {
    type O = Cons<f, Cons<o, Nil>>;
}
impl React<p> for f {
    type O = Cons<f, Cons<p, Nil>>;
}
impl React<q> for f {
    type O = Cons<f, Cons<q, Nil>>;
}
impl React<r> for f {
    type O = Cons<f, Cons<r, Nil>>;
}
impl React<s> for f {
    type O = Cons<f, Cons<s, Nil>>;
}
impl React<t> for f {
    type O = Cons<f, Cons<t, Nil>>;
}
impl React<u> for f {
    type O = Cons<f, Cons<u, Nil>>;
}
impl React<v> for f {
    type O = Cons<f, Cons<v, Nil>>;
}
impl React<w> for f {
    type O = Cons<f, Cons<w, Nil>>;
}
impl React<x> for f {
    type O = Cons<f, Cons<x, Nil>>;
}
impl React<y> for f {
    type O = Cons<f, Cons<y, Nil>>;
}
impl React<z> for f {
    type O = Cons<f, Cons<z, Nil>>;
}
impl React<A> for f {
    type O = Cons<f, Cons<A, Nil>>;
}
impl React<B> for f {
    type O = Cons<f, Cons<B, Nil>>;
}
impl React<C> for f {
    type O = Cons<f, Cons<C, Nil>>;
}
impl React<D> for f {
    type O = Cons<f, Cons<D, Nil>>;
}
impl React<E> for f {
    type O = Cons<f, Cons<E, Nil>>;
}
impl React<G> for f {
    type O = Cons<f, Cons<G, Nil>>;
}
impl React<H> for f {
    type O = Cons<f, Cons<H, Nil>>;
}
impl React<I> for f {
    type O = Cons<f, Cons<I, Nil>>;
}
impl React<J> for f {
    type O = Cons<f, Cons<J, Nil>>;
}
impl React<K> for f {
    type O = Cons<f, Cons<K, Nil>>;
}
impl React<L> for f {
    type O = Cons<f, Cons<L, Nil>>;
}
impl React<M> for f {
    type O = Cons<f, Cons<M, Nil>>;
}
impl React<N> for f {
    type O = Cons<f, Cons<N, Nil>>;
}
impl React<O> for f {
    type O = Cons<f, Cons<O, Nil>>;
}
impl React<P> for f {
    type O = Cons<f, Cons<P, Nil>>;
}
impl React<Q> for f {
    type O = Cons<f, Cons<Q, Nil>>;
}
impl React<R> for f {
    type O = Cons<f, Cons<R, Nil>>;
}
impl React<S> for f {
    type O = Cons<f, Cons<S, Nil>>;
}
impl React<T> for f {
    type O = Cons<f, Cons<T, Nil>>;
}
impl React<U> for f {
    type O = Cons<f, Cons<U, Nil>>;
}
impl React<V> for f {
    type O = Cons<f, Cons<V, Nil>>;
}
impl React<W> for f {
    type O = Cons<f, Cons<W, Nil>>;
}
impl React<X> for f {
    type O = Cons<f, Cons<X, Nil>>;
}
impl React<Y> for f {
    type O = Cons<f, Cons<Y, Nil>>;
}
impl React<Z> for f {
    type O = Cons<f, Cons<Z, Nil>>;
}
struct g;
impl React<G> for g {
    type O = Nil;
}
impl React<a> for g {
    type O = Cons<g, Cons<a, Nil>>;
}
impl React<b> for g {
    type O = Cons<g, Cons<b, Nil>>;
}
impl React<c> for g {
    type O = Cons<g, Cons<c, Nil>>;
}
impl React<d> for g {
    type O = Cons<g, Cons<d, Nil>>;
}
impl React<e> for g {
    type O = Cons<g, Cons<e, Nil>>;
}
impl React<f> for g {
    type O = Cons<g, Cons<f, Nil>>;
}
impl React<g> for g {
    type O = Cons<g, Cons<g, Nil>>;
}
impl React<h> for g {
    type O = Cons<g, Cons<h, Nil>>;
}
impl React<i> for g {
    type O = Cons<g, Cons<i, Nil>>;
}
impl React<j> for g {
    type O = Cons<g, Cons<j, Nil>>;
}
impl React<k> for g {
    type O = Cons<g, Cons<k, Nil>>;
}
impl React<l> for g {
    type O = Cons<g, Cons<l, Nil>>;
}
impl React<m> for g {
    type O = Cons<g, Cons<m, Nil>>;
}
impl React<n> for g {
    type O = Cons<g, Cons<n, Nil>>;
}
impl React<o> for g {
    type O = Cons<g, Cons<o, Nil>>;
}
impl React<p> for g {
    type O = Cons<g, Cons<p, Nil>>;
}
impl React<q> for g {
    type O = Cons<g, Cons<q, Nil>>;
}
impl React<r> for g {
    type O = Cons<g, Cons<r, Nil>>;
}
impl React<s> for g {
    type O = Cons<g, Cons<s, Nil>>;
}
impl React<t> for g {
    type O = Cons<g, Cons<t, Nil>>;
}
impl React<u> for g {
    type O = Cons<g, Cons<u, Nil>>;
}
impl React<v> for g {
    type O = Cons<g, Cons<v, Nil>>;
}
impl React<w> for g {
    type O = Cons<g, Cons<w, Nil>>;
}
impl React<x> for g {
    type O = Cons<g, Cons<x, Nil>>;
}
impl React<y> for g {
    type O = Cons<g, Cons<y, Nil>>;
}
impl React<z> for g {
    type O = Cons<g, Cons<z, Nil>>;
}
impl React<A> for g {
    type O = Cons<g, Cons<A, Nil>>;
}
impl React<B> for g {
    type O = Cons<g, Cons<B, Nil>>;
}
impl React<C> for g {
    type O = Cons<g, Cons<C, Nil>>;
}
impl React<D> for g {
    type O = Cons<g, Cons<D, Nil>>;
}
impl React<E> for g {
    type O = Cons<g, Cons<E, Nil>>;
}
impl React<F> for g {
    type O = Cons<g, Cons<F, Nil>>;
}
impl React<H> for g {
    type O = Cons<g, Cons<H, Nil>>;
}
impl React<I> for g {
    type O = Cons<g, Cons<I, Nil>>;
}
impl React<J> for g {
    type O = Cons<g, Cons<J, Nil>>;
}
impl React<K> for g {
    type O = Cons<g, Cons<K, Nil>>;
}
impl React<L> for g {
    type O = Cons<g, Cons<L, Nil>>;
}
impl React<M> for g {
    type O = Cons<g, Cons<M, Nil>>;
}
impl React<N> for g {
    type O = Cons<g, Cons<N, Nil>>;
}
impl React<O> for g {
    type O = Cons<g, Cons<O, Nil>>;
}
impl React<P> for g {
    type O = Cons<g, Cons<P, Nil>>;
}
impl React<Q> for g {
    type O = Cons<g, Cons<Q, Nil>>;
}
impl React<R> for g {
    type O = Cons<g, Cons<R, Nil>>;
}
impl React<S> for g {
    type O = Cons<g, Cons<S, Nil>>;
}
impl React<T> for g {
    type O = Cons<g, Cons<T, Nil>>;
}
impl React<U> for g {
    type O = Cons<g, Cons<U, Nil>>;
}
impl React<V> for g {
    type O = Cons<g, Cons<V, Nil>>;
}
impl React<W> for g {
    type O = Cons<g, Cons<W, Nil>>;
}
impl React<X> for g {
    type O = Cons<g, Cons<X, Nil>>;
}
impl React<Y> for g {
    type O = Cons<g, Cons<Y, Nil>>;
}
impl React<Z> for g {
    type O = Cons<g, Cons<Z, Nil>>;
}
struct h;
impl React<H> for h {
    type O = Nil;
}
impl React<a> for h {
    type O = Cons<h, Cons<a, Nil>>;
}
impl React<b> for h {
    type O = Cons<h, Cons<b, Nil>>;
}
impl React<c> for h {
    type O = Cons<h, Cons<c, Nil>>;
}
impl React<d> for h {
    type O = Cons<h, Cons<d, Nil>>;
}
impl React<e> for h {
    type O = Cons<h, Cons<e, Nil>>;
}
impl React<f> for h {
    type O = Cons<h, Cons<f, Nil>>;
}
impl React<g> for h {
    type O = Cons<h, Cons<g, Nil>>;
}
impl React<h> for h {
    type O = Cons<h, Cons<h, Nil>>;
}
impl React<i> for h {
    type O = Cons<h, Cons<i, Nil>>;
}
impl React<j> for h {
    type O = Cons<h, Cons<j, Nil>>;
}
impl React<k> for h {
    type O = Cons<h, Cons<k, Nil>>;
}
impl React<l> for h {
    type O = Cons<h, Cons<l, Nil>>;
}
impl React<m> for h {
    type O = Cons<h, Cons<m, Nil>>;
}
impl React<n> for h {
    type O = Cons<h, Cons<n, Nil>>;
}
impl React<o> for h {
    type O = Cons<h, Cons<o, Nil>>;
}
impl React<p> for h {
    type O = Cons<h, Cons<p, Nil>>;
}
impl React<q> for h {
    type O = Cons<h, Cons<q, Nil>>;
}
impl React<r> for h {
    type O = Cons<h, Cons<r, Nil>>;
}
impl React<s> for h {
    type O = Cons<h, Cons<s, Nil>>;
}
impl React<t> for h {
    type O = Cons<h, Cons<t, Nil>>;
}
impl React<u> for h {
    type O = Cons<h, Cons<u, Nil>>;
}
impl React<v> for h {
    type O = Cons<h, Cons<v, Nil>>;
}
impl React<w> for h {
    type O = Cons<h, Cons<w, Nil>>;
}
impl React<x> for h {
    type O = Cons<h, Cons<x, Nil>>;
}
impl React<y> for h {
    type O = Cons<h, Cons<y, Nil>>;
}
impl React<z> for h {
    type O = Cons<h, Cons<z, Nil>>;
}
impl React<A> for h {
    type O = Cons<h, Cons<A, Nil>>;
}
impl React<B> for h {
    type O = Cons<h, Cons<B, Nil>>;
}
impl React<C> for h {
    type O = Cons<h, Cons<C, Nil>>;
}
impl React<D> for h {
    type O = Cons<h, Cons<D, Nil>>;
}
impl React<E> for h {
    type O = Cons<h, Cons<E, Nil>>;
}
impl React<F> for h {
    type O = Cons<h, Cons<F, Nil>>;
}
impl React<G> for h {
    type O = Cons<h, Cons<G, Nil>>;
}
impl React<I> for h {
    type O = Cons<h, Cons<I, Nil>>;
}
impl React<J> for h {
    type O = Cons<h, Cons<J, Nil>>;
}
impl React<K> for h {
    type O = Cons<h, Cons<K, Nil>>;
}
impl React<L> for h {
    type O = Cons<h, Cons<L, Nil>>;
}
impl React<M> for h {
    type O = Cons<h, Cons<M, Nil>>;
}
impl React<N> for h {
    type O = Cons<h, Cons<N, Nil>>;
}
impl React<O> for h {
    type O = Cons<h, Cons<O, Nil>>;
}
impl React<P> for h {
    type O = Cons<h, Cons<P, Nil>>;
}
impl React<Q> for h {
    type O = Cons<h, Cons<Q, Nil>>;
}
impl React<R> for h {
    type O = Cons<h, Cons<R, Nil>>;
}
impl React<S> for h {
    type O = Cons<h, Cons<S, Nil>>;
}
impl React<T> for h {
    type O = Cons<h, Cons<T, Nil>>;
}
impl React<U> for h {
    type O = Cons<h, Cons<U, Nil>>;
}
impl React<V> for h {
    type O = Cons<h, Cons<V, Nil>>;
}
impl React<W> for h {
    type O = Cons<h, Cons<W, Nil>>;
}
impl React<X> for h {
    type O = Cons<h, Cons<X, Nil>>;
}
impl React<Y> for h {
    type O = Cons<h, Cons<Y, Nil>>;
}
impl React<Z> for h {
    type O = Cons<h, Cons<Z, Nil>>;
}
struct i;
impl React<I> for i {
    type O = Nil;
}
impl React<a> for i {
    type O = Cons<i, Cons<a, Nil>>;
}
impl React<b> for i {
    type O = Cons<i, Cons<b, Nil>>;
}
impl React<c> for i {
    type O = Cons<i, Cons<c, Nil>>;
}
impl React<d> for i {
    type O = Cons<i, Cons<d, Nil>>;
}
impl React<e> for i {
    type O = Cons<i, Cons<e, Nil>>;
}
impl React<f> for i {
    type O = Cons<i, Cons<f, Nil>>;
}
impl React<g> for i {
    type O = Cons<i, Cons<g, Nil>>;
}
impl React<h> for i {
    type O = Cons<i, Cons<h, Nil>>;
}
impl React<i> for i {
    type O = Cons<i, Cons<i, Nil>>;
}
impl React<j> for i {
    type O = Cons<i, Cons<j, Nil>>;
}
impl React<k> for i {
    type O = Cons<i, Cons<k, Nil>>;
}
impl React<l> for i {
    type O = Cons<i, Cons<l, Nil>>;
}
impl React<m> for i {
    type O = Cons<i, Cons<m, Nil>>;
}
impl React<n> for i {
    type O = Cons<i, Cons<n, Nil>>;
}
impl React<o> for i {
    type O = Cons<i, Cons<o, Nil>>;
}
impl React<p> for i {
    type O = Cons<i, Cons<p, Nil>>;
}
impl React<q> for i {
    type O = Cons<i, Cons<q, Nil>>;
}
impl React<r> for i {
    type O = Cons<i, Cons<r, Nil>>;
}
impl React<s> for i {
    type O = Cons<i, Cons<s, Nil>>;
}
impl React<t> for i {
    type O = Cons<i, Cons<t, Nil>>;
}
impl React<u> for i {
    type O = Cons<i, Cons<u, Nil>>;
}
impl React<v> for i {
    type O = Cons<i, Cons<v, Nil>>;
}
impl React<w> for i {
    type O = Cons<i, Cons<w, Nil>>;
}
impl React<x> for i {
    type O = Cons<i, Cons<x, Nil>>;
}
impl React<y> for i {
    type O = Cons<i, Cons<y, Nil>>;
}
impl React<z> for i {
    type O = Cons<i, Cons<z, Nil>>;
}
impl React<A> for i {
    type O = Cons<i, Cons<A, Nil>>;
}
impl React<B> for i {
    type O = Cons<i, Cons<B, Nil>>;
}
impl React<C> for i {
    type O = Cons<i, Cons<C, Nil>>;
}
impl React<D> for i {
    type O = Cons<i, Cons<D, Nil>>;
}
impl React<E> for i {
    type O = Cons<i, Cons<E, Nil>>;
}
impl React<F> for i {
    type O = Cons<i, Cons<F, Nil>>;
}
impl React<G> for i {
    type O = Cons<i, Cons<G, Nil>>;
}
impl React<H> for i {
    type O = Cons<i, Cons<H, Nil>>;
}
impl React<J> for i {
    type O = Cons<i, Cons<J, Nil>>;
}
impl React<K> for i {
    type O = Cons<i, Cons<K, Nil>>;
}
impl React<L> for i {
    type O = Cons<i, Cons<L, Nil>>;
}
impl React<M> for i {
    type O = Cons<i, Cons<M, Nil>>;
}
impl React<N> for i {
    type O = Cons<i, Cons<N, Nil>>;
}
impl React<O> for i {
    type O = Cons<i, Cons<O, Nil>>;
}
impl React<P> for i {
    type O = Cons<i, Cons<P, Nil>>;
}
impl React<Q> for i {
    type O = Cons<i, Cons<Q, Nil>>;
}
impl React<R> for i {
    type O = Cons<i, Cons<R, Nil>>;
}
impl React<S> for i {
    type O = Cons<i, Cons<S, Nil>>;
}
impl React<T> for i {
    type O = Cons<i, Cons<T, Nil>>;
}
impl React<U> for i {
    type O = Cons<i, Cons<U, Nil>>;
}
impl React<V> for i {
    type O = Cons<i, Cons<V, Nil>>;
}
impl React<W> for i {
    type O = Cons<i, Cons<W, Nil>>;
}
impl React<X> for i {
    type O = Cons<i, Cons<X, Nil>>;
}
impl React<Y> for i {
    type O = Cons<i, Cons<Y, Nil>>;
}
impl React<Z> for i {
    type O = Cons<i, Cons<Z, Nil>>;
}
struct j;
impl React<J> for j {
    type O = Nil;
}
impl React<a> for j {
    type O = Cons<j, Cons<a, Nil>>;
}
impl React<b> for j {
    type O = Cons<j, Cons<b, Nil>>;
}
impl React<c> for j {
    type O = Cons<j, Cons<c, Nil>>;
}
impl React<d> for j {
    type O = Cons<j, Cons<d, Nil>>;
}
impl React<e> for j {
    type O = Cons<j, Cons<e, Nil>>;
}
impl React<f> for j {
    type O = Cons<j, Cons<f, Nil>>;
}
impl React<g> for j {
    type O = Cons<j, Cons<g, Nil>>;
}
impl React<h> for j {
    type O = Cons<j, Cons<h, Nil>>;
}
impl React<i> for j {
    type O = Cons<j, Cons<i, Nil>>;
}
impl React<j> for j {
    type O = Cons<j, Cons<j, Nil>>;
}
impl React<k> for j {
    type O = Cons<j, Cons<k, Nil>>;
}
impl React<l> for j {
    type O = Cons<j, Cons<l, Nil>>;
}
impl React<m> for j {
    type O = Cons<j, Cons<m, Nil>>;
}
impl React<n> for j {
    type O = Cons<j, Cons<n, Nil>>;
}
impl React<o> for j {
    type O = Cons<j, Cons<o, Nil>>;
}
impl React<p> for j {
    type O = Cons<j, Cons<p, Nil>>;
}
impl React<q> for j {
    type O = Cons<j, Cons<q, Nil>>;
}
impl React<r> for j {
    type O = Cons<j, Cons<r, Nil>>;
}
impl React<s> for j {
    type O = Cons<j, Cons<s, Nil>>;
}
impl React<t> for j {
    type O = Cons<j, Cons<t, Nil>>;
}
impl React<u> for j {
    type O = Cons<j, Cons<u, Nil>>;
}
impl React<v> for j {
    type O = Cons<j, Cons<v, Nil>>;
}
impl React<w> for j {
    type O = Cons<j, Cons<w, Nil>>;
}
impl React<x> for j {
    type O = Cons<j, Cons<x, Nil>>;
}
impl React<y> for j {
    type O = Cons<j, Cons<y, Nil>>;
}
impl React<z> for j {
    type O = Cons<j, Cons<z, Nil>>;
}
impl React<A> for j {
    type O = Cons<j, Cons<A, Nil>>;
}
impl React<B> for j {
    type O = Cons<j, Cons<B, Nil>>;
}
impl React<C> for j {
    type O = Cons<j, Cons<C, Nil>>;
}
impl React<D> for j {
    type O = Cons<j, Cons<D, Nil>>;
}
impl React<E> for j {
    type O = Cons<j, Cons<E, Nil>>;
}
impl React<F> for j {
    type O = Cons<j, Cons<F, Nil>>;
}
impl React<G> for j {
    type O = Cons<j, Cons<G, Nil>>;
}
impl React<H> for j {
    type O = Cons<j, Cons<H, Nil>>;
}
impl React<I> for j {
    type O = Cons<j, Cons<I, Nil>>;
}
impl React<K> for j {
    type O = Cons<j, Cons<K, Nil>>;
}
impl React<L> for j {
    type O = Cons<j, Cons<L, Nil>>;
}
impl React<M> for j {
    type O = Cons<j, Cons<M, Nil>>;
}
impl React<N> for j {
    type O = Cons<j, Cons<N, Nil>>;
}
impl React<O> for j {
    type O = Cons<j, Cons<O, Nil>>;
}
impl React<P> for j {
    type O = Cons<j, Cons<P, Nil>>;
}
impl React<Q> for j {
    type O = Cons<j, Cons<Q, Nil>>;
}
impl React<R> for j {
    type O = Cons<j, Cons<R, Nil>>;
}
impl React<S> for j {
    type O = Cons<j, Cons<S, Nil>>;
}
impl React<T> for j {
    type O = Cons<j, Cons<T, Nil>>;
}
impl React<U> for j {
    type O = Cons<j, Cons<U, Nil>>;
}
impl React<V> for j {
    type O = Cons<j, Cons<V, Nil>>;
}
impl React<W> for j {
    type O = Cons<j, Cons<W, Nil>>;
}
impl React<X> for j {
    type O = Cons<j, Cons<X, Nil>>;
}
impl React<Y> for j {
    type O = Cons<j, Cons<Y, Nil>>;
}
impl React<Z> for j {
    type O = Cons<j, Cons<Z, Nil>>;
}
struct k;
impl React<K> for k {
    type O = Nil;
}
impl React<a> for k {
    type O = Cons<k, Cons<a, Nil>>;
}
impl React<b> for k {
    type O = Cons<k, Cons<b, Nil>>;
}
impl React<c> for k {
    type O = Cons<k, Cons<c, Nil>>;
}
impl React<d> for k {
    type O = Cons<k, Cons<d, Nil>>;
}
impl React<e> for k {
    type O = Cons<k, Cons<e, Nil>>;
}
impl React<f> for k {
    type O = Cons<k, Cons<f, Nil>>;
}
impl React<g> for k {
    type O = Cons<k, Cons<g, Nil>>;
}
impl React<h> for k {
    type O = Cons<k, Cons<h, Nil>>;
}
impl React<i> for k {
    type O = Cons<k, Cons<i, Nil>>;
}
impl React<j> for k {
    type O = Cons<k, Cons<j, Nil>>;
}
impl React<k> for k {
    type O = Cons<k, Cons<k, Nil>>;
}
impl React<l> for k {
    type O = Cons<k, Cons<l, Nil>>;
}
impl React<m> for k {
    type O = Cons<k, Cons<m, Nil>>;
}
impl React<n> for k {
    type O = Cons<k, Cons<n, Nil>>;
}
impl React<o> for k {
    type O = Cons<k, Cons<o, Nil>>;
}
impl React<p> for k {
    type O = Cons<k, Cons<p, Nil>>;
}
impl React<q> for k {
    type O = Cons<k, Cons<q, Nil>>;
}
impl React<r> for k {
    type O = Cons<k, Cons<r, Nil>>;
}
impl React<s> for k {
    type O = Cons<k, Cons<s, Nil>>;
}
impl React<t> for k {
    type O = Cons<k, Cons<t, Nil>>;
}
impl React<u> for k {
    type O = Cons<k, Cons<u, Nil>>;
}
impl React<v> for k {
    type O = Cons<k, Cons<v, Nil>>;
}
impl React<w> for k {
    type O = Cons<k, Cons<w, Nil>>;
}
impl React<x> for k {
    type O = Cons<k, Cons<x, Nil>>;
}
impl React<y> for k {
    type O = Cons<k, Cons<y, Nil>>;
}
impl React<z> for k {
    type O = Cons<k, Cons<z, Nil>>;
}
impl React<A> for k {
    type O = Cons<k, Cons<A, Nil>>;
}
impl React<B> for k {
    type O = Cons<k, Cons<B, Nil>>;
}
impl React<C> for k {
    type O = Cons<k, Cons<C, Nil>>;
}
impl React<D> for k {
    type O = Cons<k, Cons<D, Nil>>;
}
impl React<E> for k {
    type O = Cons<k, Cons<E, Nil>>;
}
impl React<F> for k {
    type O = Cons<k, Cons<F, Nil>>;
}
impl React<G> for k {
    type O = Cons<k, Cons<G, Nil>>;
}
impl React<H> for k {
    type O = Cons<k, Cons<H, Nil>>;
}
impl React<I> for k {
    type O = Cons<k, Cons<I, Nil>>;
}
impl React<J> for k {
    type O = Cons<k, Cons<J, Nil>>;
}
impl React<L> for k {
    type O = Cons<k, Cons<L, Nil>>;
}
impl React<M> for k {
    type O = Cons<k, Cons<M, Nil>>;
}
impl React<N> for k {
    type O = Cons<k, Cons<N, Nil>>;
}
impl React<O> for k {
    type O = Cons<k, Cons<O, Nil>>;
}
impl React<P> for k {
    type O = Cons<k, Cons<P, Nil>>;
}
impl React<Q> for k {
    type O = Cons<k, Cons<Q, Nil>>;
}
impl React<R> for k {
    type O = Cons<k, Cons<R, Nil>>;
}
impl React<S> for k {
    type O = Cons<k, Cons<S, Nil>>;
}
impl React<T> for k {
    type O = Cons<k, Cons<T, Nil>>;
}
impl React<U> for k {
    type O = Cons<k, Cons<U, Nil>>;
}
impl React<V> for k {
    type O = Cons<k, Cons<V, Nil>>;
}
impl React<W> for k {
    type O = Cons<k, Cons<W, Nil>>;
}
impl React<X> for k {
    type O = Cons<k, Cons<X, Nil>>;
}
impl React<Y> for k {
    type O = Cons<k, Cons<Y, Nil>>;
}
impl React<Z> for k {
    type O = Cons<k, Cons<Z, Nil>>;
}
struct l;
impl React<L> for l {
    type O = Nil;
}
impl React<a> for l {
    type O = Cons<l, Cons<a, Nil>>;
}
impl React<b> for l {
    type O = Cons<l, Cons<b, Nil>>;
}
impl React<c> for l {
    type O = Cons<l, Cons<c, Nil>>;
}
impl React<d> for l {
    type O = Cons<l, Cons<d, Nil>>;
}
impl React<e> for l {
    type O = Cons<l, Cons<e, Nil>>;
}
impl React<f> for l {
    type O = Cons<l, Cons<f, Nil>>;
}
impl React<g> for l {
    type O = Cons<l, Cons<g, Nil>>;
}
impl React<h> for l {
    type O = Cons<l, Cons<h, Nil>>;
}
impl React<i> for l {
    type O = Cons<l, Cons<i, Nil>>;
}
impl React<j> for l {
    type O = Cons<l, Cons<j, Nil>>;
}
impl React<k> for l {
    type O = Cons<l, Cons<k, Nil>>;
}
impl React<l> for l {
    type O = Cons<l, Cons<l, Nil>>;
}
impl React<m> for l {
    type O = Cons<l, Cons<m, Nil>>;
}
impl React<n> for l {
    type O = Cons<l, Cons<n, Nil>>;
}
impl React<o> for l {
    type O = Cons<l, Cons<o, Nil>>;
}
impl React<p> for l {
    type O = Cons<l, Cons<p, Nil>>;
}
impl React<q> for l {
    type O = Cons<l, Cons<q, Nil>>;
}
impl React<r> for l {
    type O = Cons<l, Cons<r, Nil>>;
}
impl React<s> for l {
    type O = Cons<l, Cons<s, Nil>>;
}
impl React<t> for l {
    type O = Cons<l, Cons<t, Nil>>;
}
impl React<u> for l {
    type O = Cons<l, Cons<u, Nil>>;
}
impl React<v> for l {
    type O = Cons<l, Cons<v, Nil>>;
}
impl React<w> for l {
    type O = Cons<l, Cons<w, Nil>>;
}
impl React<x> for l {
    type O = Cons<l, Cons<x, Nil>>;
}
impl React<y> for l {
    type O = Cons<l, Cons<y, Nil>>;
}
impl React<z> for l {
    type O = Cons<l, Cons<z, Nil>>;
}
impl React<A> for l {
    type O = Cons<l, Cons<A, Nil>>;
}
impl React<B> for l {
    type O = Cons<l, Cons<B, Nil>>;
}
impl React<C> for l {
    type O = Cons<l, Cons<C, Nil>>;
}
impl React<D> for l {
    type O = Cons<l, Cons<D, Nil>>;
}
impl React<E> for l {
    type O = Cons<l, Cons<E, Nil>>;
}
impl React<F> for l {
    type O = Cons<l, Cons<F, Nil>>;
}
impl React<G> for l {
    type O = Cons<l, Cons<G, Nil>>;
}
impl React<H> for l {
    type O = Cons<l, Cons<H, Nil>>;
}
impl React<I> for l {
    type O = Cons<l, Cons<I, Nil>>;
}
impl React<J> for l {
    type O = Cons<l, Cons<J, Nil>>;
}
impl React<K> for l {
    type O = Cons<l, Cons<K, Nil>>;
}
impl React<M> for l {
    type O = Cons<l, Cons<M, Nil>>;
}
impl React<N> for l {
    type O = Cons<l, Cons<N, Nil>>;
}
impl React<O> for l {
    type O = Cons<l, Cons<O, Nil>>;
}
impl React<P> for l {
    type O = Cons<l, Cons<P, Nil>>;
}
impl React<Q> for l {
    type O = Cons<l, Cons<Q, Nil>>;
}
impl React<R> for l {
    type O = Cons<l, Cons<R, Nil>>;
}
impl React<S> for l {
    type O = Cons<l, Cons<S, Nil>>;
}
impl React<T> for l {
    type O = Cons<l, Cons<T, Nil>>;
}
impl React<U> for l {
    type O = Cons<l, Cons<U, Nil>>;
}
impl React<V> for l {
    type O = Cons<l, Cons<V, Nil>>;
}
impl React<W> for l {
    type O = Cons<l, Cons<W, Nil>>;
}
impl React<X> for l {
    type O = Cons<l, Cons<X, Nil>>;
}
impl React<Y> for l {
    type O = Cons<l, Cons<Y, Nil>>;
}
impl React<Z> for l {
    type O = Cons<l, Cons<Z, Nil>>;
}
struct m;
impl React<M> for m {
    type O = Nil;
}
impl React<a> for m {
    type O = Cons<m, Cons<a, Nil>>;
}
impl React<b> for m {
    type O = Cons<m, Cons<b, Nil>>;
}
impl React<c> for m {
    type O = Cons<m, Cons<c, Nil>>;
}
impl React<d> for m {
    type O = Cons<m, Cons<d, Nil>>;
}
impl React<e> for m {
    type O = Cons<m, Cons<e, Nil>>;
}
impl React<f> for m {
    type O = Cons<m, Cons<f, Nil>>;
}
impl React<g> for m {
    type O = Cons<m, Cons<g, Nil>>;
}
impl React<h> for m {
    type O = Cons<m, Cons<h, Nil>>;
}
impl React<i> for m {
    type O = Cons<m, Cons<i, Nil>>;
}
impl React<j> for m {
    type O = Cons<m, Cons<j, Nil>>;
}
impl React<k> for m {
    type O = Cons<m, Cons<k, Nil>>;
}
impl React<l> for m {
    type O = Cons<m, Cons<l, Nil>>;
}
impl React<m> for m {
    type O = Cons<m, Cons<m, Nil>>;
}
impl React<n> for m {
    type O = Cons<m, Cons<n, Nil>>;
}
impl React<o> for m {
    type O = Cons<m, Cons<o, Nil>>;
}
impl React<p> for m {
    type O = Cons<m, Cons<p, Nil>>;
}
impl React<q> for m {
    type O = Cons<m, Cons<q, Nil>>;
}
impl React<r> for m {
    type O = Cons<m, Cons<r, Nil>>;
}
impl React<s> for m {
    type O = Cons<m, Cons<s, Nil>>;
}
impl React<t> for m {
    type O = Cons<m, Cons<t, Nil>>;
}
impl React<u> for m {
    type O = Cons<m, Cons<u, Nil>>;
}
impl React<v> for m {
    type O = Cons<m, Cons<v, Nil>>;
}
impl React<w> for m {
    type O = Cons<m, Cons<w, Nil>>;
}
impl React<x> for m {
    type O = Cons<m, Cons<x, Nil>>;
}
impl React<y> for m {
    type O = Cons<m, Cons<y, Nil>>;
}
impl React<z> for m {
    type O = Cons<m, Cons<z, Nil>>;
}
impl React<A> for m {
    type O = Cons<m, Cons<A, Nil>>;
}
impl React<B> for m {
    type O = Cons<m, Cons<B, Nil>>;
}
impl React<C> for m {
    type O = Cons<m, Cons<C, Nil>>;
}
impl React<D> for m {
    type O = Cons<m, Cons<D, Nil>>;
}
impl React<E> for m {
    type O = Cons<m, Cons<E, Nil>>;
}
impl React<F> for m {
    type O = Cons<m, Cons<F, Nil>>;
}
impl React<G> for m {
    type O = Cons<m, Cons<G, Nil>>;
}
impl React<H> for m {
    type O = Cons<m, Cons<H, Nil>>;
}
impl React<I> for m {
    type O = Cons<m, Cons<I, Nil>>;
}
impl React<J> for m {
    type O = Cons<m, Cons<J, Nil>>;
}
impl React<K> for m {
    type O = Cons<m, Cons<K, Nil>>;
}
impl React<L> for m {
    type O = Cons<m, Cons<L, Nil>>;
}
impl React<N> for m {
    type O = Cons<m, Cons<N, Nil>>;
}
impl React<O> for m {
    type O = Cons<m, Cons<O, Nil>>;
}
impl React<P> for m {
    type O = Cons<m, Cons<P, Nil>>;
}
impl React<Q> for m {
    type O = Cons<m, Cons<Q, Nil>>;
}
impl React<R> for m {
    type O = Cons<m, Cons<R, Nil>>;
}
impl React<S> for m {
    type O = Cons<m, Cons<S, Nil>>;
}
impl React<T> for m {
    type O = Cons<m, Cons<T, Nil>>;
}
impl React<U> for m {
    type O = Cons<m, Cons<U, Nil>>;
}
impl React<V> for m {
    type O = Cons<m, Cons<V, Nil>>;
}
impl React<W> for m {
    type O = Cons<m, Cons<W, Nil>>;
}
impl React<X> for m {
    type O = Cons<m, Cons<X, Nil>>;
}
impl React<Y> for m {
    type O = Cons<m, Cons<Y, Nil>>;
}
impl React<Z> for m {
    type O = Cons<m, Cons<Z, Nil>>;
}
struct n;
impl React<N> for n {
    type O = Nil;
}
impl React<a> for n {
    type O = Cons<n, Cons<a, Nil>>;
}
impl React<b> for n {
    type O = Cons<n, Cons<b, Nil>>;
}
impl React<c> for n {
    type O = Cons<n, Cons<c, Nil>>;
}
impl React<d> for n {
    type O = Cons<n, Cons<d, Nil>>;
}
impl React<e> for n {
    type O = Cons<n, Cons<e, Nil>>;
}
impl React<f> for n {
    type O = Cons<n, Cons<f, Nil>>;
}
impl React<g> for n {
    type O = Cons<n, Cons<g, Nil>>;
}
impl React<h> for n {
    type O = Cons<n, Cons<h, Nil>>;
}
impl React<i> for n {
    type O = Cons<n, Cons<i, Nil>>;
}
impl React<j> for n {
    type O = Cons<n, Cons<j, Nil>>;
}
impl React<k> for n {
    type O = Cons<n, Cons<k, Nil>>;
}
impl React<l> for n {
    type O = Cons<n, Cons<l, Nil>>;
}
impl React<m> for n {
    type O = Cons<n, Cons<m, Nil>>;
}
impl React<n> for n {
    type O = Cons<n, Cons<n, Nil>>;
}
impl React<o> for n {
    type O = Cons<n, Cons<o, Nil>>;
}
impl React<p> for n {
    type O = Cons<n, Cons<p, Nil>>;
}
impl React<q> for n {
    type O = Cons<n, Cons<q, Nil>>;
}
impl React<r> for n {
    type O = Cons<n, Cons<r, Nil>>;
}
impl React<s> for n {
    type O = Cons<n, Cons<s, Nil>>;
}
impl React<t> for n {
    type O = Cons<n, Cons<t, Nil>>;
}
impl React<u> for n {
    type O = Cons<n, Cons<u, Nil>>;
}
impl React<v> for n {
    type O = Cons<n, Cons<v, Nil>>;
}
impl React<w> for n {
    type O = Cons<n, Cons<w, Nil>>;
}
impl React<x> for n {
    type O = Cons<n, Cons<x, Nil>>;
}
impl React<y> for n {
    type O = Cons<n, Cons<y, Nil>>;
}
impl React<z> for n {
    type O = Cons<n, Cons<z, Nil>>;
}
impl React<A> for n {
    type O = Cons<n, Cons<A, Nil>>;
}
impl React<B> for n {
    type O = Cons<n, Cons<B, Nil>>;
}
impl React<C> for n {
    type O = Cons<n, Cons<C, Nil>>;
}
impl React<D> for n {
    type O = Cons<n, Cons<D, Nil>>;
}
impl React<E> for n {
    type O = Cons<n, Cons<E, Nil>>;
}
impl React<F> for n {
    type O = Cons<n, Cons<F, Nil>>;
}
impl React<G> for n {
    type O = Cons<n, Cons<G, Nil>>;
}
impl React<H> for n {
    type O = Cons<n, Cons<H, Nil>>;
}
impl React<I> for n {
    type O = Cons<n, Cons<I, Nil>>;
}
impl React<J> for n {
    type O = Cons<n, Cons<J, Nil>>;
}
impl React<K> for n {
    type O = Cons<n, Cons<K, Nil>>;
}
impl React<L> for n {
    type O = Cons<n, Cons<L, Nil>>;
}
impl React<M> for n {
    type O = Cons<n, Cons<M, Nil>>;
}
impl React<O> for n {
    type O = Cons<n, Cons<O, Nil>>;
}
impl React<P> for n {
    type O = Cons<n, Cons<P, Nil>>;
}
impl React<Q> for n {
    type O = Cons<n, Cons<Q, Nil>>;
}
impl React<R> for n {
    type O = Cons<n, Cons<R, Nil>>;
}
impl React<S> for n {
    type O = Cons<n, Cons<S, Nil>>;
}
impl React<T> for n {
    type O = Cons<n, Cons<T, Nil>>;
}
impl React<U> for n {
    type O = Cons<n, Cons<U, Nil>>;
}
impl React<V> for n {
    type O = Cons<n, Cons<V, Nil>>;
}
impl React<W> for n {
    type O = Cons<n, Cons<W, Nil>>;
}
impl React<X> for n {
    type O = Cons<n, Cons<X, Nil>>;
}
impl React<Y> for n {
    type O = Cons<n, Cons<Y, Nil>>;
}
impl React<Z> for n {
    type O = Cons<n, Cons<Z, Nil>>;
}
struct o;
impl React<O> for o {
    type O = Nil;
}
impl React<a> for o {
    type O = Cons<o, Cons<a, Nil>>;
}
impl React<b> for o {
    type O = Cons<o, Cons<b, Nil>>;
}
impl React<c> for o {
    type O = Cons<o, Cons<c, Nil>>;
}
impl React<d> for o {
    type O = Cons<o, Cons<d, Nil>>;
}
impl React<e> for o {
    type O = Cons<o, Cons<e, Nil>>;
}
impl React<f> for o {
    type O = Cons<o, Cons<f, Nil>>;
}
impl React<g> for o {
    type O = Cons<o, Cons<g, Nil>>;
}
impl React<h> for o {
    type O = Cons<o, Cons<h, Nil>>;
}
impl React<i> for o {
    type O = Cons<o, Cons<i, Nil>>;
}
impl React<j> for o {
    type O = Cons<o, Cons<j, Nil>>;
}
impl React<k> for o {
    type O = Cons<o, Cons<k, Nil>>;
}
impl React<l> for o {
    type O = Cons<o, Cons<l, Nil>>;
}
impl React<m> for o {
    type O = Cons<o, Cons<m, Nil>>;
}
impl React<n> for o {
    type O = Cons<o, Cons<n, Nil>>;
}
impl React<o> for o {
    type O = Cons<o, Cons<o, Nil>>;
}
impl React<p> for o {
    type O = Cons<o, Cons<p, Nil>>;
}
impl React<q> for o {
    type O = Cons<o, Cons<q, Nil>>;
}
impl React<r> for o {
    type O = Cons<o, Cons<r, Nil>>;
}
impl React<s> for o {
    type O = Cons<o, Cons<s, Nil>>;
}
impl React<t> for o {
    type O = Cons<o, Cons<t, Nil>>;
}
impl React<u> for o {
    type O = Cons<o, Cons<u, Nil>>;
}
impl React<v> for o {
    type O = Cons<o, Cons<v, Nil>>;
}
impl React<w> for o {
    type O = Cons<o, Cons<w, Nil>>;
}
impl React<x> for o {
    type O = Cons<o, Cons<x, Nil>>;
}
impl React<y> for o {
    type O = Cons<o, Cons<y, Nil>>;
}
impl React<z> for o {
    type O = Cons<o, Cons<z, Nil>>;
}
impl React<A> for o {
    type O = Cons<o, Cons<A, Nil>>;
}
impl React<B> for o {
    type O = Cons<o, Cons<B, Nil>>;
}
impl React<C> for o {
    type O = Cons<o, Cons<C, Nil>>;
}
impl React<D> for o {
    type O = Cons<o, Cons<D, Nil>>;
}
impl React<E> for o {
    type O = Cons<o, Cons<E, Nil>>;
}
impl React<F> for o {
    type O = Cons<o, Cons<F, Nil>>;
}
impl React<G> for o {
    type O = Cons<o, Cons<G, Nil>>;
}
impl React<H> for o {
    type O = Cons<o, Cons<H, Nil>>;
}
impl React<I> for o {
    type O = Cons<o, Cons<I, Nil>>;
}
impl React<J> for o {
    type O = Cons<o, Cons<J, Nil>>;
}
impl React<K> for o {
    type O = Cons<o, Cons<K, Nil>>;
}
impl React<L> for o {
    type O = Cons<o, Cons<L, Nil>>;
}
impl React<M> for o {
    type O = Cons<o, Cons<M, Nil>>;
}
impl React<N> for o {
    type O = Cons<o, Cons<N, Nil>>;
}
impl React<P> for o {
    type O = Cons<o, Cons<P, Nil>>;
}
impl React<Q> for o {
    type O = Cons<o, Cons<Q, Nil>>;
}
impl React<R> for o {
    type O = Cons<o, Cons<R, Nil>>;
}
impl React<S> for o {
    type O = Cons<o, Cons<S, Nil>>;
}
impl React<T> for o {
    type O = Cons<o, Cons<T, Nil>>;
}
impl React<U> for o {
    type O = Cons<o, Cons<U, Nil>>;
}
impl React<V> for o {
    type O = Cons<o, Cons<V, Nil>>;
}
impl React<W> for o {
    type O = Cons<o, Cons<W, Nil>>;
}
impl React<X> for o {
    type O = Cons<o, Cons<X, Nil>>;
}
impl React<Y> for o {
    type O = Cons<o, Cons<Y, Nil>>;
}
impl React<Z> for o {
    type O = Cons<o, Cons<Z, Nil>>;
}
struct p;
impl React<P> for p {
    type O = Nil;
}
impl React<a> for p {
    type O = Cons<p, Cons<a, Nil>>;
}
impl React<b> for p {
    type O = Cons<p, Cons<b, Nil>>;
}
impl React<c> for p {
    type O = Cons<p, Cons<c, Nil>>;
}
impl React<d> for p {
    type O = Cons<p, Cons<d, Nil>>;
}
impl React<e> for p {
    type O = Cons<p, Cons<e, Nil>>;
}
impl React<f> for p {
    type O = Cons<p, Cons<f, Nil>>;
}
impl React<g> for p {
    type O = Cons<p, Cons<g, Nil>>;
}
impl React<h> for p {
    type O = Cons<p, Cons<h, Nil>>;
}
impl React<i> for p {
    type O = Cons<p, Cons<i, Nil>>;
}
impl React<j> for p {
    type O = Cons<p, Cons<j, Nil>>;
}
impl React<k> for p {
    type O = Cons<p, Cons<k, Nil>>;
}
impl React<l> for p {
    type O = Cons<p, Cons<l, Nil>>;
}
impl React<m> for p {
    type O = Cons<p, Cons<m, Nil>>;
}
impl React<n> for p {
    type O = Cons<p, Cons<n, Nil>>;
}
impl React<o> for p {
    type O = Cons<p, Cons<o, Nil>>;
}
impl React<p> for p {
    type O = Cons<p, Cons<p, Nil>>;
}
impl React<q> for p {
    type O = Cons<p, Cons<q, Nil>>;
}
impl React<r> for p {
    type O = Cons<p, Cons<r, Nil>>;
}
impl React<s> for p {
    type O = Cons<p, Cons<s, Nil>>;
}
impl React<t> for p {
    type O = Cons<p, Cons<t, Nil>>;
}
impl React<u> for p {
    type O = Cons<p, Cons<u, Nil>>;
}
impl React<v> for p {
    type O = Cons<p, Cons<v, Nil>>;
}
impl React<w> for p {
    type O = Cons<p, Cons<w, Nil>>;
}
impl React<x> for p {
    type O = Cons<p, Cons<x, Nil>>;
}
impl React<y> for p {
    type O = Cons<p, Cons<y, Nil>>;
}
impl React<z> for p {
    type O = Cons<p, Cons<z, Nil>>;
}
impl React<A> for p {
    type O = Cons<p, Cons<A, Nil>>;
}
impl React<B> for p {
    type O = Cons<p, Cons<B, Nil>>;
}
impl React<C> for p {
    type O = Cons<p, Cons<C, Nil>>;
}
impl React<D> for p {
    type O = Cons<p, Cons<D, Nil>>;
}
impl React<E> for p {
    type O = Cons<p, Cons<E, Nil>>;
}
impl React<F> for p {
    type O = Cons<p, Cons<F, Nil>>;
}
impl React<G> for p {
    type O = Cons<p, Cons<G, Nil>>;
}
impl React<H> for p {
    type O = Cons<p, Cons<H, Nil>>;
}
impl React<I> for p {
    type O = Cons<p, Cons<I, Nil>>;
}
impl React<J> for p {
    type O = Cons<p, Cons<J, Nil>>;
}
impl React<K> for p {
    type O = Cons<p, Cons<K, Nil>>;
}
impl React<L> for p {
    type O = Cons<p, Cons<L, Nil>>;
}
impl React<M> for p {
    type O = Cons<p, Cons<M, Nil>>;
}
impl React<N> for p {
    type O = Cons<p, Cons<N, Nil>>;
}
impl React<O> for p {
    type O = Cons<p, Cons<O, Nil>>;
}
impl React<Q> for p {
    type O = Cons<p, Cons<Q, Nil>>;
}
impl React<R> for p {
    type O = Cons<p, Cons<R, Nil>>;
}
impl React<S> for p {
    type O = Cons<p, Cons<S, Nil>>;
}
impl React<T> for p {
    type O = Cons<p, Cons<T, Nil>>;
}
impl React<U> for p {
    type O = Cons<p, Cons<U, Nil>>;
}
impl React<V> for p {
    type O = Cons<p, Cons<V, Nil>>;
}
impl React<W> for p {
    type O = Cons<p, Cons<W, Nil>>;
}
impl React<X> for p {
    type O = Cons<p, Cons<X, Nil>>;
}
impl React<Y> for p {
    type O = Cons<p, Cons<Y, Nil>>;
}
impl React<Z> for p {
    type O = Cons<p, Cons<Z, Nil>>;
}
struct q;
impl React<Q> for q {
    type O = Nil;
}
impl React<a> for q {
    type O = Cons<q, Cons<a, Nil>>;
}
impl React<b> for q {
    type O = Cons<q, Cons<b, Nil>>;
}
impl React<c> for q {
    type O = Cons<q, Cons<c, Nil>>;
}
impl React<d> for q {
    type O = Cons<q, Cons<d, Nil>>;
}
impl React<e> for q {
    type O = Cons<q, Cons<e, Nil>>;
}
impl React<f> for q {
    type O = Cons<q, Cons<f, Nil>>;
}
impl React<g> for q {
    type O = Cons<q, Cons<g, Nil>>;
}
impl React<h> for q {
    type O = Cons<q, Cons<h, Nil>>;
}
impl React<i> for q {
    type O = Cons<q, Cons<i, Nil>>;
}
impl React<j> for q {
    type O = Cons<q, Cons<j, Nil>>;
}
impl React<k> for q {
    type O = Cons<q, Cons<k, Nil>>;
}
impl React<l> for q {
    type O = Cons<q, Cons<l, Nil>>;
}
impl React<m> for q {
    type O = Cons<q, Cons<m, Nil>>;
}
impl React<n> for q {
    type O = Cons<q, Cons<n, Nil>>;
}
impl React<o> for q {
    type O = Cons<q, Cons<o, Nil>>;
}
impl React<p> for q {
    type O = Cons<q, Cons<p, Nil>>;
}
impl React<q> for q {
    type O = Cons<q, Cons<q, Nil>>;
}
impl React<r> for q {
    type O = Cons<q, Cons<r, Nil>>;
}
impl React<s> for q {
    type O = Cons<q, Cons<s, Nil>>;
}
impl React<t> for q {
    type O = Cons<q, Cons<t, Nil>>;
}
impl React<u> for q {
    type O = Cons<q, Cons<u, Nil>>;
}
impl React<v> for q {
    type O = Cons<q, Cons<v, Nil>>;
}
impl React<w> for q {
    type O = Cons<q, Cons<w, Nil>>;
}
impl React<x> for q {
    type O = Cons<q, Cons<x, Nil>>;
}
impl React<y> for q {
    type O = Cons<q, Cons<y, Nil>>;
}
impl React<z> for q {
    type O = Cons<q, Cons<z, Nil>>;
}
impl React<A> for q {
    type O = Cons<q, Cons<A, Nil>>;
}
impl React<B> for q {
    type O = Cons<q, Cons<B, Nil>>;
}
impl React<C> for q {
    type O = Cons<q, Cons<C, Nil>>;
}
impl React<D> for q {
    type O = Cons<q, Cons<D, Nil>>;
}
impl React<E> for q {
    type O = Cons<q, Cons<E, Nil>>;
}
impl React<F> for q {
    type O = Cons<q, Cons<F, Nil>>;
}
impl React<G> for q {
    type O = Cons<q, Cons<G, Nil>>;
}
impl React<H> for q {
    type O = Cons<q, Cons<H, Nil>>;
}
impl React<I> for q {
    type O = Cons<q, Cons<I, Nil>>;
}
impl React<J> for q {
    type O = Cons<q, Cons<J, Nil>>;
}
impl React<K> for q {
    type O = Cons<q, Cons<K, Nil>>;
}
impl React<L> for q {
    type O = Cons<q, Cons<L, Nil>>;
}
impl React<M> for q {
    type O = Cons<q, Cons<M, Nil>>;
}
impl React<N> for q {
    type O = Cons<q, Cons<N, Nil>>;
}
impl React<O> for q {
    type O = Cons<q, Cons<O, Nil>>;
}
impl React<P> for q {
    type O = Cons<q, Cons<P, Nil>>;
}
impl React<R> for q {
    type O = Cons<q, Cons<R, Nil>>;
}
impl React<S> for q {
    type O = Cons<q, Cons<S, Nil>>;
}
impl React<T> for q {
    type O = Cons<q, Cons<T, Nil>>;
}
impl React<U> for q {
    type O = Cons<q, Cons<U, Nil>>;
}
impl React<V> for q {
    type O = Cons<q, Cons<V, Nil>>;
}
impl React<W> for q {
    type O = Cons<q, Cons<W, Nil>>;
}
impl React<X> for q {
    type O = Cons<q, Cons<X, Nil>>;
}
impl React<Y> for q {
    type O = Cons<q, Cons<Y, Nil>>;
}
impl React<Z> for q {
    type O = Cons<q, Cons<Z, Nil>>;
}
struct r;
impl React<R> for r {
    type O = Nil;
}
impl React<a> for r {
    type O = Cons<r, Cons<a, Nil>>;
}
impl React<b> for r {
    type O = Cons<r, Cons<b, Nil>>;
}
impl React<c> for r {
    type O = Cons<r, Cons<c, Nil>>;
}
impl React<d> for r {
    type O = Cons<r, Cons<d, Nil>>;
}
impl React<e> for r {
    type O = Cons<r, Cons<e, Nil>>;
}
impl React<f> for r {
    type O = Cons<r, Cons<f, Nil>>;
}
impl React<g> for r {
    type O = Cons<r, Cons<g, Nil>>;
}
impl React<h> for r {
    type O = Cons<r, Cons<h, Nil>>;
}
impl React<i> for r {
    type O = Cons<r, Cons<i, Nil>>;
}
impl React<j> for r {
    type O = Cons<r, Cons<j, Nil>>;
}
impl React<k> for r {
    type O = Cons<r, Cons<k, Nil>>;
}
impl React<l> for r {
    type O = Cons<r, Cons<l, Nil>>;
}
impl React<m> for r {
    type O = Cons<r, Cons<m, Nil>>;
}
impl React<n> for r {
    type O = Cons<r, Cons<n, Nil>>;
}
impl React<o> for r {
    type O = Cons<r, Cons<o, Nil>>;
}
impl React<p> for r {
    type O = Cons<r, Cons<p, Nil>>;
}
impl React<q> for r {
    type O = Cons<r, Cons<q, Nil>>;
}
impl React<r> for r {
    type O = Cons<r, Cons<r, Nil>>;
}
impl React<s> for r {
    type O = Cons<r, Cons<s, Nil>>;
}
impl React<t> for r {
    type O = Cons<r, Cons<t, Nil>>;
}
impl React<u> for r {
    type O = Cons<r, Cons<u, Nil>>;
}
impl React<v> for r {
    type O = Cons<r, Cons<v, Nil>>;
}
impl React<w> for r {
    type O = Cons<r, Cons<w, Nil>>;
}
impl React<x> for r {
    type O = Cons<r, Cons<x, Nil>>;
}
impl React<y> for r {
    type O = Cons<r, Cons<y, Nil>>;
}
impl React<z> for r {
    type O = Cons<r, Cons<z, Nil>>;
}
impl React<A> for r {
    type O = Cons<r, Cons<A, Nil>>;
}
impl React<B> for r {
    type O = Cons<r, Cons<B, Nil>>;
}
impl React<C> for r {
    type O = Cons<r, Cons<C, Nil>>;
}
impl React<D> for r {
    type O = Cons<r, Cons<D, Nil>>;
}
impl React<E> for r {
    type O = Cons<r, Cons<E, Nil>>;
}
impl React<F> for r {
    type O = Cons<r, Cons<F, Nil>>;
}
impl React<G> for r {
    type O = Cons<r, Cons<G, Nil>>;
}
impl React<H> for r {
    type O = Cons<r, Cons<H, Nil>>;
}
impl React<I> for r {
    type O = Cons<r, Cons<I, Nil>>;
}
impl React<J> for r {
    type O = Cons<r, Cons<J, Nil>>;
}
impl React<K> for r {
    type O = Cons<r, Cons<K, Nil>>;
}
impl React<L> for r {
    type O = Cons<r, Cons<L, Nil>>;
}
impl React<M> for r {
    type O = Cons<r, Cons<M, Nil>>;
}
impl React<N> for r {
    type O = Cons<r, Cons<N, Nil>>;
}
impl React<O> for r {
    type O = Cons<r, Cons<O, Nil>>;
}
impl React<P> for r {
    type O = Cons<r, Cons<P, Nil>>;
}
impl React<Q> for r {
    type O = Cons<r, Cons<Q, Nil>>;
}
impl React<S> for r {
    type O = Cons<r, Cons<S, Nil>>;
}
impl React<T> for r {
    type O = Cons<r, Cons<T, Nil>>;
}
impl React<U> for r {
    type O = Cons<r, Cons<U, Nil>>;
}
impl React<V> for r {
    type O = Cons<r, Cons<V, Nil>>;
}
impl React<W> for r {
    type O = Cons<r, Cons<W, Nil>>;
}
impl React<X> for r {
    type O = Cons<r, Cons<X, Nil>>;
}
impl React<Y> for r {
    type O = Cons<r, Cons<Y, Nil>>;
}
impl React<Z> for r {
    type O = Cons<r, Cons<Z, Nil>>;
}
struct s;
impl React<S> for s {
    type O = Nil;
}
impl React<a> for s {
    type O = Cons<s, Cons<a, Nil>>;
}
impl React<b> for s {
    type O = Cons<s, Cons<b, Nil>>;
}
impl React<c> for s {
    type O = Cons<s, Cons<c, Nil>>;
}
impl React<d> for s {
    type O = Cons<s, Cons<d, Nil>>;
}
impl React<e> for s {
    type O = Cons<s, Cons<e, Nil>>;
}
impl React<f> for s {
    type O = Cons<s, Cons<f, Nil>>;
}
impl React<g> for s {
    type O = Cons<s, Cons<g, Nil>>;
}
impl React<h> for s {
    type O = Cons<s, Cons<h, Nil>>;
}
impl React<i> for s {
    type O = Cons<s, Cons<i, Nil>>;
}
impl React<j> for s {
    type O = Cons<s, Cons<j, Nil>>;
}
impl React<k> for s {
    type O = Cons<s, Cons<k, Nil>>;
}
impl React<l> for s {
    type O = Cons<s, Cons<l, Nil>>;
}
impl React<m> for s {
    type O = Cons<s, Cons<m, Nil>>;
}
impl React<n> for s {
    type O = Cons<s, Cons<n, Nil>>;
}
impl React<o> for s {
    type O = Cons<s, Cons<o, Nil>>;
}
impl React<p> for s {
    type O = Cons<s, Cons<p, Nil>>;
}
impl React<q> for s {
    type O = Cons<s, Cons<q, Nil>>;
}
impl React<r> for s {
    type O = Cons<s, Cons<r, Nil>>;
}
impl React<s> for s {
    type O = Cons<s, Cons<s, Nil>>;
}
impl React<t> for s {
    type O = Cons<s, Cons<t, Nil>>;
}
impl React<u> for s {
    type O = Cons<s, Cons<u, Nil>>;
}
impl React<v> for s {
    type O = Cons<s, Cons<v, Nil>>;
}
impl React<w> for s {
    type O = Cons<s, Cons<w, Nil>>;
}
impl React<x> for s {
    type O = Cons<s, Cons<x, Nil>>;
}
impl React<y> for s {
    type O = Cons<s, Cons<y, Nil>>;
}
impl React<z> for s {
    type O = Cons<s, Cons<z, Nil>>;
}
impl React<A> for s {
    type O = Cons<s, Cons<A, Nil>>;
}
impl React<B> for s {
    type O = Cons<s, Cons<B, Nil>>;
}
impl React<C> for s {
    type O = Cons<s, Cons<C, Nil>>;
}
impl React<D> for s {
    type O = Cons<s, Cons<D, Nil>>;
}
impl React<E> for s {
    type O = Cons<s, Cons<E, Nil>>;
}
impl React<F> for s {
    type O = Cons<s, Cons<F, Nil>>;
}
impl React<G> for s {
    type O = Cons<s, Cons<G, Nil>>;
}
impl React<H> for s {
    type O = Cons<s, Cons<H, Nil>>;
}
impl React<I> for s {
    type O = Cons<s, Cons<I, Nil>>;
}
impl React<J> for s {
    type O = Cons<s, Cons<J, Nil>>;
}
impl React<K> for s {
    type O = Cons<s, Cons<K, Nil>>;
}
impl React<L> for s {
    type O = Cons<s, Cons<L, Nil>>;
}
impl React<M> for s {
    type O = Cons<s, Cons<M, Nil>>;
}
impl React<N> for s {
    type O = Cons<s, Cons<N, Nil>>;
}
impl React<O> for s {
    type O = Cons<s, Cons<O, Nil>>;
}
impl React<P> for s {
    type O = Cons<s, Cons<P, Nil>>;
}
impl React<Q> for s {
    type O = Cons<s, Cons<Q, Nil>>;
}
impl React<R> for s {
    type O = Cons<s, Cons<R, Nil>>;
}
impl React<T> for s {
    type O = Cons<s, Cons<T, Nil>>;
}
impl React<U> for s {
    type O = Cons<s, Cons<U, Nil>>;
}
impl React<V> for s {
    type O = Cons<s, Cons<V, Nil>>;
}
impl React<W> for s {
    type O = Cons<s, Cons<W, Nil>>;
}
impl React<X> for s {
    type O = Cons<s, Cons<X, Nil>>;
}
impl React<Y> for s {
    type O = Cons<s, Cons<Y, Nil>>;
}
impl React<Z> for s {
    type O = Cons<s, Cons<Z, Nil>>;
}
struct t;
impl React<T> for t {
    type O = Nil;
}
impl React<a> for t {
    type O = Cons<t, Cons<a, Nil>>;
}
impl React<b> for t {
    type O = Cons<t, Cons<b, Nil>>;
}
impl React<c> for t {
    type O = Cons<t, Cons<c, Nil>>;
}
impl React<d> for t {
    type O = Cons<t, Cons<d, Nil>>;
}
impl React<e> for t {
    type O = Cons<t, Cons<e, Nil>>;
}
impl React<f> for t {
    type O = Cons<t, Cons<f, Nil>>;
}
impl React<g> for t {
    type O = Cons<t, Cons<g, Nil>>;
}
impl React<h> for t {
    type O = Cons<t, Cons<h, Nil>>;
}
impl React<i> for t {
    type O = Cons<t, Cons<i, Nil>>;
}
impl React<j> for t {
    type O = Cons<t, Cons<j, Nil>>;
}
impl React<k> for t {
    type O = Cons<t, Cons<k, Nil>>;
}
impl React<l> for t {
    type O = Cons<t, Cons<l, Nil>>;
}
impl React<m> for t {
    type O = Cons<t, Cons<m, Nil>>;
}
impl React<n> for t {
    type O = Cons<t, Cons<n, Nil>>;
}
impl React<o> for t {
    type O = Cons<t, Cons<o, Nil>>;
}
impl React<p> for t {
    type O = Cons<t, Cons<p, Nil>>;
}
impl React<q> for t {
    type O = Cons<t, Cons<q, Nil>>;
}
impl React<r> for t {
    type O = Cons<t, Cons<r, Nil>>;
}
impl React<s> for t {
    type O = Cons<t, Cons<s, Nil>>;
}
impl React<t> for t {
    type O = Cons<t, Cons<t, Nil>>;
}
impl React<u> for t {
    type O = Cons<t, Cons<u, Nil>>;
}
impl React<v> for t {
    type O = Cons<t, Cons<v, Nil>>;
}
impl React<w> for t {
    type O = Cons<t, Cons<w, Nil>>;
}
impl React<x> for t {
    type O = Cons<t, Cons<x, Nil>>;
}
impl React<y> for t {
    type O = Cons<t, Cons<y, Nil>>;
}
impl React<z> for t {
    type O = Cons<t, Cons<z, Nil>>;
}
impl React<A> for t {
    type O = Cons<t, Cons<A, Nil>>;
}
impl React<B> for t {
    type O = Cons<t, Cons<B, Nil>>;
}
impl React<C> for t {
    type O = Cons<t, Cons<C, Nil>>;
}
impl React<D> for t {
    type O = Cons<t, Cons<D, Nil>>;
}
impl React<E> for t {
    type O = Cons<t, Cons<E, Nil>>;
}
impl React<F> for t {
    type O = Cons<t, Cons<F, Nil>>;
}
impl React<G> for t {
    type O = Cons<t, Cons<G, Nil>>;
}
impl React<H> for t {
    type O = Cons<t, Cons<H, Nil>>;
}
impl React<I> for t {
    type O = Cons<t, Cons<I, Nil>>;
}
impl React<J> for t {
    type O = Cons<t, Cons<J, Nil>>;
}
impl React<K> for t {
    type O = Cons<t, Cons<K, Nil>>;
}
impl React<L> for t {
    type O = Cons<t, Cons<L, Nil>>;
}
impl React<M> for t {
    type O = Cons<t, Cons<M, Nil>>;
}
impl React<N> for t {
    type O = Cons<t, Cons<N, Nil>>;
}
impl React<O> for t {
    type O = Cons<t, Cons<O, Nil>>;
}
impl React<P> for t {
    type O = Cons<t, Cons<P, Nil>>;
}
impl React<Q> for t {
    type O = Cons<t, Cons<Q, Nil>>;
}
impl React<R> for t {
    type O = Cons<t, Cons<R, Nil>>;
}
impl React<S> for t {
    type O = Cons<t, Cons<S, Nil>>;
}
impl React<U> for t {
    type O = Cons<t, Cons<U, Nil>>;
}
impl React<V> for t {
    type O = Cons<t, Cons<V, Nil>>;
}
impl React<W> for t {
    type O = Cons<t, Cons<W, Nil>>;
}
impl React<X> for t {
    type O = Cons<t, Cons<X, Nil>>;
}
impl React<Y> for t {
    type O = Cons<t, Cons<Y, Nil>>;
}
impl React<Z> for t {
    type O = Cons<t, Cons<Z, Nil>>;
}
struct u;
impl React<U> for u {
    type O = Nil;
}
impl React<a> for u {
    type O = Cons<u, Cons<a, Nil>>;
}
impl React<b> for u {
    type O = Cons<u, Cons<b, Nil>>;
}
impl React<c> for u {
    type O = Cons<u, Cons<c, Nil>>;
}
impl React<d> for u {
    type O = Cons<u, Cons<d, Nil>>;
}
impl React<e> for u {
    type O = Cons<u, Cons<e, Nil>>;
}
impl React<f> for u {
    type O = Cons<u, Cons<f, Nil>>;
}
impl React<g> for u {
    type O = Cons<u, Cons<g, Nil>>;
}
impl React<h> for u {
    type O = Cons<u, Cons<h, Nil>>;
}
impl React<i> for u {
    type O = Cons<u, Cons<i, Nil>>;
}
impl React<j> for u {
    type O = Cons<u, Cons<j, Nil>>;
}
impl React<k> for u {
    type O = Cons<u, Cons<k, Nil>>;
}
impl React<l> for u {
    type O = Cons<u, Cons<l, Nil>>;
}
impl React<m> for u {
    type O = Cons<u, Cons<m, Nil>>;
}
impl React<n> for u {
    type O = Cons<u, Cons<n, Nil>>;
}
impl React<o> for u {
    type O = Cons<u, Cons<o, Nil>>;
}
impl React<p> for u {
    type O = Cons<u, Cons<p, Nil>>;
}
impl React<q> for u {
    type O = Cons<u, Cons<q, Nil>>;
}
impl React<r> for u {
    type O = Cons<u, Cons<r, Nil>>;
}
impl React<s> for u {
    type O = Cons<u, Cons<s, Nil>>;
}
impl React<t> for u {
    type O = Cons<u, Cons<t, Nil>>;
}
impl React<u> for u {
    type O = Cons<u, Cons<u, Nil>>;
}
impl React<v> for u {
    type O = Cons<u, Cons<v, Nil>>;
}
impl React<w> for u {
    type O = Cons<u, Cons<w, Nil>>;
}
impl React<x> for u {
    type O = Cons<u, Cons<x, Nil>>;
}
impl React<y> for u {
    type O = Cons<u, Cons<y, Nil>>;
}
impl React<z> for u {
    type O = Cons<u, Cons<z, Nil>>;
}
impl React<A> for u {
    type O = Cons<u, Cons<A, Nil>>;
}
impl React<B> for u {
    type O = Cons<u, Cons<B, Nil>>;
}
impl React<C> for u {
    type O = Cons<u, Cons<C, Nil>>;
}
impl React<D> for u {
    type O = Cons<u, Cons<D, Nil>>;
}
impl React<E> for u {
    type O = Cons<u, Cons<E, Nil>>;
}
impl React<F> for u {
    type O = Cons<u, Cons<F, Nil>>;
}
impl React<G> for u {
    type O = Cons<u, Cons<G, Nil>>;
}
impl React<H> for u {
    type O = Cons<u, Cons<H, Nil>>;
}
impl React<I> for u {
    type O = Cons<u, Cons<I, Nil>>;
}
impl React<J> for u {
    type O = Cons<u, Cons<J, Nil>>;
}
impl React<K> for u {
    type O = Cons<u, Cons<K, Nil>>;
}
impl React<L> for u {
    type O = Cons<u, Cons<L, Nil>>;
}
impl React<M> for u {
    type O = Cons<u, Cons<M, Nil>>;
}
impl React<N> for u {
    type O = Cons<u, Cons<N, Nil>>;
}
impl React<O> for u {
    type O = Cons<u, Cons<O, Nil>>;
}
impl React<P> for u {
    type O = Cons<u, Cons<P, Nil>>;
}
impl React<Q> for u {
    type O = Cons<u, Cons<Q, Nil>>;
}
impl React<R> for u {
    type O = Cons<u, Cons<R, Nil>>;
}
impl React<S> for u {
    type O = Cons<u, Cons<S, Nil>>;
}
impl React<T> for u {
    type O = Cons<u, Cons<T, Nil>>;
}
impl React<V> for u {
    type O = Cons<u, Cons<V, Nil>>;
}
impl React<W> for u {
    type O = Cons<u, Cons<W, Nil>>;
}
impl React<X> for u {
    type O = Cons<u, Cons<X, Nil>>;
}
impl React<Y> for u {
    type O = Cons<u, Cons<Y, Nil>>;
}
impl React<Z> for u {
    type O = Cons<u, Cons<Z, Nil>>;
}
struct v;
impl React<V> for v {
    type O = Nil;
}
impl React<a> for v {
    type O = Cons<v, Cons<a, Nil>>;
}
impl React<b> for v {
    type O = Cons<v, Cons<b, Nil>>;
}
impl React<c> for v {
    type O = Cons<v, Cons<c, Nil>>;
}
impl React<d> for v {
    type O = Cons<v, Cons<d, Nil>>;
}
impl React<e> for v {
    type O = Cons<v, Cons<e, Nil>>;
}
impl React<f> for v {
    type O = Cons<v, Cons<f, Nil>>;
}
impl React<g> for v {
    type O = Cons<v, Cons<g, Nil>>;
}
impl React<h> for v {
    type O = Cons<v, Cons<h, Nil>>;
}
impl React<i> for v {
    type O = Cons<v, Cons<i, Nil>>;
}
impl React<j> for v {
    type O = Cons<v, Cons<j, Nil>>;
}
impl React<k> for v {
    type O = Cons<v, Cons<k, Nil>>;
}
impl React<l> for v {
    type O = Cons<v, Cons<l, Nil>>;
}
impl React<m> for v {
    type O = Cons<v, Cons<m, Nil>>;
}
impl React<n> for v {
    type O = Cons<v, Cons<n, Nil>>;
}
impl React<o> for v {
    type O = Cons<v, Cons<o, Nil>>;
}
impl React<p> for v {
    type O = Cons<v, Cons<p, Nil>>;
}
impl React<q> for v {
    type O = Cons<v, Cons<q, Nil>>;
}
impl React<r> for v {
    type O = Cons<v, Cons<r, Nil>>;
}
impl React<s> for v {
    type O = Cons<v, Cons<s, Nil>>;
}
impl React<t> for v {
    type O = Cons<v, Cons<t, Nil>>;
}
impl React<u> for v {
    type O = Cons<v, Cons<u, Nil>>;
}
impl React<v> for v {
    type O = Cons<v, Cons<v, Nil>>;
}
impl React<w> for v {
    type O = Cons<v, Cons<w, Nil>>;
}
impl React<x> for v {
    type O = Cons<v, Cons<x, Nil>>;
}
impl React<y> for v {
    type O = Cons<v, Cons<y, Nil>>;
}
impl React<z> for v {
    type O = Cons<v, Cons<z, Nil>>;
}
impl React<A> for v {
    type O = Cons<v, Cons<A, Nil>>;
}
impl React<B> for v {
    type O = Cons<v, Cons<B, Nil>>;
}
impl React<C> for v {
    type O = Cons<v, Cons<C, Nil>>;
}
impl React<D> for v {
    type O = Cons<v, Cons<D, Nil>>;
}
impl React<E> for v {
    type O = Cons<v, Cons<E, Nil>>;
}
impl React<F> for v {
    type O = Cons<v, Cons<F, Nil>>;
}
impl React<G> for v {
    type O = Cons<v, Cons<G, Nil>>;
}
impl React<H> for v {
    type O = Cons<v, Cons<H, Nil>>;
}
impl React<I> for v {
    type O = Cons<v, Cons<I, Nil>>;
}
impl React<J> for v {
    type O = Cons<v, Cons<J, Nil>>;
}
impl React<K> for v {
    type O = Cons<v, Cons<K, Nil>>;
}
impl React<L> for v {
    type O = Cons<v, Cons<L, Nil>>;
}
impl React<M> for v {
    type O = Cons<v, Cons<M, Nil>>;
}
impl React<N> for v {
    type O = Cons<v, Cons<N, Nil>>;
}
impl React<O> for v {
    type O = Cons<v, Cons<O, Nil>>;
}
impl React<P> for v {
    type O = Cons<v, Cons<P, Nil>>;
}
impl React<Q> for v {
    type O = Cons<v, Cons<Q, Nil>>;
}
impl React<R> for v {
    type O = Cons<v, Cons<R, Nil>>;
}
impl React<S> for v {
    type O = Cons<v, Cons<S, Nil>>;
}
impl React<T> for v {
    type O = Cons<v, Cons<T, Nil>>;
}
impl React<U> for v {
    type O = Cons<v, Cons<U, Nil>>;
}
impl React<W> for v {
    type O = Cons<v, Cons<W, Nil>>;
}
impl React<X> for v {
    type O = Cons<v, Cons<X, Nil>>;
}
impl React<Y> for v {
    type O = Cons<v, Cons<Y, Nil>>;
}
impl React<Z> for v {
    type O = Cons<v, Cons<Z, Nil>>;
}
struct w;
impl React<W> for w {
    type O = Nil;
}
impl React<a> for w {
    type O = Cons<w, Cons<a, Nil>>;
}
impl React<b> for w {
    type O = Cons<w, Cons<b, Nil>>;
}
impl React<c> for w {
    type O = Cons<w, Cons<c, Nil>>;
}
impl React<d> for w {
    type O = Cons<w, Cons<d, Nil>>;
}
impl React<e> for w {
    type O = Cons<w, Cons<e, Nil>>;
}
impl React<f> for w {
    type O = Cons<w, Cons<f, Nil>>;
}
impl React<g> for w {
    type O = Cons<w, Cons<g, Nil>>;
}
impl React<h> for w {
    type O = Cons<w, Cons<h, Nil>>;
}
impl React<i> for w {
    type O = Cons<w, Cons<i, Nil>>;
}
impl React<j> for w {
    type O = Cons<w, Cons<j, Nil>>;
}
impl React<k> for w {
    type O = Cons<w, Cons<k, Nil>>;
}
impl React<l> for w {
    type O = Cons<w, Cons<l, Nil>>;
}
impl React<m> for w {
    type O = Cons<w, Cons<m, Nil>>;
}
impl React<n> for w {
    type O = Cons<w, Cons<n, Nil>>;
}
impl React<o> for w {
    type O = Cons<w, Cons<o, Nil>>;
}
impl React<p> for w {
    type O = Cons<w, Cons<p, Nil>>;
}
impl React<q> for w {
    type O = Cons<w, Cons<q, Nil>>;
}
impl React<r> for w {
    type O = Cons<w, Cons<r, Nil>>;
}
impl React<s> for w {
    type O = Cons<w, Cons<s, Nil>>;
}
impl React<t> for w {
    type O = Cons<w, Cons<t, Nil>>;
}
impl React<u> for w {
    type O = Cons<w, Cons<u, Nil>>;
}
impl React<v> for w {
    type O = Cons<w, Cons<v, Nil>>;
}
impl React<w> for w {
    type O = Cons<w, Cons<w, Nil>>;
}
impl React<x> for w {
    type O = Cons<w, Cons<x, Nil>>;
}
impl React<y> for w {
    type O = Cons<w, Cons<y, Nil>>;
}
impl React<z> for w {
    type O = Cons<w, Cons<z, Nil>>;
}
impl React<A> for w {
    type O = Cons<w, Cons<A, Nil>>;
}
impl React<B> for w {
    type O = Cons<w, Cons<B, Nil>>;
}
impl React<C> for w {
    type O = Cons<w, Cons<C, Nil>>;
}
impl React<D> for w {
    type O = Cons<w, Cons<D, Nil>>;
}
impl React<E> for w {
    type O = Cons<w, Cons<E, Nil>>;
}
impl React<F> for w {
    type O = Cons<w, Cons<F, Nil>>;
}
impl React<G> for w {
    type O = Cons<w, Cons<G, Nil>>;
}
impl React<H> for w {
    type O = Cons<w, Cons<H, Nil>>;
}
impl React<I> for w {
    type O = Cons<w, Cons<I, Nil>>;
}
impl React<J> for w {
    type O = Cons<w, Cons<J, Nil>>;
}
impl React<K> for w {
    type O = Cons<w, Cons<K, Nil>>;
}
impl React<L> for w {
    type O = Cons<w, Cons<L, Nil>>;
}
impl React<M> for w {
    type O = Cons<w, Cons<M, Nil>>;
}
impl React<N> for w {
    type O = Cons<w, Cons<N, Nil>>;
}
impl React<O> for w {
    type O = Cons<w, Cons<O, Nil>>;
}
impl React<P> for w {
    type O = Cons<w, Cons<P, Nil>>;
}
impl React<Q> for w {
    type O = Cons<w, Cons<Q, Nil>>;
}
impl React<R> for w {
    type O = Cons<w, Cons<R, Nil>>;
}
impl React<S> for w {
    type O = Cons<w, Cons<S, Nil>>;
}
impl React<T> for w {
    type O = Cons<w, Cons<T, Nil>>;
}
impl React<U> for w {
    type O = Cons<w, Cons<U, Nil>>;
}
impl React<V> for w {
    type O = Cons<w, Cons<V, Nil>>;
}
impl React<X> for w {
    type O = Cons<w, Cons<X, Nil>>;
}
impl React<Y> for w {
    type O = Cons<w, Cons<Y, Nil>>;
}
impl React<Z> for w {
    type O = Cons<w, Cons<Z, Nil>>;
}
struct x;
impl React<X> for x {
    type O = Nil;
}
impl React<a> for x {
    type O = Cons<x, Cons<a, Nil>>;
}
impl React<b> for x {
    type O = Cons<x, Cons<b, Nil>>;
}
impl React<c> for x {
    type O = Cons<x, Cons<c, Nil>>;
}
impl React<d> for x {
    type O = Cons<x, Cons<d, Nil>>;
}
impl React<e> for x {
    type O = Cons<x, Cons<e, Nil>>;
}
impl React<f> for x {
    type O = Cons<x, Cons<f, Nil>>;
}
impl React<g> for x {
    type O = Cons<x, Cons<g, Nil>>;
}
impl React<h> for x {
    type O = Cons<x, Cons<h, Nil>>;
}
impl React<i> for x {
    type O = Cons<x, Cons<i, Nil>>;
}
impl React<j> for x {
    type O = Cons<x, Cons<j, Nil>>;
}
impl React<k> for x {
    type O = Cons<x, Cons<k, Nil>>;
}
impl React<l> for x {
    type O = Cons<x, Cons<l, Nil>>;
}
impl React<m> for x {
    type O = Cons<x, Cons<m, Nil>>;
}
impl React<n> for x {
    type O = Cons<x, Cons<n, Nil>>;
}
impl React<o> for x {
    type O = Cons<x, Cons<o, Nil>>;
}
impl React<p> for x {
    type O = Cons<x, Cons<p, Nil>>;
}
impl React<q> for x {
    type O = Cons<x, Cons<q, Nil>>;
}
impl React<r> for x {
    type O = Cons<x, Cons<r, Nil>>;
}
impl React<s> for x {
    type O = Cons<x, Cons<s, Nil>>;
}
impl React<t> for x {
    type O = Cons<x, Cons<t, Nil>>;
}
impl React<u> for x {
    type O = Cons<x, Cons<u, Nil>>;
}
impl React<v> for x {
    type O = Cons<x, Cons<v, Nil>>;
}
impl React<w> for x {
    type O = Cons<x, Cons<w, Nil>>;
}
impl React<x> for x {
    type O = Cons<x, Cons<x, Nil>>;
}
impl React<y> for x {
    type O = Cons<x, Cons<y, Nil>>;
}
impl React<z> for x {
    type O = Cons<x, Cons<z, Nil>>;
}
impl React<A> for x {
    type O = Cons<x, Cons<A, Nil>>;
}
impl React<B> for x {
    type O = Cons<x, Cons<B, Nil>>;
}
impl React<C> for x {
    type O = Cons<x, Cons<C, Nil>>;
}
impl React<D> for x {
    type O = Cons<x, Cons<D, Nil>>;
}
impl React<E> for x {
    type O = Cons<x, Cons<E, Nil>>;
}
impl React<F> for x {
    type O = Cons<x, Cons<F, Nil>>;
}
impl React<G> for x {
    type O = Cons<x, Cons<G, Nil>>;
}
impl React<H> for x {
    type O = Cons<x, Cons<H, Nil>>;
}
impl React<I> for x {
    type O = Cons<x, Cons<I, Nil>>;
}
impl React<J> for x {
    type O = Cons<x, Cons<J, Nil>>;
}
impl React<K> for x {
    type O = Cons<x, Cons<K, Nil>>;
}
impl React<L> for x {
    type O = Cons<x, Cons<L, Nil>>;
}
impl React<M> for x {
    type O = Cons<x, Cons<M, Nil>>;
}
impl React<N> for x {
    type O = Cons<x, Cons<N, Nil>>;
}
impl React<O> for x {
    type O = Cons<x, Cons<O, Nil>>;
}
impl React<P> for x {
    type O = Cons<x, Cons<P, Nil>>;
}
impl React<Q> for x {
    type O = Cons<x, Cons<Q, Nil>>;
}
impl React<R> for x {
    type O = Cons<x, Cons<R, Nil>>;
}
impl React<S> for x {
    type O = Cons<x, Cons<S, Nil>>;
}
impl React<T> for x {
    type O = Cons<x, Cons<T, Nil>>;
}
impl React<U> for x {
    type O = Cons<x, Cons<U, Nil>>;
}
impl React<V> for x {
    type O = Cons<x, Cons<V, Nil>>;
}
impl React<W> for x {
    type O = Cons<x, Cons<W, Nil>>;
}
impl React<Y> for x {
    type O = Cons<x, Cons<Y, Nil>>;
}
impl React<Z> for x {
    type O = Cons<x, Cons<Z, Nil>>;
}
struct y;
impl React<Y> for y {
    type O = Nil;
}
impl React<a> for y {
    type O = Cons<y, Cons<a, Nil>>;
}
impl React<b> for y {
    type O = Cons<y, Cons<b, Nil>>;
}
impl React<c> for y {
    type O = Cons<y, Cons<c, Nil>>;
}
impl React<d> for y {
    type O = Cons<y, Cons<d, Nil>>;
}
impl React<e> for y {
    type O = Cons<y, Cons<e, Nil>>;
}
impl React<f> for y {
    type O = Cons<y, Cons<f, Nil>>;
}
impl React<g> for y {
    type O = Cons<y, Cons<g, Nil>>;
}
impl React<h> for y {
    type O = Cons<y, Cons<h, Nil>>;
}
impl React<i> for y {
    type O = Cons<y, Cons<i, Nil>>;
}
impl React<j> for y {
    type O = Cons<y, Cons<j, Nil>>;
}
impl React<k> for y {
    type O = Cons<y, Cons<k, Nil>>;
}
impl React<l> for y {
    type O = Cons<y, Cons<l, Nil>>;
}
impl React<m> for y {
    type O = Cons<y, Cons<m, Nil>>;
}
impl React<n> for y {
    type O = Cons<y, Cons<n, Nil>>;
}
impl React<o> for y {
    type O = Cons<y, Cons<o, Nil>>;
}
impl React<p> for y {
    type O = Cons<y, Cons<p, Nil>>;
}
impl React<q> for y {
    type O = Cons<y, Cons<q, Nil>>;
}
impl React<r> for y {
    type O = Cons<y, Cons<r, Nil>>;
}
impl React<s> for y {
    type O = Cons<y, Cons<s, Nil>>;
}
impl React<t> for y {
    type O = Cons<y, Cons<t, Nil>>;
}
impl React<u> for y {
    type O = Cons<y, Cons<u, Nil>>;
}
impl React<v> for y {
    type O = Cons<y, Cons<v, Nil>>;
}
impl React<w> for y {
    type O = Cons<y, Cons<w, Nil>>;
}
impl React<x> for y {
    type O = Cons<y, Cons<x, Nil>>;
}
impl React<y> for y {
    type O = Cons<y, Cons<y, Nil>>;
}
impl React<z> for y {
    type O = Cons<y, Cons<z, Nil>>;
}
impl React<A> for y {
    type O = Cons<y, Cons<A, Nil>>;
}
impl React<B> for y {
    type O = Cons<y, Cons<B, Nil>>;
}
impl React<C> for y {
    type O = Cons<y, Cons<C, Nil>>;
}
impl React<D> for y {
    type O = Cons<y, Cons<D, Nil>>;
}
impl React<E> for y {
    type O = Cons<y, Cons<E, Nil>>;
}
impl React<F> for y {
    type O = Cons<y, Cons<F, Nil>>;
}
impl React<G> for y {
    type O = Cons<y, Cons<G, Nil>>;
}
impl React<H> for y {
    type O = Cons<y, Cons<H, Nil>>;
}
impl React<I> for y {
    type O = Cons<y, Cons<I, Nil>>;
}
impl React<J> for y {
    type O = Cons<y, Cons<J, Nil>>;
}
impl React<K> for y {
    type O = Cons<y, Cons<K, Nil>>;
}
impl React<L> for y {
    type O = Cons<y, Cons<L, Nil>>;
}
impl React<M> for y {
    type O = Cons<y, Cons<M, Nil>>;
}
impl React<N> for y {
    type O = Cons<y, Cons<N, Nil>>;
}
impl React<O> for y {
    type O = Cons<y, Cons<O, Nil>>;
}
impl React<P> for y {
    type O = Cons<y, Cons<P, Nil>>;
}
impl React<Q> for y {
    type O = Cons<y, Cons<Q, Nil>>;
}
impl React<R> for y {
    type O = Cons<y, Cons<R, Nil>>;
}
impl React<S> for y {
    type O = Cons<y, Cons<S, Nil>>;
}
impl React<T> for y {
    type O = Cons<y, Cons<T, Nil>>;
}
impl React<U> for y {
    type O = Cons<y, Cons<U, Nil>>;
}
impl React<V> for y {
    type O = Cons<y, Cons<V, Nil>>;
}
impl React<W> for y {
    type O = Cons<y, Cons<W, Nil>>;
}
impl React<X> for y {
    type O = Cons<y, Cons<X, Nil>>;
}
impl React<Z> for y {
    type O = Cons<y, Cons<Z, Nil>>;
}
struct z;
impl React<Z> for z {
    type O = Nil;
}
impl React<a> for z {
    type O = Cons<z, Cons<a, Nil>>;
}
impl React<b> for z {
    type O = Cons<z, Cons<b, Nil>>;
}
impl React<c> for z {
    type O = Cons<z, Cons<c, Nil>>;
}
impl React<d> for z {
    type O = Cons<z, Cons<d, Nil>>;
}
impl React<e> for z {
    type O = Cons<z, Cons<e, Nil>>;
}
impl React<f> for z {
    type O = Cons<z, Cons<f, Nil>>;
}
impl React<g> for z {
    type O = Cons<z, Cons<g, Nil>>;
}
impl React<h> for z {
    type O = Cons<z, Cons<h, Nil>>;
}
impl React<i> for z {
    type O = Cons<z, Cons<i, Nil>>;
}
impl React<j> for z {
    type O = Cons<z, Cons<j, Nil>>;
}
impl React<k> for z {
    type O = Cons<z, Cons<k, Nil>>;
}
impl React<l> for z {
    type O = Cons<z, Cons<l, Nil>>;
}
impl React<m> for z {
    type O = Cons<z, Cons<m, Nil>>;
}
impl React<n> for z {
    type O = Cons<z, Cons<n, Nil>>;
}
impl React<o> for z {
    type O = Cons<z, Cons<o, Nil>>;
}
impl React<p> for z {
    type O = Cons<z, Cons<p, Nil>>;
}
impl React<q> for z {
    type O = Cons<z, Cons<q, Nil>>;
}
impl React<r> for z {
    type O = Cons<z, Cons<r, Nil>>;
}
impl React<s> for z {
    type O = Cons<z, Cons<s, Nil>>;
}
impl React<t> for z {
    type O = Cons<z, Cons<t, Nil>>;
}
impl React<u> for z {
    type O = Cons<z, Cons<u, Nil>>;
}
impl React<v> for z {
    type O = Cons<z, Cons<v, Nil>>;
}
impl React<w> for z {
    type O = Cons<z, Cons<w, Nil>>;
}
impl React<x> for z {
    type O = Cons<z, Cons<x, Nil>>;
}
impl React<y> for z {
    type O = Cons<z, Cons<y, Nil>>;
}
impl React<z> for z {
    type O = Cons<z, Cons<z, Nil>>;
}
impl React<A> for z {
    type O = Cons<z, Cons<A, Nil>>;
}
impl React<B> for z {
    type O = Cons<z, Cons<B, Nil>>;
}
impl React<C> for z {
    type O = Cons<z, Cons<C, Nil>>;
}
impl React<D> for z {
    type O = Cons<z, Cons<D, Nil>>;
}
impl React<E> for z {
    type O = Cons<z, Cons<E, Nil>>;
}
impl React<F> for z {
    type O = Cons<z, Cons<F, Nil>>;
}
impl React<G> for z {
    type O = Cons<z, Cons<G, Nil>>;
}
impl React<H> for z {
    type O = Cons<z, Cons<H, Nil>>;
}
impl React<I> for z {
    type O = Cons<z, Cons<I, Nil>>;
}
impl React<J> for z {
    type O = Cons<z, Cons<J, Nil>>;
}
impl React<K> for z {
    type O = Cons<z, Cons<K, Nil>>;
}
impl React<L> for z {
    type O = Cons<z, Cons<L, Nil>>;
}
impl React<M> for z {
    type O = Cons<z, Cons<M, Nil>>;
}
impl React<N> for z {
    type O = Cons<z, Cons<N, Nil>>;
}
impl React<O> for z {
    type O = Cons<z, Cons<O, Nil>>;
}
impl React<P> for z {
    type O = Cons<z, Cons<P, Nil>>;
}
impl React<Q> for z {
    type O = Cons<z, Cons<Q, Nil>>;
}
impl React<R> for z {
    type O = Cons<z, Cons<R, Nil>>;
}
impl React<S> for z {
    type O = Cons<z, Cons<S, Nil>>;
}
impl React<T> for z {
    type O = Cons<z, Cons<T, Nil>>;
}
impl React<U> for z {
    type O = Cons<z, Cons<U, Nil>>;
}
impl React<V> for z {
    type O = Cons<z, Cons<V, Nil>>;
}
impl React<W> for z {
    type O = Cons<z, Cons<W, Nil>>;
}
impl React<X> for z {
    type O = Cons<z, Cons<X, Nil>>;
}
impl React<Y> for z {
    type O = Cons<z, Cons<Y, Nil>>;
}
struct A;
impl React<a> for A {
    type O = Nil;
}
impl React<A> for A {
    type O = Cons<A, Cons<A, Nil>>;
}
impl React<B> for A {
    type O = Cons<A, Cons<B, Nil>>;
}
impl React<C> for A {
    type O = Cons<A, Cons<C, Nil>>;
}
impl React<D> for A {
    type O = Cons<A, Cons<D, Nil>>;
}
impl React<E> for A {
    type O = Cons<A, Cons<E, Nil>>;
}
impl React<F> for A {
    type O = Cons<A, Cons<F, Nil>>;
}
impl React<G> for A {
    type O = Cons<A, Cons<G, Nil>>;
}
impl React<H> for A {
    type O = Cons<A, Cons<H, Nil>>;
}
impl React<I> for A {
    type O = Cons<A, Cons<I, Nil>>;
}
impl React<J> for A {
    type O = Cons<A, Cons<J, Nil>>;
}
impl React<K> for A {
    type O = Cons<A, Cons<K, Nil>>;
}
impl React<L> for A {
    type O = Cons<A, Cons<L, Nil>>;
}
impl React<M> for A {
    type O = Cons<A, Cons<M, Nil>>;
}
impl React<N> for A {
    type O = Cons<A, Cons<N, Nil>>;
}
impl React<O> for A {
    type O = Cons<A, Cons<O, Nil>>;
}
impl React<P> for A {
    type O = Cons<A, Cons<P, Nil>>;
}
impl React<Q> for A {
    type O = Cons<A, Cons<Q, Nil>>;
}
impl React<R> for A {
    type O = Cons<A, Cons<R, Nil>>;
}
impl React<S> for A {
    type O = Cons<A, Cons<S, Nil>>;
}
impl React<T> for A {
    type O = Cons<A, Cons<T, Nil>>;
}
impl React<U> for A {
    type O = Cons<A, Cons<U, Nil>>;
}
impl React<V> for A {
    type O = Cons<A, Cons<V, Nil>>;
}
impl React<W> for A {
    type O = Cons<A, Cons<W, Nil>>;
}
impl React<X> for A {
    type O = Cons<A, Cons<X, Nil>>;
}
impl React<Y> for A {
    type O = Cons<A, Cons<Y, Nil>>;
}
impl React<Z> for A {
    type O = Cons<A, Cons<Z, Nil>>;
}
impl React<b> for A {
    type O = Cons<A, Cons<b, Nil>>;
}
impl React<c> for A {
    type O = Cons<A, Cons<c, Nil>>;
}
impl React<d> for A {
    type O = Cons<A, Cons<d, Nil>>;
}
impl React<e> for A {
    type O = Cons<A, Cons<e, Nil>>;
}
impl React<f> for A {
    type O = Cons<A, Cons<f, Nil>>;
}
impl React<g> for A {
    type O = Cons<A, Cons<g, Nil>>;
}
impl React<h> for A {
    type O = Cons<A, Cons<h, Nil>>;
}
impl React<i> for A {
    type O = Cons<A, Cons<i, Nil>>;
}
impl React<j> for A {
    type O = Cons<A, Cons<j, Nil>>;
}
impl React<k> for A {
    type O = Cons<A, Cons<k, Nil>>;
}
impl React<l> for A {
    type O = Cons<A, Cons<l, Nil>>;
}
impl React<m> for A {
    type O = Cons<A, Cons<m, Nil>>;
}
impl React<n> for A {
    type O = Cons<A, Cons<n, Nil>>;
}
impl React<o> for A {
    type O = Cons<A, Cons<o, Nil>>;
}
impl React<p> for A {
    type O = Cons<A, Cons<p, Nil>>;
}
impl React<q> for A {
    type O = Cons<A, Cons<q, Nil>>;
}
impl React<r> for A {
    type O = Cons<A, Cons<r, Nil>>;
}
impl React<s> for A {
    type O = Cons<A, Cons<s, Nil>>;
}
impl React<t> for A {
    type O = Cons<A, Cons<t, Nil>>;
}
impl React<u> for A {
    type O = Cons<A, Cons<u, Nil>>;
}
impl React<v> for A {
    type O = Cons<A, Cons<v, Nil>>;
}
impl React<w> for A {
    type O = Cons<A, Cons<w, Nil>>;
}
impl React<x> for A {
    type O = Cons<A, Cons<x, Nil>>;
}
impl React<y> for A {
    type O = Cons<A, Cons<y, Nil>>;
}
impl React<z> for A {
    type O = Cons<A, Cons<z, Nil>>;
}
struct B;
impl React<b> for B {
    type O = Nil;
}
impl React<A> for B {
    type O = Cons<B, Cons<A, Nil>>;
}
impl React<B> for B {
    type O = Cons<B, Cons<B, Nil>>;
}
impl React<C> for B {
    type O = Cons<B, Cons<C, Nil>>;
}
impl React<D> for B {
    type O = Cons<B, Cons<D, Nil>>;
}
impl React<E> for B {
    type O = Cons<B, Cons<E, Nil>>;
}
impl React<F> for B {
    type O = Cons<B, Cons<F, Nil>>;
}
impl React<G> for B {
    type O = Cons<B, Cons<G, Nil>>;
}
impl React<H> for B {
    type O = Cons<B, Cons<H, Nil>>;
}
impl React<I> for B {
    type O = Cons<B, Cons<I, Nil>>;
}
impl React<J> for B {
    type O = Cons<B, Cons<J, Nil>>;
}
impl React<K> for B {
    type O = Cons<B, Cons<K, Nil>>;
}
impl React<L> for B {
    type O = Cons<B, Cons<L, Nil>>;
}
impl React<M> for B {
    type O = Cons<B, Cons<M, Nil>>;
}
impl React<N> for B {
    type O = Cons<B, Cons<N, Nil>>;
}
impl React<O> for B {
    type O = Cons<B, Cons<O, Nil>>;
}
impl React<P> for B {
    type O = Cons<B, Cons<P, Nil>>;
}
impl React<Q> for B {
    type O = Cons<B, Cons<Q, Nil>>;
}
impl React<R> for B {
    type O = Cons<B, Cons<R, Nil>>;
}
impl React<S> for B {
    type O = Cons<B, Cons<S, Nil>>;
}
impl React<T> for B {
    type O = Cons<B, Cons<T, Nil>>;
}
impl React<U> for B {
    type O = Cons<B, Cons<U, Nil>>;
}
impl React<V> for B {
    type O = Cons<B, Cons<V, Nil>>;
}
impl React<W> for B {
    type O = Cons<B, Cons<W, Nil>>;
}
impl React<X> for B {
    type O = Cons<B, Cons<X, Nil>>;
}
impl React<Y> for B {
    type O = Cons<B, Cons<Y, Nil>>;
}
impl React<Z> for B {
    type O = Cons<B, Cons<Z, Nil>>;
}
impl React<a> for B {
    type O = Cons<B, Cons<a, Nil>>;
}
impl React<c> for B {
    type O = Cons<B, Cons<c, Nil>>;
}
impl React<d> for B {
    type O = Cons<B, Cons<d, Nil>>;
}
impl React<e> for B {
    type O = Cons<B, Cons<e, Nil>>;
}
impl React<f> for B {
    type O = Cons<B, Cons<f, Nil>>;
}
impl React<g> for B {
    type O = Cons<B, Cons<g, Nil>>;
}
impl React<h> for B {
    type O = Cons<B, Cons<h, Nil>>;
}
impl React<i> for B {
    type O = Cons<B, Cons<i, Nil>>;
}
impl React<j> for B {
    type O = Cons<B, Cons<j, Nil>>;
}
impl React<k> for B {
    type O = Cons<B, Cons<k, Nil>>;
}
impl React<l> for B {
    type O = Cons<B, Cons<l, Nil>>;
}
impl React<m> for B {
    type O = Cons<B, Cons<m, Nil>>;
}
impl React<n> for B {
    type O = Cons<B, Cons<n, Nil>>;
}
impl React<o> for B {
    type O = Cons<B, Cons<o, Nil>>;
}
impl React<p> for B {
    type O = Cons<B, Cons<p, Nil>>;
}
impl React<q> for B {
    type O = Cons<B, Cons<q, Nil>>;
}
impl React<r> for B {
    type O = Cons<B, Cons<r, Nil>>;
}
impl React<s> for B {
    type O = Cons<B, Cons<s, Nil>>;
}
impl React<t> for B {
    type O = Cons<B, Cons<t, Nil>>;
}
impl React<u> for B {
    type O = Cons<B, Cons<u, Nil>>;
}
impl React<v> for B {
    type O = Cons<B, Cons<v, Nil>>;
}
impl React<w> for B {
    type O = Cons<B, Cons<w, Nil>>;
}
impl React<x> for B {
    type O = Cons<B, Cons<x, Nil>>;
}
impl React<y> for B {
    type O = Cons<B, Cons<y, Nil>>;
}
impl React<z> for B {
    type O = Cons<B, Cons<z, Nil>>;
}
struct C;
impl React<c> for C {
    type O = Nil;
}
impl React<A> for C {
    type O = Cons<C, Cons<A, Nil>>;
}
impl React<B> for C {
    type O = Cons<C, Cons<B, Nil>>;
}
impl React<C> for C {
    type O = Cons<C, Cons<C, Nil>>;
}
impl React<D> for C {
    type O = Cons<C, Cons<D, Nil>>;
}
impl React<E> for C {
    type O = Cons<C, Cons<E, Nil>>;
}
impl React<F> for C {
    type O = Cons<C, Cons<F, Nil>>;
}
impl React<G> for C {
    type O = Cons<C, Cons<G, Nil>>;
}
impl React<H> for C {
    type O = Cons<C, Cons<H, Nil>>;
}
impl React<I> for C {
    type O = Cons<C, Cons<I, Nil>>;
}
impl React<J> for C {
    type O = Cons<C, Cons<J, Nil>>;
}
impl React<K> for C {
    type O = Cons<C, Cons<K, Nil>>;
}
impl React<L> for C {
    type O = Cons<C, Cons<L, Nil>>;
}
impl React<M> for C {
    type O = Cons<C, Cons<M, Nil>>;
}
impl React<N> for C {
    type O = Cons<C, Cons<N, Nil>>;
}
impl React<O> for C {
    type O = Cons<C, Cons<O, Nil>>;
}
impl React<P> for C {
    type O = Cons<C, Cons<P, Nil>>;
}
impl React<Q> for C {
    type O = Cons<C, Cons<Q, Nil>>;
}
impl React<R> for C {
    type O = Cons<C, Cons<R, Nil>>;
}
impl React<S> for C {
    type O = Cons<C, Cons<S, Nil>>;
}
impl React<T> for C {
    type O = Cons<C, Cons<T, Nil>>;
}
impl React<U> for C {
    type O = Cons<C, Cons<U, Nil>>;
}
impl React<V> for C {
    type O = Cons<C, Cons<V, Nil>>;
}
impl React<W> for C {
    type O = Cons<C, Cons<W, Nil>>;
}
impl React<X> for C {
    type O = Cons<C, Cons<X, Nil>>;
}
impl React<Y> for C {
    type O = Cons<C, Cons<Y, Nil>>;
}
impl React<Z> for C {
    type O = Cons<C, Cons<Z, Nil>>;
}
impl React<a> for C {
    type O = Cons<C, Cons<a, Nil>>;
}
impl React<b> for C {
    type O = Cons<C, Cons<b, Nil>>;
}
impl React<d> for C {
    type O = Cons<C, Cons<d, Nil>>;
}
impl React<e> for C {
    type O = Cons<C, Cons<e, Nil>>;
}
impl React<f> for C {
    type O = Cons<C, Cons<f, Nil>>;
}
impl React<g> for C {
    type O = Cons<C, Cons<g, Nil>>;
}
impl React<h> for C {
    type O = Cons<C, Cons<h, Nil>>;
}
impl React<i> for C {
    type O = Cons<C, Cons<i, Nil>>;
}
impl React<j> for C {
    type O = Cons<C, Cons<j, Nil>>;
}
impl React<k> for C {
    type O = Cons<C, Cons<k, Nil>>;
}
impl React<l> for C {
    type O = Cons<C, Cons<l, Nil>>;
}
impl React<m> for C {
    type O = Cons<C, Cons<m, Nil>>;
}
impl React<n> for C {
    type O = Cons<C, Cons<n, Nil>>;
}
impl React<o> for C {
    type O = Cons<C, Cons<o, Nil>>;
}
impl React<p> for C {
    type O = Cons<C, Cons<p, Nil>>;
}
impl React<q> for C {
    type O = Cons<C, Cons<q, Nil>>;
}
impl React<r> for C {
    type O = Cons<C, Cons<r, Nil>>;
}
impl React<s> for C {
    type O = Cons<C, Cons<s, Nil>>;
}
impl React<t> for C {
    type O = Cons<C, Cons<t, Nil>>;
}
impl React<u> for C {
    type O = Cons<C, Cons<u, Nil>>;
}
impl React<v> for C {
    type O = Cons<C, Cons<v, Nil>>;
}
impl React<w> for C {
    type O = Cons<C, Cons<w, Nil>>;
}
impl React<x> for C {
    type O = Cons<C, Cons<x, Nil>>;
}
impl React<y> for C {
    type O = Cons<C, Cons<y, Nil>>;
}
impl React<z> for C {
    type O = Cons<C, Cons<z, Nil>>;
}
struct D;
impl React<d> for D {
    type O = Nil;
}
impl React<A> for D {
    type O = Cons<D, Cons<A, Nil>>;
}
impl React<B> for D {
    type O = Cons<D, Cons<B, Nil>>;
}
impl React<C> for D {
    type O = Cons<D, Cons<C, Nil>>;
}
impl React<D> for D {
    type O = Cons<D, Cons<D, Nil>>;
}
impl React<E> for D {
    type O = Cons<D, Cons<E, Nil>>;
}
impl React<F> for D {
    type O = Cons<D, Cons<F, Nil>>;
}
impl React<G> for D {
    type O = Cons<D, Cons<G, Nil>>;
}
impl React<H> for D {
    type O = Cons<D, Cons<H, Nil>>;
}
impl React<I> for D {
    type O = Cons<D, Cons<I, Nil>>;
}
impl React<J> for D {
    type O = Cons<D, Cons<J, Nil>>;
}
impl React<K> for D {
    type O = Cons<D, Cons<K, Nil>>;
}
impl React<L> for D {
    type O = Cons<D, Cons<L, Nil>>;
}
impl React<M> for D {
    type O = Cons<D, Cons<M, Nil>>;
}
impl React<N> for D {
    type O = Cons<D, Cons<N, Nil>>;
}
impl React<O> for D {
    type O = Cons<D, Cons<O, Nil>>;
}
impl React<P> for D {
    type O = Cons<D, Cons<P, Nil>>;
}
impl React<Q> for D {
    type O = Cons<D, Cons<Q, Nil>>;
}
impl React<R> for D {
    type O = Cons<D, Cons<R, Nil>>;
}
impl React<S> for D {
    type O = Cons<D, Cons<S, Nil>>;
}
impl React<T> for D {
    type O = Cons<D, Cons<T, Nil>>;
}
impl React<U> for D {
    type O = Cons<D, Cons<U, Nil>>;
}
impl React<V> for D {
    type O = Cons<D, Cons<V, Nil>>;
}
impl React<W> for D {
    type O = Cons<D, Cons<W, Nil>>;
}
impl React<X> for D {
    type O = Cons<D, Cons<X, Nil>>;
}
impl React<Y> for D {
    type O = Cons<D, Cons<Y, Nil>>;
}
impl React<Z> for D {
    type O = Cons<D, Cons<Z, Nil>>;
}
impl React<a> for D {
    type O = Cons<D, Cons<a, Nil>>;
}
impl React<b> for D {
    type O = Cons<D, Cons<b, Nil>>;
}
impl React<c> for D {
    type O = Cons<D, Cons<c, Nil>>;
}
impl React<e> for D {
    type O = Cons<D, Cons<e, Nil>>;
}
impl React<f> for D {
    type O = Cons<D, Cons<f, Nil>>;
}
impl React<g> for D {
    type O = Cons<D, Cons<g, Nil>>;
}
impl React<h> for D {
    type O = Cons<D, Cons<h, Nil>>;
}
impl React<i> for D {
    type O = Cons<D, Cons<i, Nil>>;
}
impl React<j> for D {
    type O = Cons<D, Cons<j, Nil>>;
}
impl React<k> for D {
    type O = Cons<D, Cons<k, Nil>>;
}
impl React<l> for D {
    type O = Cons<D, Cons<l, Nil>>;
}
impl React<m> for D {
    type O = Cons<D, Cons<m, Nil>>;
}
impl React<n> for D {
    type O = Cons<D, Cons<n, Nil>>;
}
impl React<o> for D {
    type O = Cons<D, Cons<o, Nil>>;
}
impl React<p> for D {
    type O = Cons<D, Cons<p, Nil>>;
}
impl React<q> for D {
    type O = Cons<D, Cons<q, Nil>>;
}
impl React<r> for D {
    type O = Cons<D, Cons<r, Nil>>;
}
impl React<s> for D {
    type O = Cons<D, Cons<s, Nil>>;
}
impl React<t> for D {
    type O = Cons<D, Cons<t, Nil>>;
}
impl React<u> for D {
    type O = Cons<D, Cons<u, Nil>>;
}
impl React<v> for D {
    type O = Cons<D, Cons<v, Nil>>;
}
impl React<w> for D {
    type O = Cons<D, Cons<w, Nil>>;
}
impl React<x> for D {
    type O = Cons<D, Cons<x, Nil>>;
}
impl React<y> for D {
    type O = Cons<D, Cons<y, Nil>>;
}
impl React<z> for D {
    type O = Cons<D, Cons<z, Nil>>;
}
struct E;
impl React<e> for E {
    type O = Nil;
}
impl React<A> for E {
    type O = Cons<E, Cons<A, Nil>>;
}
impl React<B> for E {
    type O = Cons<E, Cons<B, Nil>>;
}
impl React<C> for E {
    type O = Cons<E, Cons<C, Nil>>;
}
impl React<D> for E {
    type O = Cons<E, Cons<D, Nil>>;
}
impl React<E> for E {
    type O = Cons<E, Cons<E, Nil>>;
}
impl React<F> for E {
    type O = Cons<E, Cons<F, Nil>>;
}
impl React<G> for E {
    type O = Cons<E, Cons<G, Nil>>;
}
impl React<H> for E {
    type O = Cons<E, Cons<H, Nil>>;
}
impl React<I> for E {
    type O = Cons<E, Cons<I, Nil>>;
}
impl React<J> for E {
    type O = Cons<E, Cons<J, Nil>>;
}
impl React<K> for E {
    type O = Cons<E, Cons<K, Nil>>;
}
impl React<L> for E {
    type O = Cons<E, Cons<L, Nil>>;
}
impl React<M> for E {
    type O = Cons<E, Cons<M, Nil>>;
}
impl React<N> for E {
    type O = Cons<E, Cons<N, Nil>>;
}
impl React<O> for E {
    type O = Cons<E, Cons<O, Nil>>;
}
impl React<P> for E {
    type O = Cons<E, Cons<P, Nil>>;
}
impl React<Q> for E {
    type O = Cons<E, Cons<Q, Nil>>;
}
impl React<R> for E {
    type O = Cons<E, Cons<R, Nil>>;
}
impl React<S> for E {
    type O = Cons<E, Cons<S, Nil>>;
}
impl React<T> for E {
    type O = Cons<E, Cons<T, Nil>>;
}
impl React<U> for E {
    type O = Cons<E, Cons<U, Nil>>;
}
impl React<V> for E {
    type O = Cons<E, Cons<V, Nil>>;
}
impl React<W> for E {
    type O = Cons<E, Cons<W, Nil>>;
}
impl React<X> for E {
    type O = Cons<E, Cons<X, Nil>>;
}
impl React<Y> for E {
    type O = Cons<E, Cons<Y, Nil>>;
}
impl React<Z> for E {
    type O = Cons<E, Cons<Z, Nil>>;
}
impl React<a> for E {
    type O = Cons<E, Cons<a, Nil>>;
}
impl React<b> for E {
    type O = Cons<E, Cons<b, Nil>>;
}
impl React<c> for E {
    type O = Cons<E, Cons<c, Nil>>;
}
impl React<d> for E {
    type O = Cons<E, Cons<d, Nil>>;
}
impl React<f> for E {
    type O = Cons<E, Cons<f, Nil>>;
}
impl React<g> for E {
    type O = Cons<E, Cons<g, Nil>>;
}
impl React<h> for E {
    type O = Cons<E, Cons<h, Nil>>;
}
impl React<i> for E {
    type O = Cons<E, Cons<i, Nil>>;
}
impl React<j> for E {
    type O = Cons<E, Cons<j, Nil>>;
}
impl React<k> for E {
    type O = Cons<E, Cons<k, Nil>>;
}
impl React<l> for E {
    type O = Cons<E, Cons<l, Nil>>;
}
impl React<m> for E {
    type O = Cons<E, Cons<m, Nil>>;
}
impl React<n> for E {
    type O = Cons<E, Cons<n, Nil>>;
}
impl React<o> for E {
    type O = Cons<E, Cons<o, Nil>>;
}
impl React<p> for E {
    type O = Cons<E, Cons<p, Nil>>;
}
impl React<q> for E {
    type O = Cons<E, Cons<q, Nil>>;
}
impl React<r> for E {
    type O = Cons<E, Cons<r, Nil>>;
}
impl React<s> for E {
    type O = Cons<E, Cons<s, Nil>>;
}
impl React<t> for E {
    type O = Cons<E, Cons<t, Nil>>;
}
impl React<u> for E {
    type O = Cons<E, Cons<u, Nil>>;
}
impl React<v> for E {
    type O = Cons<E, Cons<v, Nil>>;
}
impl React<w> for E {
    type O = Cons<E, Cons<w, Nil>>;
}
impl React<x> for E {
    type O = Cons<E, Cons<x, Nil>>;
}
impl React<y> for E {
    type O = Cons<E, Cons<y, Nil>>;
}
impl React<z> for E {
    type O = Cons<E, Cons<z, Nil>>;
}
struct F;
impl React<f> for F {
    type O = Nil;
}
impl React<A> for F {
    type O = Cons<F, Cons<A, Nil>>;
}
impl React<B> for F {
    type O = Cons<F, Cons<B, Nil>>;
}
impl React<C> for F {
    type O = Cons<F, Cons<C, Nil>>;
}
impl React<D> for F {
    type O = Cons<F, Cons<D, Nil>>;
}
impl React<E> for F {
    type O = Cons<F, Cons<E, Nil>>;
}
impl React<F> for F {
    type O = Cons<F, Cons<F, Nil>>;
}
impl React<G> for F {
    type O = Cons<F, Cons<G, Nil>>;
}
impl React<H> for F {
    type O = Cons<F, Cons<H, Nil>>;
}
impl React<I> for F {
    type O = Cons<F, Cons<I, Nil>>;
}
impl React<J> for F {
    type O = Cons<F, Cons<J, Nil>>;
}
impl React<K> for F {
    type O = Cons<F, Cons<K, Nil>>;
}
impl React<L> for F {
    type O = Cons<F, Cons<L, Nil>>;
}
impl React<M> for F {
    type O = Cons<F, Cons<M, Nil>>;
}
impl React<N> for F {
    type O = Cons<F, Cons<N, Nil>>;
}
impl React<O> for F {
    type O = Cons<F, Cons<O, Nil>>;
}
impl React<P> for F {
    type O = Cons<F, Cons<P, Nil>>;
}
impl React<Q> for F {
    type O = Cons<F, Cons<Q, Nil>>;
}
impl React<R> for F {
    type O = Cons<F, Cons<R, Nil>>;
}
impl React<S> for F {
    type O = Cons<F, Cons<S, Nil>>;
}
impl React<T> for F {
    type O = Cons<F, Cons<T, Nil>>;
}
impl React<U> for F {
    type O = Cons<F, Cons<U, Nil>>;
}
impl React<V> for F {
    type O = Cons<F, Cons<V, Nil>>;
}
impl React<W> for F {
    type O = Cons<F, Cons<W, Nil>>;
}
impl React<X> for F {
    type O = Cons<F, Cons<X, Nil>>;
}
impl React<Y> for F {
    type O = Cons<F, Cons<Y, Nil>>;
}
impl React<Z> for F {
    type O = Cons<F, Cons<Z, Nil>>;
}
impl React<a> for F {
    type O = Cons<F, Cons<a, Nil>>;
}
impl React<b> for F {
    type O = Cons<F, Cons<b, Nil>>;
}
impl React<c> for F {
    type O = Cons<F, Cons<c, Nil>>;
}
impl React<d> for F {
    type O = Cons<F, Cons<d, Nil>>;
}
impl React<e> for F {
    type O = Cons<F, Cons<e, Nil>>;
}
impl React<g> for F {
    type O = Cons<F, Cons<g, Nil>>;
}
impl React<h> for F {
    type O = Cons<F, Cons<h, Nil>>;
}
impl React<i> for F {
    type O = Cons<F, Cons<i, Nil>>;
}
impl React<j> for F {
    type O = Cons<F, Cons<j, Nil>>;
}
impl React<k> for F {
    type O = Cons<F, Cons<k, Nil>>;
}
impl React<l> for F {
    type O = Cons<F, Cons<l, Nil>>;
}
impl React<m> for F {
    type O = Cons<F, Cons<m, Nil>>;
}
impl React<n> for F {
    type O = Cons<F, Cons<n, Nil>>;
}
impl React<o> for F {
    type O = Cons<F, Cons<o, Nil>>;
}
impl React<p> for F {
    type O = Cons<F, Cons<p, Nil>>;
}
impl React<q> for F {
    type O = Cons<F, Cons<q, Nil>>;
}
impl React<r> for F {
    type O = Cons<F, Cons<r, Nil>>;
}
impl React<s> for F {
    type O = Cons<F, Cons<s, Nil>>;
}
impl React<t> for F {
    type O = Cons<F, Cons<t, Nil>>;
}
impl React<u> for F {
    type O = Cons<F, Cons<u, Nil>>;
}
impl React<v> for F {
    type O = Cons<F, Cons<v, Nil>>;
}
impl React<w> for F {
    type O = Cons<F, Cons<w, Nil>>;
}
impl React<x> for F {
    type O = Cons<F, Cons<x, Nil>>;
}
impl React<y> for F {
    type O = Cons<F, Cons<y, Nil>>;
}
impl React<z> for F {
    type O = Cons<F, Cons<z, Nil>>;
}
struct G;
impl React<g> for G {
    type O = Nil;
}
impl React<A> for G {
    type O = Cons<G, Cons<A, Nil>>;
}
impl React<B> for G {
    type O = Cons<G, Cons<B, Nil>>;
}
impl React<C> for G {
    type O = Cons<G, Cons<C, Nil>>;
}
impl React<D> for G {
    type O = Cons<G, Cons<D, Nil>>;
}
impl React<E> for G {
    type O = Cons<G, Cons<E, Nil>>;
}
impl React<F> for G {
    type O = Cons<G, Cons<F, Nil>>;
}
impl React<G> for G {
    type O = Cons<G, Cons<G, Nil>>;
}
impl React<H> for G {
    type O = Cons<G, Cons<H, Nil>>;
}
impl React<I> for G {
    type O = Cons<G, Cons<I, Nil>>;
}
impl React<J> for G {
    type O = Cons<G, Cons<J, Nil>>;
}
impl React<K> for G {
    type O = Cons<G, Cons<K, Nil>>;
}
impl React<L> for G {
    type O = Cons<G, Cons<L, Nil>>;
}
impl React<M> for G {
    type O = Cons<G, Cons<M, Nil>>;
}
impl React<N> for G {
    type O = Cons<G, Cons<N, Nil>>;
}
impl React<O> for G {
    type O = Cons<G, Cons<O, Nil>>;
}
impl React<P> for G {
    type O = Cons<G, Cons<P, Nil>>;
}
impl React<Q> for G {
    type O = Cons<G, Cons<Q, Nil>>;
}
impl React<R> for G {
    type O = Cons<G, Cons<R, Nil>>;
}
impl React<S> for G {
    type O = Cons<G, Cons<S, Nil>>;
}
impl React<T> for G {
    type O = Cons<G, Cons<T, Nil>>;
}
impl React<U> for G {
    type O = Cons<G, Cons<U, Nil>>;
}
impl React<V> for G {
    type O = Cons<G, Cons<V, Nil>>;
}
impl React<W> for G {
    type O = Cons<G, Cons<W, Nil>>;
}
impl React<X> for G {
    type O = Cons<G, Cons<X, Nil>>;
}
impl React<Y> for G {
    type O = Cons<G, Cons<Y, Nil>>;
}
impl React<Z> for G {
    type O = Cons<G, Cons<Z, Nil>>;
}
impl React<a> for G {
    type O = Cons<G, Cons<a, Nil>>;
}
impl React<b> for G {
    type O = Cons<G, Cons<b, Nil>>;
}
impl React<c> for G {
    type O = Cons<G, Cons<c, Nil>>;
}
impl React<d> for G {
    type O = Cons<G, Cons<d, Nil>>;
}
impl React<e> for G {
    type O = Cons<G, Cons<e, Nil>>;
}
impl React<f> for G {
    type O = Cons<G, Cons<f, Nil>>;
}
impl React<h> for G {
    type O = Cons<G, Cons<h, Nil>>;
}
impl React<i> for G {
    type O = Cons<G, Cons<i, Nil>>;
}
impl React<j> for G {
    type O = Cons<G, Cons<j, Nil>>;
}
impl React<k> for G {
    type O = Cons<G, Cons<k, Nil>>;
}
impl React<l> for G {
    type O = Cons<G, Cons<l, Nil>>;
}
impl React<m> for G {
    type O = Cons<G, Cons<m, Nil>>;
}
impl React<n> for G {
    type O = Cons<G, Cons<n, Nil>>;
}
impl React<o> for G {
    type O = Cons<G, Cons<o, Nil>>;
}
impl React<p> for G {
    type O = Cons<G, Cons<p, Nil>>;
}
impl React<q> for G {
    type O = Cons<G, Cons<q, Nil>>;
}
impl React<r> for G {
    type O = Cons<G, Cons<r, Nil>>;
}
impl React<s> for G {
    type O = Cons<G, Cons<s, Nil>>;
}
impl React<t> for G {
    type O = Cons<G, Cons<t, Nil>>;
}
impl React<u> for G {
    type O = Cons<G, Cons<u, Nil>>;
}
impl React<v> for G {
    type O = Cons<G, Cons<v, Nil>>;
}
impl React<w> for G {
    type O = Cons<G, Cons<w, Nil>>;
}
impl React<x> for G {
    type O = Cons<G, Cons<x, Nil>>;
}
impl React<y> for G {
    type O = Cons<G, Cons<y, Nil>>;
}
impl React<z> for G {
    type O = Cons<G, Cons<z, Nil>>;
}
struct H;
impl React<h> for H {
    type O = Nil;
}
impl React<A> for H {
    type O = Cons<H, Cons<A, Nil>>;
}
impl React<B> for H {
    type O = Cons<H, Cons<B, Nil>>;
}
impl React<C> for H {
    type O = Cons<H, Cons<C, Nil>>;
}
impl React<D> for H {
    type O = Cons<H, Cons<D, Nil>>;
}
impl React<E> for H {
    type O = Cons<H, Cons<E, Nil>>;
}
impl React<F> for H {
    type O = Cons<H, Cons<F, Nil>>;
}
impl React<G> for H {
    type O = Cons<H, Cons<G, Nil>>;
}
impl React<H> for H {
    type O = Cons<H, Cons<H, Nil>>;
}
impl React<I> for H {
    type O = Cons<H, Cons<I, Nil>>;
}
impl React<J> for H {
    type O = Cons<H, Cons<J, Nil>>;
}
impl React<K> for H {
    type O = Cons<H, Cons<K, Nil>>;
}
impl React<L> for H {
    type O = Cons<H, Cons<L, Nil>>;
}
impl React<M> for H {
    type O = Cons<H, Cons<M, Nil>>;
}
impl React<N> for H {
    type O = Cons<H, Cons<N, Nil>>;
}
impl React<O> for H {
    type O = Cons<H, Cons<O, Nil>>;
}
impl React<P> for H {
    type O = Cons<H, Cons<P, Nil>>;
}
impl React<Q> for H {
    type O = Cons<H, Cons<Q, Nil>>;
}
impl React<R> for H {
    type O = Cons<H, Cons<R, Nil>>;
}
impl React<S> for H {
    type O = Cons<H, Cons<S, Nil>>;
}
impl React<T> for H {
    type O = Cons<H, Cons<T, Nil>>;
}
impl React<U> for H {
    type O = Cons<H, Cons<U, Nil>>;
}
impl React<V> for H {
    type O = Cons<H, Cons<V, Nil>>;
}
impl React<W> for H {
    type O = Cons<H, Cons<W, Nil>>;
}
impl React<X> for H {
    type O = Cons<H, Cons<X, Nil>>;
}
impl React<Y> for H {
    type O = Cons<H, Cons<Y, Nil>>;
}
impl React<Z> for H {
    type O = Cons<H, Cons<Z, Nil>>;
}
impl React<a> for H {
    type O = Cons<H, Cons<a, Nil>>;
}
impl React<b> for H {
    type O = Cons<H, Cons<b, Nil>>;
}
impl React<c> for H {
    type O = Cons<H, Cons<c, Nil>>;
}
impl React<d> for H {
    type O = Cons<H, Cons<d, Nil>>;
}
impl React<e> for H {
    type O = Cons<H, Cons<e, Nil>>;
}
impl React<f> for H {
    type O = Cons<H, Cons<f, Nil>>;
}
impl React<g> for H {
    type O = Cons<H, Cons<g, Nil>>;
}
impl React<i> for H {
    type O = Cons<H, Cons<i, Nil>>;
}
impl React<j> for H {
    type O = Cons<H, Cons<j, Nil>>;
}
impl React<k> for H {
    type O = Cons<H, Cons<k, Nil>>;
}
impl React<l> for H {
    type O = Cons<H, Cons<l, Nil>>;
}
impl React<m> for H {
    type O = Cons<H, Cons<m, Nil>>;
}
impl React<n> for H {
    type O = Cons<H, Cons<n, Nil>>;
}
impl React<o> for H {
    type O = Cons<H, Cons<o, Nil>>;
}
impl React<p> for H {
    type O = Cons<H, Cons<p, Nil>>;
}
impl React<q> for H {
    type O = Cons<H, Cons<q, Nil>>;
}
impl React<r> for H {
    type O = Cons<H, Cons<r, Nil>>;
}
impl React<s> for H {
    type O = Cons<H, Cons<s, Nil>>;
}
impl React<t> for H {
    type O = Cons<H, Cons<t, Nil>>;
}
impl React<u> for H {
    type O = Cons<H, Cons<u, Nil>>;
}
impl React<v> for H {
    type O = Cons<H, Cons<v, Nil>>;
}
impl React<w> for H {
    type O = Cons<H, Cons<w, Nil>>;
}
impl React<x> for H {
    type O = Cons<H, Cons<x, Nil>>;
}
impl React<y> for H {
    type O = Cons<H, Cons<y, Nil>>;
}
impl React<z> for H {
    type O = Cons<H, Cons<z, Nil>>;
}
struct I;
impl React<i> for I {
    type O = Nil;
}
impl React<A> for I {
    type O = Cons<I, Cons<A, Nil>>;
}
impl React<B> for I {
    type O = Cons<I, Cons<B, Nil>>;
}
impl React<C> for I {
    type O = Cons<I, Cons<C, Nil>>;
}
impl React<D> for I {
    type O = Cons<I, Cons<D, Nil>>;
}
impl React<E> for I {
    type O = Cons<I, Cons<E, Nil>>;
}
impl React<F> for I {
    type O = Cons<I, Cons<F, Nil>>;
}
impl React<G> for I {
    type O = Cons<I, Cons<G, Nil>>;
}
impl React<H> for I {
    type O = Cons<I, Cons<H, Nil>>;
}
impl React<I> for I {
    type O = Cons<I, Cons<I, Nil>>;
}
impl React<J> for I {
    type O = Cons<I, Cons<J, Nil>>;
}
impl React<K> for I {
    type O = Cons<I, Cons<K, Nil>>;
}
impl React<L> for I {
    type O = Cons<I, Cons<L, Nil>>;
}
impl React<M> for I {
    type O = Cons<I, Cons<M, Nil>>;
}
impl React<N> for I {
    type O = Cons<I, Cons<N, Nil>>;
}
impl React<O> for I {
    type O = Cons<I, Cons<O, Nil>>;
}
impl React<P> for I {
    type O = Cons<I, Cons<P, Nil>>;
}
impl React<Q> for I {
    type O = Cons<I, Cons<Q, Nil>>;
}
impl React<R> for I {
    type O = Cons<I, Cons<R, Nil>>;
}
impl React<S> for I {
    type O = Cons<I, Cons<S, Nil>>;
}
impl React<T> for I {
    type O = Cons<I, Cons<T, Nil>>;
}
impl React<U> for I {
    type O = Cons<I, Cons<U, Nil>>;
}
impl React<V> for I {
    type O = Cons<I, Cons<V, Nil>>;
}
impl React<W> for I {
    type O = Cons<I, Cons<W, Nil>>;
}
impl React<X> for I {
    type O = Cons<I, Cons<X, Nil>>;
}
impl React<Y> for I {
    type O = Cons<I, Cons<Y, Nil>>;
}
impl React<Z> for I {
    type O = Cons<I, Cons<Z, Nil>>;
}
impl React<a> for I {
    type O = Cons<I, Cons<a, Nil>>;
}
impl React<b> for I {
    type O = Cons<I, Cons<b, Nil>>;
}
impl React<c> for I {
    type O = Cons<I, Cons<c, Nil>>;
}
impl React<d> for I {
    type O = Cons<I, Cons<d, Nil>>;
}
impl React<e> for I {
    type O = Cons<I, Cons<e, Nil>>;
}
impl React<f> for I {
    type O = Cons<I, Cons<f, Nil>>;
}
impl React<g> for I {
    type O = Cons<I, Cons<g, Nil>>;
}
impl React<h> for I {
    type O = Cons<I, Cons<h, Nil>>;
}
impl React<j> for I {
    type O = Cons<I, Cons<j, Nil>>;
}
impl React<k> for I {
    type O = Cons<I, Cons<k, Nil>>;
}
impl React<l> for I {
    type O = Cons<I, Cons<l, Nil>>;
}
impl React<m> for I {
    type O = Cons<I, Cons<m, Nil>>;
}
impl React<n> for I {
    type O = Cons<I, Cons<n, Nil>>;
}
impl React<o> for I {
    type O = Cons<I, Cons<o, Nil>>;
}
impl React<p> for I {
    type O = Cons<I, Cons<p, Nil>>;
}
impl React<q> for I {
    type O = Cons<I, Cons<q, Nil>>;
}
impl React<r> for I {
    type O = Cons<I, Cons<r, Nil>>;
}
impl React<s> for I {
    type O = Cons<I, Cons<s, Nil>>;
}
impl React<t> for I {
    type O = Cons<I, Cons<t, Nil>>;
}
impl React<u> for I {
    type O = Cons<I, Cons<u, Nil>>;
}
impl React<v> for I {
    type O = Cons<I, Cons<v, Nil>>;
}
impl React<w> for I {
    type O = Cons<I, Cons<w, Nil>>;
}
impl React<x> for I {
    type O = Cons<I, Cons<x, Nil>>;
}
impl React<y> for I {
    type O = Cons<I, Cons<y, Nil>>;
}
impl React<z> for I {
    type O = Cons<I, Cons<z, Nil>>;
}
struct J;
impl React<j> for J {
    type O = Nil;
}
impl React<A> for J {
    type O = Cons<J, Cons<A, Nil>>;
}
impl React<B> for J {
    type O = Cons<J, Cons<B, Nil>>;
}
impl React<C> for J {
    type O = Cons<J, Cons<C, Nil>>;
}
impl React<D> for J {
    type O = Cons<J, Cons<D, Nil>>;
}
impl React<E> for J {
    type O = Cons<J, Cons<E, Nil>>;
}
impl React<F> for J {
    type O = Cons<J, Cons<F, Nil>>;
}
impl React<G> for J {
    type O = Cons<J, Cons<G, Nil>>;
}
impl React<H> for J {
    type O = Cons<J, Cons<H, Nil>>;
}
impl React<I> for J {
    type O = Cons<J, Cons<I, Nil>>;
}
impl React<J> for J {
    type O = Cons<J, Cons<J, Nil>>;
}
impl React<K> for J {
    type O = Cons<J, Cons<K, Nil>>;
}
impl React<L> for J {
    type O = Cons<J, Cons<L, Nil>>;
}
impl React<M> for J {
    type O = Cons<J, Cons<M, Nil>>;
}
impl React<N> for J {
    type O = Cons<J, Cons<N, Nil>>;
}
impl React<O> for J {
    type O = Cons<J, Cons<O, Nil>>;
}
impl React<P> for J {
    type O = Cons<J, Cons<P, Nil>>;
}
impl React<Q> for J {
    type O = Cons<J, Cons<Q, Nil>>;
}
impl React<R> for J {
    type O = Cons<J, Cons<R, Nil>>;
}
impl React<S> for J {
    type O = Cons<J, Cons<S, Nil>>;
}
impl React<T> for J {
    type O = Cons<J, Cons<T, Nil>>;
}
impl React<U> for J {
    type O = Cons<J, Cons<U, Nil>>;
}
impl React<V> for J {
    type O = Cons<J, Cons<V, Nil>>;
}
impl React<W> for J {
    type O = Cons<J, Cons<W, Nil>>;
}
impl React<X> for J {
    type O = Cons<J, Cons<X, Nil>>;
}
impl React<Y> for J {
    type O = Cons<J, Cons<Y, Nil>>;
}
impl React<Z> for J {
    type O = Cons<J, Cons<Z, Nil>>;
}
impl React<a> for J {
    type O = Cons<J, Cons<a, Nil>>;
}
impl React<b> for J {
    type O = Cons<J, Cons<b, Nil>>;
}
impl React<c> for J {
    type O = Cons<J, Cons<c, Nil>>;
}
impl React<d> for J {
    type O = Cons<J, Cons<d, Nil>>;
}
impl React<e> for J {
    type O = Cons<J, Cons<e, Nil>>;
}
impl React<f> for J {
    type O = Cons<J, Cons<f, Nil>>;
}
impl React<g> for J {
    type O = Cons<J, Cons<g, Nil>>;
}
impl React<h> for J {
    type O = Cons<J, Cons<h, Nil>>;
}
impl React<i> for J {
    type O = Cons<J, Cons<i, Nil>>;
}
impl React<k> for J {
    type O = Cons<J, Cons<k, Nil>>;
}
impl React<l> for J {
    type O = Cons<J, Cons<l, Nil>>;
}
impl React<m> for J {
    type O = Cons<J, Cons<m, Nil>>;
}
impl React<n> for J {
    type O = Cons<J, Cons<n, Nil>>;
}
impl React<o> for J {
    type O = Cons<J, Cons<o, Nil>>;
}
impl React<p> for J {
    type O = Cons<J, Cons<p, Nil>>;
}
impl React<q> for J {
    type O = Cons<J, Cons<q, Nil>>;
}
impl React<r> for J {
    type O = Cons<J, Cons<r, Nil>>;
}
impl React<s> for J {
    type O = Cons<J, Cons<s, Nil>>;
}
impl React<t> for J {
    type O = Cons<J, Cons<t, Nil>>;
}
impl React<u> for J {
    type O = Cons<J, Cons<u, Nil>>;
}
impl React<v> for J {
    type O = Cons<J, Cons<v, Nil>>;
}
impl React<w> for J {
    type O = Cons<J, Cons<w, Nil>>;
}
impl React<x> for J {
    type O = Cons<J, Cons<x, Nil>>;
}
impl React<y> for J {
    type O = Cons<J, Cons<y, Nil>>;
}
impl React<z> for J {
    type O = Cons<J, Cons<z, Nil>>;
}
struct K;
impl React<k> for K {
    type O = Nil;
}
impl React<A> for K {
    type O = Cons<K, Cons<A, Nil>>;
}
impl React<B> for K {
    type O = Cons<K, Cons<B, Nil>>;
}
impl React<C> for K {
    type O = Cons<K, Cons<C, Nil>>;
}
impl React<D> for K {
    type O = Cons<K, Cons<D, Nil>>;
}
impl React<E> for K {
    type O = Cons<K, Cons<E, Nil>>;
}
impl React<F> for K {
    type O = Cons<K, Cons<F, Nil>>;
}
impl React<G> for K {
    type O = Cons<K, Cons<G, Nil>>;
}
impl React<H> for K {
    type O = Cons<K, Cons<H, Nil>>;
}
impl React<I> for K {
    type O = Cons<K, Cons<I, Nil>>;
}
impl React<J> for K {
    type O = Cons<K, Cons<J, Nil>>;
}
impl React<K> for K {
    type O = Cons<K, Cons<K, Nil>>;
}
impl React<L> for K {
    type O = Cons<K, Cons<L, Nil>>;
}
impl React<M> for K {
    type O = Cons<K, Cons<M, Nil>>;
}
impl React<N> for K {
    type O = Cons<K, Cons<N, Nil>>;
}
impl React<O> for K {
    type O = Cons<K, Cons<O, Nil>>;
}
impl React<P> for K {
    type O = Cons<K, Cons<P, Nil>>;
}
impl React<Q> for K {
    type O = Cons<K, Cons<Q, Nil>>;
}
impl React<R> for K {
    type O = Cons<K, Cons<R, Nil>>;
}
impl React<S> for K {
    type O = Cons<K, Cons<S, Nil>>;
}
impl React<T> for K {
    type O = Cons<K, Cons<T, Nil>>;
}
impl React<U> for K {
    type O = Cons<K, Cons<U, Nil>>;
}
impl React<V> for K {
    type O = Cons<K, Cons<V, Nil>>;
}
impl React<W> for K {
    type O = Cons<K, Cons<W, Nil>>;
}
impl React<X> for K {
    type O = Cons<K, Cons<X, Nil>>;
}
impl React<Y> for K {
    type O = Cons<K, Cons<Y, Nil>>;
}
impl React<Z> for K {
    type O = Cons<K, Cons<Z, Nil>>;
}
impl React<a> for K {
    type O = Cons<K, Cons<a, Nil>>;
}
impl React<b> for K {
    type O = Cons<K, Cons<b, Nil>>;
}
impl React<c> for K {
    type O = Cons<K, Cons<c, Nil>>;
}
impl React<d> for K {
    type O = Cons<K, Cons<d, Nil>>;
}
impl React<e> for K {
    type O = Cons<K, Cons<e, Nil>>;
}
impl React<f> for K {
    type O = Cons<K, Cons<f, Nil>>;
}
impl React<g> for K {
    type O = Cons<K, Cons<g, Nil>>;
}
impl React<h> for K {
    type O = Cons<K, Cons<h, Nil>>;
}
impl React<i> for K {
    type O = Cons<K, Cons<i, Nil>>;
}
impl React<j> for K {
    type O = Cons<K, Cons<j, Nil>>;
}
impl React<l> for K {
    type O = Cons<K, Cons<l, Nil>>;
}
impl React<m> for K {
    type O = Cons<K, Cons<m, Nil>>;
}
impl React<n> for K {
    type O = Cons<K, Cons<n, Nil>>;
}
impl React<o> for K {
    type O = Cons<K, Cons<o, Nil>>;
}
impl React<p> for K {
    type O = Cons<K, Cons<p, Nil>>;
}
impl React<q> for K {
    type O = Cons<K, Cons<q, Nil>>;
}
impl React<r> for K {
    type O = Cons<K, Cons<r, Nil>>;
}
impl React<s> for K {
    type O = Cons<K, Cons<s, Nil>>;
}
impl React<t> for K {
    type O = Cons<K, Cons<t, Nil>>;
}
impl React<u> for K {
    type O = Cons<K, Cons<u, Nil>>;
}
impl React<v> for K {
    type O = Cons<K, Cons<v, Nil>>;
}
impl React<w> for K {
    type O = Cons<K, Cons<w, Nil>>;
}
impl React<x> for K {
    type O = Cons<K, Cons<x, Nil>>;
}
impl React<y> for K {
    type O = Cons<K, Cons<y, Nil>>;
}
impl React<z> for K {
    type O = Cons<K, Cons<z, Nil>>;
}
struct L;
impl React<l> for L {
    type O = Nil;
}
impl React<A> for L {
    type O = Cons<L, Cons<A, Nil>>;
}
impl React<B> for L {
    type O = Cons<L, Cons<B, Nil>>;
}
impl React<C> for L {
    type O = Cons<L, Cons<C, Nil>>;
}
impl React<D> for L {
    type O = Cons<L, Cons<D, Nil>>;
}
impl React<E> for L {
    type O = Cons<L, Cons<E, Nil>>;
}
impl React<F> for L {
    type O = Cons<L, Cons<F, Nil>>;
}
impl React<G> for L {
    type O = Cons<L, Cons<G, Nil>>;
}
impl React<H> for L {
    type O = Cons<L, Cons<H, Nil>>;
}
impl React<I> for L {
    type O = Cons<L, Cons<I, Nil>>;
}
impl React<J> for L {
    type O = Cons<L, Cons<J, Nil>>;
}
impl React<K> for L {
    type O = Cons<L, Cons<K, Nil>>;
}
impl React<L> for L {
    type O = Cons<L, Cons<L, Nil>>;
}
impl React<M> for L {
    type O = Cons<L, Cons<M, Nil>>;
}
impl React<N> for L {
    type O = Cons<L, Cons<N, Nil>>;
}
impl React<O> for L {
    type O = Cons<L, Cons<O, Nil>>;
}
impl React<P> for L {
    type O = Cons<L, Cons<P, Nil>>;
}
impl React<Q> for L {
    type O = Cons<L, Cons<Q, Nil>>;
}
impl React<R> for L {
    type O = Cons<L, Cons<R, Nil>>;
}
impl React<S> for L {
    type O = Cons<L, Cons<S, Nil>>;
}
impl React<T> for L {
    type O = Cons<L, Cons<T, Nil>>;
}
impl React<U> for L {
    type O = Cons<L, Cons<U, Nil>>;
}
impl React<V> for L {
    type O = Cons<L, Cons<V, Nil>>;
}
impl React<W> for L {
    type O = Cons<L, Cons<W, Nil>>;
}
impl React<X> for L {
    type O = Cons<L, Cons<X, Nil>>;
}
impl React<Y> for L {
    type O = Cons<L, Cons<Y, Nil>>;
}
impl React<Z> for L {
    type O = Cons<L, Cons<Z, Nil>>;
}
impl React<a> for L {
    type O = Cons<L, Cons<a, Nil>>;
}
impl React<b> for L {
    type O = Cons<L, Cons<b, Nil>>;
}
impl React<c> for L {
    type O = Cons<L, Cons<c, Nil>>;
}
impl React<d> for L {
    type O = Cons<L, Cons<d, Nil>>;
}
impl React<e> for L {
    type O = Cons<L, Cons<e, Nil>>;
}
impl React<f> for L {
    type O = Cons<L, Cons<f, Nil>>;
}
impl React<g> for L {
    type O = Cons<L, Cons<g, Nil>>;
}
impl React<h> for L {
    type O = Cons<L, Cons<h, Nil>>;
}
impl React<i> for L {
    type O = Cons<L, Cons<i, Nil>>;
}
impl React<j> for L {
    type O = Cons<L, Cons<j, Nil>>;
}
impl React<k> for L {
    type O = Cons<L, Cons<k, Nil>>;
}
impl React<m> for L {
    type O = Cons<L, Cons<m, Nil>>;
}
impl React<n> for L {
    type O = Cons<L, Cons<n, Nil>>;
}
impl React<o> for L {
    type O = Cons<L, Cons<o, Nil>>;
}
impl React<p> for L {
    type O = Cons<L, Cons<p, Nil>>;
}
impl React<q> for L {
    type O = Cons<L, Cons<q, Nil>>;
}
impl React<r> for L {
    type O = Cons<L, Cons<r, Nil>>;
}
impl React<s> for L {
    type O = Cons<L, Cons<s, Nil>>;
}
impl React<t> for L {
    type O = Cons<L, Cons<t, Nil>>;
}
impl React<u> for L {
    type O = Cons<L, Cons<u, Nil>>;
}
impl React<v> for L {
    type O = Cons<L, Cons<v, Nil>>;
}
impl React<w> for L {
    type O = Cons<L, Cons<w, Nil>>;
}
impl React<x> for L {
    type O = Cons<L, Cons<x, Nil>>;
}
impl React<y> for L {
    type O = Cons<L, Cons<y, Nil>>;
}
impl React<z> for L {
    type O = Cons<L, Cons<z, Nil>>;
}
struct M;
impl React<m> for M {
    type O = Nil;
}
impl React<A> for M {
    type O = Cons<M, Cons<A, Nil>>;
}
impl React<B> for M {
    type O = Cons<M, Cons<B, Nil>>;
}
impl React<C> for M {
    type O = Cons<M, Cons<C, Nil>>;
}
impl React<D> for M {
    type O = Cons<M, Cons<D, Nil>>;
}
impl React<E> for M {
    type O = Cons<M, Cons<E, Nil>>;
}
impl React<F> for M {
    type O = Cons<M, Cons<F, Nil>>;
}
impl React<G> for M {
    type O = Cons<M, Cons<G, Nil>>;
}
impl React<H> for M {
    type O = Cons<M, Cons<H, Nil>>;
}
impl React<I> for M {
    type O = Cons<M, Cons<I, Nil>>;
}
impl React<J> for M {
    type O = Cons<M, Cons<J, Nil>>;
}
impl React<K> for M {
    type O = Cons<M, Cons<K, Nil>>;
}
impl React<L> for M {
    type O = Cons<M, Cons<L, Nil>>;
}
impl React<M> for M {
    type O = Cons<M, Cons<M, Nil>>;
}
impl React<N> for M {
    type O = Cons<M, Cons<N, Nil>>;
}
impl React<O> for M {
    type O = Cons<M, Cons<O, Nil>>;
}
impl React<P> for M {
    type O = Cons<M, Cons<P, Nil>>;
}
impl React<Q> for M {
    type O = Cons<M, Cons<Q, Nil>>;
}
impl React<R> for M {
    type O = Cons<M, Cons<R, Nil>>;
}
impl React<S> for M {
    type O = Cons<M, Cons<S, Nil>>;
}
impl React<T> for M {
    type O = Cons<M, Cons<T, Nil>>;
}
impl React<U> for M {
    type O = Cons<M, Cons<U, Nil>>;
}
impl React<V> for M {
    type O = Cons<M, Cons<V, Nil>>;
}
impl React<W> for M {
    type O = Cons<M, Cons<W, Nil>>;
}
impl React<X> for M {
    type O = Cons<M, Cons<X, Nil>>;
}
impl React<Y> for M {
    type O = Cons<M, Cons<Y, Nil>>;
}
impl React<Z> for M {
    type O = Cons<M, Cons<Z, Nil>>;
}
impl React<a> for M {
    type O = Cons<M, Cons<a, Nil>>;
}
impl React<b> for M {
    type O = Cons<M, Cons<b, Nil>>;
}
impl React<c> for M {
    type O = Cons<M, Cons<c, Nil>>;
}
impl React<d> for M {
    type O = Cons<M, Cons<d, Nil>>;
}
impl React<e> for M {
    type O = Cons<M, Cons<e, Nil>>;
}
impl React<f> for M {
    type O = Cons<M, Cons<f, Nil>>;
}
impl React<g> for M {
    type O = Cons<M, Cons<g, Nil>>;
}
impl React<h> for M {
    type O = Cons<M, Cons<h, Nil>>;
}
impl React<i> for M {
    type O = Cons<M, Cons<i, Nil>>;
}
impl React<j> for M {
    type O = Cons<M, Cons<j, Nil>>;
}
impl React<k> for M {
    type O = Cons<M, Cons<k, Nil>>;
}
impl React<l> for M {
    type O = Cons<M, Cons<l, Nil>>;
}
impl React<n> for M {
    type O = Cons<M, Cons<n, Nil>>;
}
impl React<o> for M {
    type O = Cons<M, Cons<o, Nil>>;
}
impl React<p> for M {
    type O = Cons<M, Cons<p, Nil>>;
}
impl React<q> for M {
    type O = Cons<M, Cons<q, Nil>>;
}
impl React<r> for M {
    type O = Cons<M, Cons<r, Nil>>;
}
impl React<s> for M {
    type O = Cons<M, Cons<s, Nil>>;
}
impl React<t> for M {
    type O = Cons<M, Cons<t, Nil>>;
}
impl React<u> for M {
    type O = Cons<M, Cons<u, Nil>>;
}
impl React<v> for M {
    type O = Cons<M, Cons<v, Nil>>;
}
impl React<w> for M {
    type O = Cons<M, Cons<w, Nil>>;
}
impl React<x> for M {
    type O = Cons<M, Cons<x, Nil>>;
}
impl React<y> for M {
    type O = Cons<M, Cons<y, Nil>>;
}
impl React<z> for M {
    type O = Cons<M, Cons<z, Nil>>;
}
struct N;
impl React<n> for N {
    type O = Nil;
}
impl React<A> for N {
    type O = Cons<N, Cons<A, Nil>>;
}
impl React<B> for N {
    type O = Cons<N, Cons<B, Nil>>;
}
impl React<C> for N {
    type O = Cons<N, Cons<C, Nil>>;
}
impl React<D> for N {
    type O = Cons<N, Cons<D, Nil>>;
}
impl React<E> for N {
    type O = Cons<N, Cons<E, Nil>>;
}
impl React<F> for N {
    type O = Cons<N, Cons<F, Nil>>;
}
impl React<G> for N {
    type O = Cons<N, Cons<G, Nil>>;
}
impl React<H> for N {
    type O = Cons<N, Cons<H, Nil>>;
}
impl React<I> for N {
    type O = Cons<N, Cons<I, Nil>>;
}
impl React<J> for N {
    type O = Cons<N, Cons<J, Nil>>;
}
impl React<K> for N {
    type O = Cons<N, Cons<K, Nil>>;
}
impl React<L> for N {
    type O = Cons<N, Cons<L, Nil>>;
}
impl React<M> for N {
    type O = Cons<N, Cons<M, Nil>>;
}
impl React<N> for N {
    type O = Cons<N, Cons<N, Nil>>;
}
impl React<O> for N {
    type O = Cons<N, Cons<O, Nil>>;
}
impl React<P> for N {
    type O = Cons<N, Cons<P, Nil>>;
}
impl React<Q> for N {
    type O = Cons<N, Cons<Q, Nil>>;
}
impl React<R> for N {
    type O = Cons<N, Cons<R, Nil>>;
}
impl React<S> for N {
    type O = Cons<N, Cons<S, Nil>>;
}
impl React<T> for N {
    type O = Cons<N, Cons<T, Nil>>;
}
impl React<U> for N {
    type O = Cons<N, Cons<U, Nil>>;
}
impl React<V> for N {
    type O = Cons<N, Cons<V, Nil>>;
}
impl React<W> for N {
    type O = Cons<N, Cons<W, Nil>>;
}
impl React<X> for N {
    type O = Cons<N, Cons<X, Nil>>;
}
impl React<Y> for N {
    type O = Cons<N, Cons<Y, Nil>>;
}
impl React<Z> for N {
    type O = Cons<N, Cons<Z, Nil>>;
}
impl React<a> for N {
    type O = Cons<N, Cons<a, Nil>>;
}
impl React<b> for N {
    type O = Cons<N, Cons<b, Nil>>;
}
impl React<c> for N {
    type O = Cons<N, Cons<c, Nil>>;
}
impl React<d> for N {
    type O = Cons<N, Cons<d, Nil>>;
}
impl React<e> for N {
    type O = Cons<N, Cons<e, Nil>>;
}
impl React<f> for N {
    type O = Cons<N, Cons<f, Nil>>;
}
impl React<g> for N {
    type O = Cons<N, Cons<g, Nil>>;
}
impl React<h> for N {
    type O = Cons<N, Cons<h, Nil>>;
}
impl React<i> for N {
    type O = Cons<N, Cons<i, Nil>>;
}
impl React<j> for N {
    type O = Cons<N, Cons<j, Nil>>;
}
impl React<k> for N {
    type O = Cons<N, Cons<k, Nil>>;
}
impl React<l> for N {
    type O = Cons<N, Cons<l, Nil>>;
}
impl React<m> for N {
    type O = Cons<N, Cons<m, Nil>>;
}
impl React<o> for N {
    type O = Cons<N, Cons<o, Nil>>;
}
impl React<p> for N {
    type O = Cons<N, Cons<p, Nil>>;
}
impl React<q> for N {
    type O = Cons<N, Cons<q, Nil>>;
}
impl React<r> for N {
    type O = Cons<N, Cons<r, Nil>>;
}
impl React<s> for N {
    type O = Cons<N, Cons<s, Nil>>;
}
impl React<t> for N {
    type O = Cons<N, Cons<t, Nil>>;
}
impl React<u> for N {
    type O = Cons<N, Cons<u, Nil>>;
}
impl React<v> for N {
    type O = Cons<N, Cons<v, Nil>>;
}
impl React<w> for N {
    type O = Cons<N, Cons<w, Nil>>;
}
impl React<x> for N {
    type O = Cons<N, Cons<x, Nil>>;
}
impl React<y> for N {
    type O = Cons<N, Cons<y, Nil>>;
}
impl React<z> for N {
    type O = Cons<N, Cons<z, Nil>>;
}
struct O;
impl React<o> for O {
    type O = Nil;
}
impl React<A> for O {
    type O = Cons<O, Cons<A, Nil>>;
}
impl React<B> for O {
    type O = Cons<O, Cons<B, Nil>>;
}
impl React<C> for O {
    type O = Cons<O, Cons<C, Nil>>;
}
impl React<D> for O {
    type O = Cons<O, Cons<D, Nil>>;
}
impl React<E> for O {
    type O = Cons<O, Cons<E, Nil>>;
}
impl React<F> for O {
    type O = Cons<O, Cons<F, Nil>>;
}
impl React<G> for O {
    type O = Cons<O, Cons<G, Nil>>;
}
impl React<H> for O {
    type O = Cons<O, Cons<H, Nil>>;
}
impl React<I> for O {
    type O = Cons<O, Cons<I, Nil>>;
}
impl React<J> for O {
    type O = Cons<O, Cons<J, Nil>>;
}
impl React<K> for O {
    type O = Cons<O, Cons<K, Nil>>;
}
impl React<L> for O {
    type O = Cons<O, Cons<L, Nil>>;
}
impl React<M> for O {
    type O = Cons<O, Cons<M, Nil>>;
}
impl React<N> for O {
    type O = Cons<O, Cons<N, Nil>>;
}
impl React<O> for O {
    type O = Cons<O, Cons<O, Nil>>;
}
impl React<P> for O {
    type O = Cons<O, Cons<P, Nil>>;
}
impl React<Q> for O {
    type O = Cons<O, Cons<Q, Nil>>;
}
impl React<R> for O {
    type O = Cons<O, Cons<R, Nil>>;
}
impl React<S> for O {
    type O = Cons<O, Cons<S, Nil>>;
}
impl React<T> for O {
    type O = Cons<O, Cons<T, Nil>>;
}
impl React<U> for O {
    type O = Cons<O, Cons<U, Nil>>;
}
impl React<V> for O {
    type O = Cons<O, Cons<V, Nil>>;
}
impl React<W> for O {
    type O = Cons<O, Cons<W, Nil>>;
}
impl React<X> for O {
    type O = Cons<O, Cons<X, Nil>>;
}
impl React<Y> for O {
    type O = Cons<O, Cons<Y, Nil>>;
}
impl React<Z> for O {
    type O = Cons<O, Cons<Z, Nil>>;
}
impl React<a> for O {
    type O = Cons<O, Cons<a, Nil>>;
}
impl React<b> for O {
    type O = Cons<O, Cons<b, Nil>>;
}
impl React<c> for O {
    type O = Cons<O, Cons<c, Nil>>;
}
impl React<d> for O {
    type O = Cons<O, Cons<d, Nil>>;
}
impl React<e> for O {
    type O = Cons<O, Cons<e, Nil>>;
}
impl React<f> for O {
    type O = Cons<O, Cons<f, Nil>>;
}
impl React<g> for O {
    type O = Cons<O, Cons<g, Nil>>;
}
impl React<h> for O {
    type O = Cons<O, Cons<h, Nil>>;
}
impl React<i> for O {
    type O = Cons<O, Cons<i, Nil>>;
}
impl React<j> for O {
    type O = Cons<O, Cons<j, Nil>>;
}
impl React<k> for O {
    type O = Cons<O, Cons<k, Nil>>;
}
impl React<l> for O {
    type O = Cons<O, Cons<l, Nil>>;
}
impl React<m> for O {
    type O = Cons<O, Cons<m, Nil>>;
}
impl React<n> for O {
    type O = Cons<O, Cons<n, Nil>>;
}
impl React<p> for O {
    type O = Cons<O, Cons<p, Nil>>;
}
impl React<q> for O {
    type O = Cons<O, Cons<q, Nil>>;
}
impl React<r> for O {
    type O = Cons<O, Cons<r, Nil>>;
}
impl React<s> for O {
    type O = Cons<O, Cons<s, Nil>>;
}
impl React<t> for O {
    type O = Cons<O, Cons<t, Nil>>;
}
impl React<u> for O {
    type O = Cons<O, Cons<u, Nil>>;
}
impl React<v> for O {
    type O = Cons<O, Cons<v, Nil>>;
}
impl React<w> for O {
    type O = Cons<O, Cons<w, Nil>>;
}
impl React<x> for O {
    type O = Cons<O, Cons<x, Nil>>;
}
impl React<y> for O {
    type O = Cons<O, Cons<y, Nil>>;
}
impl React<z> for O {
    type O = Cons<O, Cons<z, Nil>>;
}
struct P;
impl React<p> for P {
    type O = Nil;
}
impl React<A> for P {
    type O = Cons<P, Cons<A, Nil>>;
}
impl React<B> for P {
    type O = Cons<P, Cons<B, Nil>>;
}
impl React<C> for P {
    type O = Cons<P, Cons<C, Nil>>;
}
impl React<D> for P {
    type O = Cons<P, Cons<D, Nil>>;
}
impl React<E> for P {
    type O = Cons<P, Cons<E, Nil>>;
}
impl React<F> for P {
    type O = Cons<P, Cons<F, Nil>>;
}
impl React<G> for P {
    type O = Cons<P, Cons<G, Nil>>;
}
impl React<H> for P {
    type O = Cons<P, Cons<H, Nil>>;
}
impl React<I> for P {
    type O = Cons<P, Cons<I, Nil>>;
}
impl React<J> for P {
    type O = Cons<P, Cons<J, Nil>>;
}
impl React<K> for P {
    type O = Cons<P, Cons<K, Nil>>;
}
impl React<L> for P {
    type O = Cons<P, Cons<L, Nil>>;
}
impl React<M> for P {
    type O = Cons<P, Cons<M, Nil>>;
}
impl React<N> for P {
    type O = Cons<P, Cons<N, Nil>>;
}
impl React<O> for P {
    type O = Cons<P, Cons<O, Nil>>;
}
impl React<P> for P {
    type O = Cons<P, Cons<P, Nil>>;
}
impl React<Q> for P {
    type O = Cons<P, Cons<Q, Nil>>;
}
impl React<R> for P {
    type O = Cons<P, Cons<R, Nil>>;
}
impl React<S> for P {
    type O = Cons<P, Cons<S, Nil>>;
}
impl React<T> for P {
    type O = Cons<P, Cons<T, Nil>>;
}
impl React<U> for P {
    type O = Cons<P, Cons<U, Nil>>;
}
impl React<V> for P {
    type O = Cons<P, Cons<V, Nil>>;
}
impl React<W> for P {
    type O = Cons<P, Cons<W, Nil>>;
}
impl React<X> for P {
    type O = Cons<P, Cons<X, Nil>>;
}
impl React<Y> for P {
    type O = Cons<P, Cons<Y, Nil>>;
}
impl React<Z> for P {
    type O = Cons<P, Cons<Z, Nil>>;
}
impl React<a> for P {
    type O = Cons<P, Cons<a, Nil>>;
}
impl React<b> for P {
    type O = Cons<P, Cons<b, Nil>>;
}
impl React<c> for P {
    type O = Cons<P, Cons<c, Nil>>;
}
impl React<d> for P {
    type O = Cons<P, Cons<d, Nil>>;
}
impl React<e> for P {
    type O = Cons<P, Cons<e, Nil>>;
}
impl React<f> for P {
    type O = Cons<P, Cons<f, Nil>>;
}
impl React<g> for P {
    type O = Cons<P, Cons<g, Nil>>;
}
impl React<h> for P {
    type O = Cons<P, Cons<h, Nil>>;
}
impl React<i> for P {
    type O = Cons<P, Cons<i, Nil>>;
}
impl React<j> for P {
    type O = Cons<P, Cons<j, Nil>>;
}
impl React<k> for P {
    type O = Cons<P, Cons<k, Nil>>;
}
impl React<l> for P {
    type O = Cons<P, Cons<l, Nil>>;
}
impl React<m> for P {
    type O = Cons<P, Cons<m, Nil>>;
}
impl React<n> for P {
    type O = Cons<P, Cons<n, Nil>>;
}
impl React<o> for P {
    type O = Cons<P, Cons<o, Nil>>;
}
impl React<q> for P {
    type O = Cons<P, Cons<q, Nil>>;
}
impl React<r> for P {
    type O = Cons<P, Cons<r, Nil>>;
}
impl React<s> for P {
    type O = Cons<P, Cons<s, Nil>>;
}
impl React<t> for P {
    type O = Cons<P, Cons<t, Nil>>;
}
impl React<u> for P {
    type O = Cons<P, Cons<u, Nil>>;
}
impl React<v> for P {
    type O = Cons<P, Cons<v, Nil>>;
}
impl React<w> for P {
    type O = Cons<P, Cons<w, Nil>>;
}
impl React<x> for P {
    type O = Cons<P, Cons<x, Nil>>;
}
impl React<y> for P {
    type O = Cons<P, Cons<y, Nil>>;
}
impl React<z> for P {
    type O = Cons<P, Cons<z, Nil>>;
}
struct Q;
impl React<q> for Q {
    type O = Nil;
}
impl React<A> for Q {
    type O = Cons<Q, Cons<A, Nil>>;
}
impl React<B> for Q {
    type O = Cons<Q, Cons<B, Nil>>;
}
impl React<C> for Q {
    type O = Cons<Q, Cons<C, Nil>>;
}
impl React<D> for Q {
    type O = Cons<Q, Cons<D, Nil>>;
}
impl React<E> for Q {
    type O = Cons<Q, Cons<E, Nil>>;
}
impl React<F> for Q {
    type O = Cons<Q, Cons<F, Nil>>;
}
impl React<G> for Q {
    type O = Cons<Q, Cons<G, Nil>>;
}
impl React<H> for Q {
    type O = Cons<Q, Cons<H, Nil>>;
}
impl React<I> for Q {
    type O = Cons<Q, Cons<I, Nil>>;
}
impl React<J> for Q {
    type O = Cons<Q, Cons<J, Nil>>;
}
impl React<K> for Q {
    type O = Cons<Q, Cons<K, Nil>>;
}
impl React<L> for Q {
    type O = Cons<Q, Cons<L, Nil>>;
}
impl React<M> for Q {
    type O = Cons<Q, Cons<M, Nil>>;
}
impl React<N> for Q {
    type O = Cons<Q, Cons<N, Nil>>;
}
impl React<O> for Q {
    type O = Cons<Q, Cons<O, Nil>>;
}
impl React<P> for Q {
    type O = Cons<Q, Cons<P, Nil>>;
}
impl React<Q> for Q {
    type O = Cons<Q, Cons<Q, Nil>>;
}
impl React<R> for Q {
    type O = Cons<Q, Cons<R, Nil>>;
}
impl React<S> for Q {
    type O = Cons<Q, Cons<S, Nil>>;
}
impl React<T> for Q {
    type O = Cons<Q, Cons<T, Nil>>;
}
impl React<U> for Q {
    type O = Cons<Q, Cons<U, Nil>>;
}
impl React<V> for Q {
    type O = Cons<Q, Cons<V, Nil>>;
}
impl React<W> for Q {
    type O = Cons<Q, Cons<W, Nil>>;
}
impl React<X> for Q {
    type O = Cons<Q, Cons<X, Nil>>;
}
impl React<Y> for Q {
    type O = Cons<Q, Cons<Y, Nil>>;
}
impl React<Z> for Q {
    type O = Cons<Q, Cons<Z, Nil>>;
}
impl React<a> for Q {
    type O = Cons<Q, Cons<a, Nil>>;
}
impl React<b> for Q {
    type O = Cons<Q, Cons<b, Nil>>;
}
impl React<c> for Q {
    type O = Cons<Q, Cons<c, Nil>>;
}
impl React<d> for Q {
    type O = Cons<Q, Cons<d, Nil>>;
}
impl React<e> for Q {
    type O = Cons<Q, Cons<e, Nil>>;
}
impl React<f> for Q {
    type O = Cons<Q, Cons<f, Nil>>;
}
impl React<g> for Q {
    type O = Cons<Q, Cons<g, Nil>>;
}
impl React<h> for Q {
    type O = Cons<Q, Cons<h, Nil>>;
}
impl React<i> for Q {
    type O = Cons<Q, Cons<i, Nil>>;
}
impl React<j> for Q {
    type O = Cons<Q, Cons<j, Nil>>;
}
impl React<k> for Q {
    type O = Cons<Q, Cons<k, Nil>>;
}
impl React<l> for Q {
    type O = Cons<Q, Cons<l, Nil>>;
}
impl React<m> for Q {
    type O = Cons<Q, Cons<m, Nil>>;
}
impl React<n> for Q {
    type O = Cons<Q, Cons<n, Nil>>;
}
impl React<o> for Q {
    type O = Cons<Q, Cons<o, Nil>>;
}
impl React<p> for Q {
    type O = Cons<Q, Cons<p, Nil>>;
}
impl React<r> for Q {
    type O = Cons<Q, Cons<r, Nil>>;
}
impl React<s> for Q {
    type O = Cons<Q, Cons<s, Nil>>;
}
impl React<t> for Q {
    type O = Cons<Q, Cons<t, Nil>>;
}
impl React<u> for Q {
    type O = Cons<Q, Cons<u, Nil>>;
}
impl React<v> for Q {
    type O = Cons<Q, Cons<v, Nil>>;
}
impl React<w> for Q {
    type O = Cons<Q, Cons<w, Nil>>;
}
impl React<x> for Q {
    type O = Cons<Q, Cons<x, Nil>>;
}
impl React<y> for Q {
    type O = Cons<Q, Cons<y, Nil>>;
}
impl React<z> for Q {
    type O = Cons<Q, Cons<z, Nil>>;
}
struct R;
impl React<r> for R {
    type O = Nil;
}
impl React<A> for R {
    type O = Cons<R, Cons<A, Nil>>;
}
impl React<B> for R {
    type O = Cons<R, Cons<B, Nil>>;
}
impl React<C> for R {
    type O = Cons<R, Cons<C, Nil>>;
}
impl React<D> for R {
    type O = Cons<R, Cons<D, Nil>>;
}
impl React<E> for R {
    type O = Cons<R, Cons<E, Nil>>;
}
impl React<F> for R {
    type O = Cons<R, Cons<F, Nil>>;
}
impl React<G> for R {
    type O = Cons<R, Cons<G, Nil>>;
}
impl React<H> for R {
    type O = Cons<R, Cons<H, Nil>>;
}
impl React<I> for R {
    type O = Cons<R, Cons<I, Nil>>;
}
impl React<J> for R {
    type O = Cons<R, Cons<J, Nil>>;
}
impl React<K> for R {
    type O = Cons<R, Cons<K, Nil>>;
}
impl React<L> for R {
    type O = Cons<R, Cons<L, Nil>>;
}
impl React<M> for R {
    type O = Cons<R, Cons<M, Nil>>;
}
impl React<N> for R {
    type O = Cons<R, Cons<N, Nil>>;
}
impl React<O> for R {
    type O = Cons<R, Cons<O, Nil>>;
}
impl React<P> for R {
    type O = Cons<R, Cons<P, Nil>>;
}
impl React<Q> for R {
    type O = Cons<R, Cons<Q, Nil>>;
}
impl React<R> for R {
    type O = Cons<R, Cons<R, Nil>>;
}
impl React<S> for R {
    type O = Cons<R, Cons<S, Nil>>;
}
impl React<T> for R {
    type O = Cons<R, Cons<T, Nil>>;
}
impl React<U> for R {
    type O = Cons<R, Cons<U, Nil>>;
}
impl React<V> for R {
    type O = Cons<R, Cons<V, Nil>>;
}
impl React<W> for R {
    type O = Cons<R, Cons<W, Nil>>;
}
impl React<X> for R {
    type O = Cons<R, Cons<X, Nil>>;
}
impl React<Y> for R {
    type O = Cons<R, Cons<Y, Nil>>;
}
impl React<Z> for R {
    type O = Cons<R, Cons<Z, Nil>>;
}
impl React<a> for R {
    type O = Cons<R, Cons<a, Nil>>;
}
impl React<b> for R {
    type O = Cons<R, Cons<b, Nil>>;
}
impl React<c> for R {
    type O = Cons<R, Cons<c, Nil>>;
}
impl React<d> for R {
    type O = Cons<R, Cons<d, Nil>>;
}
impl React<e> for R {
    type O = Cons<R, Cons<e, Nil>>;
}
impl React<f> for R {
    type O = Cons<R, Cons<f, Nil>>;
}
impl React<g> for R {
    type O = Cons<R, Cons<g, Nil>>;
}
impl React<h> for R {
    type O = Cons<R, Cons<h, Nil>>;
}
impl React<i> for R {
    type O = Cons<R, Cons<i, Nil>>;
}
impl React<j> for R {
    type O = Cons<R, Cons<j, Nil>>;
}
impl React<k> for R {
    type O = Cons<R, Cons<k, Nil>>;
}
impl React<l> for R {
    type O = Cons<R, Cons<l, Nil>>;
}
impl React<m> for R {
    type O = Cons<R, Cons<m, Nil>>;
}
impl React<n> for R {
    type O = Cons<R, Cons<n, Nil>>;
}
impl React<o> for R {
    type O = Cons<R, Cons<o, Nil>>;
}
impl React<p> for R {
    type O = Cons<R, Cons<p, Nil>>;
}
impl React<q> for R {
    type O = Cons<R, Cons<q, Nil>>;
}
impl React<s> for R {
    type O = Cons<R, Cons<s, Nil>>;
}
impl React<t> for R {
    type O = Cons<R, Cons<t, Nil>>;
}
impl React<u> for R {
    type O = Cons<R, Cons<u, Nil>>;
}
impl React<v> for R {
    type O = Cons<R, Cons<v, Nil>>;
}
impl React<w> for R {
    type O = Cons<R, Cons<w, Nil>>;
}
impl React<x> for R {
    type O = Cons<R, Cons<x, Nil>>;
}
impl React<y> for R {
    type O = Cons<R, Cons<y, Nil>>;
}
impl React<z> for R {
    type O = Cons<R, Cons<z, Nil>>;
}
struct S;
impl React<s> for S {
    type O = Nil;
}
impl React<A> for S {
    type O = Cons<S, Cons<A, Nil>>;
}
impl React<B> for S {
    type O = Cons<S, Cons<B, Nil>>;
}
impl React<C> for S {
    type O = Cons<S, Cons<C, Nil>>;
}
impl React<D> for S {
    type O = Cons<S, Cons<D, Nil>>;
}
impl React<E> for S {
    type O = Cons<S, Cons<E, Nil>>;
}
impl React<F> for S {
    type O = Cons<S, Cons<F, Nil>>;
}
impl React<G> for S {
    type O = Cons<S, Cons<G, Nil>>;
}
impl React<H> for S {
    type O = Cons<S, Cons<H, Nil>>;
}
impl React<I> for S {
    type O = Cons<S, Cons<I, Nil>>;
}
impl React<J> for S {
    type O = Cons<S, Cons<J, Nil>>;
}
impl React<K> for S {
    type O = Cons<S, Cons<K, Nil>>;
}
impl React<L> for S {
    type O = Cons<S, Cons<L, Nil>>;
}
impl React<M> for S {
    type O = Cons<S, Cons<M, Nil>>;
}
impl React<N> for S {
    type O = Cons<S, Cons<N, Nil>>;
}
impl React<O> for S {
    type O = Cons<S, Cons<O, Nil>>;
}
impl React<P> for S {
    type O = Cons<S, Cons<P, Nil>>;
}
impl React<Q> for S {
    type O = Cons<S, Cons<Q, Nil>>;
}
impl React<R> for S {
    type O = Cons<S, Cons<R, Nil>>;
}
impl React<S> for S {
    type O = Cons<S, Cons<S, Nil>>;
}
impl React<T> for S {
    type O = Cons<S, Cons<T, Nil>>;
}
impl React<U> for S {
    type O = Cons<S, Cons<U, Nil>>;
}
impl React<V> for S {
    type O = Cons<S, Cons<V, Nil>>;
}
impl React<W> for S {
    type O = Cons<S, Cons<W, Nil>>;
}
impl React<X> for S {
    type O = Cons<S, Cons<X, Nil>>;
}
impl React<Y> for S {
    type O = Cons<S, Cons<Y, Nil>>;
}
impl React<Z> for S {
    type O = Cons<S, Cons<Z, Nil>>;
}
impl React<a> for S {
    type O = Cons<S, Cons<a, Nil>>;
}
impl React<b> for S {
    type O = Cons<S, Cons<b, Nil>>;
}
impl React<c> for S {
    type O = Cons<S, Cons<c, Nil>>;
}
impl React<d> for S {
    type O = Cons<S, Cons<d, Nil>>;
}
impl React<e> for S {
    type O = Cons<S, Cons<e, Nil>>;
}
impl React<f> for S {
    type O = Cons<S, Cons<f, Nil>>;
}
impl React<g> for S {
    type O = Cons<S, Cons<g, Nil>>;
}
impl React<h> for S {
    type O = Cons<S, Cons<h, Nil>>;
}
impl React<i> for S {
    type O = Cons<S, Cons<i, Nil>>;
}
impl React<j> for S {
    type O = Cons<S, Cons<j, Nil>>;
}
impl React<k> for S {
    type O = Cons<S, Cons<k, Nil>>;
}
impl React<l> for S {
    type O = Cons<S, Cons<l, Nil>>;
}
impl React<m> for S {
    type O = Cons<S, Cons<m, Nil>>;
}
impl React<n> for S {
    type O = Cons<S, Cons<n, Nil>>;
}
impl React<o> for S {
    type O = Cons<S, Cons<o, Nil>>;
}
impl React<p> for S {
    type O = Cons<S, Cons<p, Nil>>;
}
impl React<q> for S {
    type O = Cons<S, Cons<q, Nil>>;
}
impl React<r> for S {
    type O = Cons<S, Cons<r, Nil>>;
}
impl React<t> for S {
    type O = Cons<S, Cons<t, Nil>>;
}
impl React<u> for S {
    type O = Cons<S, Cons<u, Nil>>;
}
impl React<v> for S {
    type O = Cons<S, Cons<v, Nil>>;
}
impl React<w> for S {
    type O = Cons<S, Cons<w, Nil>>;
}
impl React<x> for S {
    type O = Cons<S, Cons<x, Nil>>;
}
impl React<y> for S {
    type O = Cons<S, Cons<y, Nil>>;
}
impl React<z> for S {
    type O = Cons<S, Cons<z, Nil>>;
}
struct T;
impl React<t> for T {
    type O = Nil;
}
impl React<A> for T {
    type O = Cons<T, Cons<A, Nil>>;
}
impl React<B> for T {
    type O = Cons<T, Cons<B, Nil>>;
}
impl React<C> for T {
    type O = Cons<T, Cons<C, Nil>>;
}
impl React<D> for T {
    type O = Cons<T, Cons<D, Nil>>;
}
impl React<E> for T {
    type O = Cons<T, Cons<E, Nil>>;
}
impl React<F> for T {
    type O = Cons<T, Cons<F, Nil>>;
}
impl React<G> for T {
    type O = Cons<T, Cons<G, Nil>>;
}
impl React<H> for T {
    type O = Cons<T, Cons<H, Nil>>;
}
impl React<I> for T {
    type O = Cons<T, Cons<I, Nil>>;
}
impl React<J> for T {
    type O = Cons<T, Cons<J, Nil>>;
}
impl React<K> for T {
    type O = Cons<T, Cons<K, Nil>>;
}
impl React<L> for T {
    type O = Cons<T, Cons<L, Nil>>;
}
impl React<M> for T {
    type O = Cons<T, Cons<M, Nil>>;
}
impl React<N> for T {
    type O = Cons<T, Cons<N, Nil>>;
}
impl React<O> for T {
    type O = Cons<T, Cons<O, Nil>>;
}
impl React<P> for T {
    type O = Cons<T, Cons<P, Nil>>;
}
impl React<Q> for T {
    type O = Cons<T, Cons<Q, Nil>>;
}
impl React<R> for T {
    type O = Cons<T, Cons<R, Nil>>;
}
impl React<S> for T {
    type O = Cons<T, Cons<S, Nil>>;
}
impl React<T> for T {
    type O = Cons<T, Cons<T, Nil>>;
}
impl React<U> for T {
    type O = Cons<T, Cons<U, Nil>>;
}
impl React<V> for T {
    type O = Cons<T, Cons<V, Nil>>;
}
impl React<W> for T {
    type O = Cons<T, Cons<W, Nil>>;
}
impl React<X> for T {
    type O = Cons<T, Cons<X, Nil>>;
}
impl React<Y> for T {
    type O = Cons<T, Cons<Y, Nil>>;
}
impl React<Z> for T {
    type O = Cons<T, Cons<Z, Nil>>;
}
impl React<a> for T {
    type O = Cons<T, Cons<a, Nil>>;
}
impl React<b> for T {
    type O = Cons<T, Cons<b, Nil>>;
}
impl React<c> for T {
    type O = Cons<T, Cons<c, Nil>>;
}
impl React<d> for T {
    type O = Cons<T, Cons<d, Nil>>;
}
impl React<e> for T {
    type O = Cons<T, Cons<e, Nil>>;
}
impl React<f> for T {
    type O = Cons<T, Cons<f, Nil>>;
}
impl React<g> for T {
    type O = Cons<T, Cons<g, Nil>>;
}
impl React<h> for T {
    type O = Cons<T, Cons<h, Nil>>;
}
impl React<i> for T {
    type O = Cons<T, Cons<i, Nil>>;
}
impl React<j> for T {
    type O = Cons<T, Cons<j, Nil>>;
}
impl React<k> for T {
    type O = Cons<T, Cons<k, Nil>>;
}
impl React<l> for T {
    type O = Cons<T, Cons<l, Nil>>;
}
impl React<m> for T {
    type O = Cons<T, Cons<m, Nil>>;
}
impl React<n> for T {
    type O = Cons<T, Cons<n, Nil>>;
}
impl React<o> for T {
    type O = Cons<T, Cons<o, Nil>>;
}
impl React<p> for T {
    type O = Cons<T, Cons<p, Nil>>;
}
impl React<q> for T {
    type O = Cons<T, Cons<q, Nil>>;
}
impl React<r> for T {
    type O = Cons<T, Cons<r, Nil>>;
}
impl React<s> for T {
    type O = Cons<T, Cons<s, Nil>>;
}
impl React<u> for T {
    type O = Cons<T, Cons<u, Nil>>;
}
impl React<v> for T {
    type O = Cons<T, Cons<v, Nil>>;
}
impl React<w> for T {
    type O = Cons<T, Cons<w, Nil>>;
}
impl React<x> for T {
    type O = Cons<T, Cons<x, Nil>>;
}
impl React<y> for T {
    type O = Cons<T, Cons<y, Nil>>;
}
impl React<z> for T {
    type O = Cons<T, Cons<z, Nil>>;
}
struct U;
impl React<u> for U {
    type O = Nil;
}
impl React<A> for U {
    type O = Cons<U, Cons<A, Nil>>;
}
impl React<B> for U {
    type O = Cons<U, Cons<B, Nil>>;
}
impl React<C> for U {
    type O = Cons<U, Cons<C, Nil>>;
}
impl React<D> for U {
    type O = Cons<U, Cons<D, Nil>>;
}
impl React<E> for U {
    type O = Cons<U, Cons<E, Nil>>;
}
impl React<F> for U {
    type O = Cons<U, Cons<F, Nil>>;
}
impl React<G> for U {
    type O = Cons<U, Cons<G, Nil>>;
}
impl React<H> for U {
    type O = Cons<U, Cons<H, Nil>>;
}
impl React<I> for U {
    type O = Cons<U, Cons<I, Nil>>;
}
impl React<J> for U {
    type O = Cons<U, Cons<J, Nil>>;
}
impl React<K> for U {
    type O = Cons<U, Cons<K, Nil>>;
}
impl React<L> for U {
    type O = Cons<U, Cons<L, Nil>>;
}
impl React<M> for U {
    type O = Cons<U, Cons<M, Nil>>;
}
impl React<N> for U {
    type O = Cons<U, Cons<N, Nil>>;
}
impl React<O> for U {
    type O = Cons<U, Cons<O, Nil>>;
}
impl React<P> for U {
    type O = Cons<U, Cons<P, Nil>>;
}
impl React<Q> for U {
    type O = Cons<U, Cons<Q, Nil>>;
}
impl React<R> for U {
    type O = Cons<U, Cons<R, Nil>>;
}
impl React<S> for U {
    type O = Cons<U, Cons<S, Nil>>;
}
impl React<T> for U {
    type O = Cons<U, Cons<T, Nil>>;
}
impl React<U> for U {
    type O = Cons<U, Cons<U, Nil>>;
}
impl React<V> for U {
    type O = Cons<U, Cons<V, Nil>>;
}
impl React<W> for U {
    type O = Cons<U, Cons<W, Nil>>;
}
impl React<X> for U {
    type O = Cons<U, Cons<X, Nil>>;
}
impl React<Y> for U {
    type O = Cons<U, Cons<Y, Nil>>;
}
impl React<Z> for U {
    type O = Cons<U, Cons<Z, Nil>>;
}
impl React<a> for U {
    type O = Cons<U, Cons<a, Nil>>;
}
impl React<b> for U {
    type O = Cons<U, Cons<b, Nil>>;
}
impl React<c> for U {
    type O = Cons<U, Cons<c, Nil>>;
}
impl React<d> for U {
    type O = Cons<U, Cons<d, Nil>>;
}
impl React<e> for U {
    type O = Cons<U, Cons<e, Nil>>;
}
impl React<f> for U {
    type O = Cons<U, Cons<f, Nil>>;
}
impl React<g> for U {
    type O = Cons<U, Cons<g, Nil>>;
}
impl React<h> for U {
    type O = Cons<U, Cons<h, Nil>>;
}
impl React<i> for U {
    type O = Cons<U, Cons<i, Nil>>;
}
impl React<j> for U {
    type O = Cons<U, Cons<j, Nil>>;
}
impl React<k> for U {
    type O = Cons<U, Cons<k, Nil>>;
}
impl React<l> for U {
    type O = Cons<U, Cons<l, Nil>>;
}
impl React<m> for U {
    type O = Cons<U, Cons<m, Nil>>;
}
impl React<n> for U {
    type O = Cons<U, Cons<n, Nil>>;
}
impl React<o> for U {
    type O = Cons<U, Cons<o, Nil>>;
}
impl React<p> for U {
    type O = Cons<U, Cons<p, Nil>>;
}
impl React<q> for U {
    type O = Cons<U, Cons<q, Nil>>;
}
impl React<r> for U {
    type O = Cons<U, Cons<r, Nil>>;
}
impl React<s> for U {
    type O = Cons<U, Cons<s, Nil>>;
}
impl React<t> for U {
    type O = Cons<U, Cons<t, Nil>>;
}
impl React<v> for U {
    type O = Cons<U, Cons<v, Nil>>;
}
impl React<w> for U {
    type O = Cons<U, Cons<w, Nil>>;
}
impl React<x> for U {
    type O = Cons<U, Cons<x, Nil>>;
}
impl React<y> for U {
    type O = Cons<U, Cons<y, Nil>>;
}
impl React<z> for U {
    type O = Cons<U, Cons<z, Nil>>;
}
struct V;
impl React<v> for V {
    type O = Nil;
}
impl React<A> for V {
    type O = Cons<V, Cons<A, Nil>>;
}
impl React<B> for V {
    type O = Cons<V, Cons<B, Nil>>;
}
impl React<C> for V {
    type O = Cons<V, Cons<C, Nil>>;
}
impl React<D> for V {
    type O = Cons<V, Cons<D, Nil>>;
}
impl React<E> for V {
    type O = Cons<V, Cons<E, Nil>>;
}
impl React<F> for V {
    type O = Cons<V, Cons<F, Nil>>;
}
impl React<G> for V {
    type O = Cons<V, Cons<G, Nil>>;
}
impl React<H> for V {
    type O = Cons<V, Cons<H, Nil>>;
}
impl React<I> for V {
    type O = Cons<V, Cons<I, Nil>>;
}
impl React<J> for V {
    type O = Cons<V, Cons<J, Nil>>;
}
impl React<K> for V {
    type O = Cons<V, Cons<K, Nil>>;
}
impl React<L> for V {
    type O = Cons<V, Cons<L, Nil>>;
}
impl React<M> for V {
    type O = Cons<V, Cons<M, Nil>>;
}
impl React<N> for V {
    type O = Cons<V, Cons<N, Nil>>;
}
impl React<O> for V {
    type O = Cons<V, Cons<O, Nil>>;
}
impl React<P> for V {
    type O = Cons<V, Cons<P, Nil>>;
}
impl React<Q> for V {
    type O = Cons<V, Cons<Q, Nil>>;
}
impl React<R> for V {
    type O = Cons<V, Cons<R, Nil>>;
}
impl React<S> for V {
    type O = Cons<V, Cons<S, Nil>>;
}
impl React<T> for V {
    type O = Cons<V, Cons<T, Nil>>;
}
impl React<U> for V {
    type O = Cons<V, Cons<U, Nil>>;
}
impl React<V> for V {
    type O = Cons<V, Cons<V, Nil>>;
}
impl React<W> for V {
    type O = Cons<V, Cons<W, Nil>>;
}
impl React<X> for V {
    type O = Cons<V, Cons<X, Nil>>;
}
impl React<Y> for V {
    type O = Cons<V, Cons<Y, Nil>>;
}
impl React<Z> for V {
    type O = Cons<V, Cons<Z, Nil>>;
}
impl React<a> for V {
    type O = Cons<V, Cons<a, Nil>>;
}
impl React<b> for V {
    type O = Cons<V, Cons<b, Nil>>;
}
impl React<c> for V {
    type O = Cons<V, Cons<c, Nil>>;
}
impl React<d> for V {
    type O = Cons<V, Cons<d, Nil>>;
}
impl React<e> for V {
    type O = Cons<V, Cons<e, Nil>>;
}
impl React<f> for V {
    type O = Cons<V, Cons<f, Nil>>;
}
impl React<g> for V {
    type O = Cons<V, Cons<g, Nil>>;
}
impl React<h> for V {
    type O = Cons<V, Cons<h, Nil>>;
}
impl React<i> for V {
    type O = Cons<V, Cons<i, Nil>>;
}
impl React<j> for V {
    type O = Cons<V, Cons<j, Nil>>;
}
impl React<k> for V {
    type O = Cons<V, Cons<k, Nil>>;
}
impl React<l> for V {
    type O = Cons<V, Cons<l, Nil>>;
}
impl React<m> for V {
    type O = Cons<V, Cons<m, Nil>>;
}
impl React<n> for V {
    type O = Cons<V, Cons<n, Nil>>;
}
impl React<o> for V {
    type O = Cons<V, Cons<o, Nil>>;
}
impl React<p> for V {
    type O = Cons<V, Cons<p, Nil>>;
}
impl React<q> for V {
    type O = Cons<V, Cons<q, Nil>>;
}
impl React<r> for V {
    type O = Cons<V, Cons<r, Nil>>;
}
impl React<s> for V {
    type O = Cons<V, Cons<s, Nil>>;
}
impl React<t> for V {
    type O = Cons<V, Cons<t, Nil>>;
}
impl React<u> for V {
    type O = Cons<V, Cons<u, Nil>>;
}
impl React<w> for V {
    type O = Cons<V, Cons<w, Nil>>;
}
impl React<x> for V {
    type O = Cons<V, Cons<x, Nil>>;
}
impl React<y> for V {
    type O = Cons<V, Cons<y, Nil>>;
}
impl React<z> for V {
    type O = Cons<V, Cons<z, Nil>>;
}
struct W;
impl React<w> for W {
    type O = Nil;
}
impl React<A> for W {
    type O = Cons<W, Cons<A, Nil>>;
}
impl React<B> for W {
    type O = Cons<W, Cons<B, Nil>>;
}
impl React<C> for W {
    type O = Cons<W, Cons<C, Nil>>;
}
impl React<D> for W {
    type O = Cons<W, Cons<D, Nil>>;
}
impl React<E> for W {
    type O = Cons<W, Cons<E, Nil>>;
}
impl React<F> for W {
    type O = Cons<W, Cons<F, Nil>>;
}
impl React<G> for W {
    type O = Cons<W, Cons<G, Nil>>;
}
impl React<H> for W {
    type O = Cons<W, Cons<H, Nil>>;
}
impl React<I> for W {
    type O = Cons<W, Cons<I, Nil>>;
}
impl React<J> for W {
    type O = Cons<W, Cons<J, Nil>>;
}
impl React<K> for W {
    type O = Cons<W, Cons<K, Nil>>;
}
impl React<L> for W {
    type O = Cons<W, Cons<L, Nil>>;
}
impl React<M> for W {
    type O = Cons<W, Cons<M, Nil>>;
}
impl React<N> for W {
    type O = Cons<W, Cons<N, Nil>>;
}
impl React<O> for W {
    type O = Cons<W, Cons<O, Nil>>;
}
impl React<P> for W {
    type O = Cons<W, Cons<P, Nil>>;
}
impl React<Q> for W {
    type O = Cons<W, Cons<Q, Nil>>;
}
impl React<R> for W {
    type O = Cons<W, Cons<R, Nil>>;
}
impl React<S> for W {
    type O = Cons<W, Cons<S, Nil>>;
}
impl React<T> for W {
    type O = Cons<W, Cons<T, Nil>>;
}
impl React<U> for W {
    type O = Cons<W, Cons<U, Nil>>;
}
impl React<V> for W {
    type O = Cons<W, Cons<V, Nil>>;
}
impl React<W> for W {
    type O = Cons<W, Cons<W, Nil>>;
}
impl React<X> for W {
    type O = Cons<W, Cons<X, Nil>>;
}
impl React<Y> for W {
    type O = Cons<W, Cons<Y, Nil>>;
}
impl React<Z> for W {
    type O = Cons<W, Cons<Z, Nil>>;
}
impl React<a> for W {
    type O = Cons<W, Cons<a, Nil>>;
}
impl React<b> for W {
    type O = Cons<W, Cons<b, Nil>>;
}
impl React<c> for W {
    type O = Cons<W, Cons<c, Nil>>;
}
impl React<d> for W {
    type O = Cons<W, Cons<d, Nil>>;
}
impl React<e> for W {
    type O = Cons<W, Cons<e, Nil>>;
}
impl React<f> for W {
    type O = Cons<W, Cons<f, Nil>>;
}
impl React<g> for W {
    type O = Cons<W, Cons<g, Nil>>;
}
impl React<h> for W {
    type O = Cons<W, Cons<h, Nil>>;
}
impl React<i> for W {
    type O = Cons<W, Cons<i, Nil>>;
}
impl React<j> for W {
    type O = Cons<W, Cons<j, Nil>>;
}
impl React<k> for W {
    type O = Cons<W, Cons<k, Nil>>;
}
impl React<l> for W {
    type O = Cons<W, Cons<l, Nil>>;
}
impl React<m> for W {
    type O = Cons<W, Cons<m, Nil>>;
}
impl React<n> for W {
    type O = Cons<W, Cons<n, Nil>>;
}
impl React<o> for W {
    type O = Cons<W, Cons<o, Nil>>;
}
impl React<p> for W {
    type O = Cons<W, Cons<p, Nil>>;
}
impl React<q> for W {
    type O = Cons<W, Cons<q, Nil>>;
}
impl React<r> for W {
    type O = Cons<W, Cons<r, Nil>>;
}
impl React<s> for W {
    type O = Cons<W, Cons<s, Nil>>;
}
impl React<t> for W {
    type O = Cons<W, Cons<t, Nil>>;
}
impl React<u> for W {
    type O = Cons<W, Cons<u, Nil>>;
}
impl React<v> for W {
    type O = Cons<W, Cons<v, Nil>>;
}
impl React<x> for W {
    type O = Cons<W, Cons<x, Nil>>;
}
impl React<y> for W {
    type O = Cons<W, Cons<y, Nil>>;
}
impl React<z> for W {
    type O = Cons<W, Cons<z, Nil>>;
}
struct X;
impl React<x> for X {
    type O = Nil;
}
impl React<A> for X {
    type O = Cons<X, Cons<A, Nil>>;
}
impl React<B> for X {
    type O = Cons<X, Cons<B, Nil>>;
}
impl React<C> for X {
    type O = Cons<X, Cons<C, Nil>>;
}
impl React<D> for X {
    type O = Cons<X, Cons<D, Nil>>;
}
impl React<E> for X {
    type O = Cons<X, Cons<E, Nil>>;
}
impl React<F> for X {
    type O = Cons<X, Cons<F, Nil>>;
}
impl React<G> for X {
    type O = Cons<X, Cons<G, Nil>>;
}
impl React<H> for X {
    type O = Cons<X, Cons<H, Nil>>;
}
impl React<I> for X {
    type O = Cons<X, Cons<I, Nil>>;
}
impl React<J> for X {
    type O = Cons<X, Cons<J, Nil>>;
}
impl React<K> for X {
    type O = Cons<X, Cons<K, Nil>>;
}
impl React<L> for X {
    type O = Cons<X, Cons<L, Nil>>;
}
impl React<M> for X {
    type O = Cons<X, Cons<M, Nil>>;
}
impl React<N> for X {
    type O = Cons<X, Cons<N, Nil>>;
}
impl React<O> for X {
    type O = Cons<X, Cons<O, Nil>>;
}
impl React<P> for X {
    type O = Cons<X, Cons<P, Nil>>;
}
impl React<Q> for X {
    type O = Cons<X, Cons<Q, Nil>>;
}
impl React<R> for X {
    type O = Cons<X, Cons<R, Nil>>;
}
impl React<S> for X {
    type O = Cons<X, Cons<S, Nil>>;
}
impl React<T> for X {
    type O = Cons<X, Cons<T, Nil>>;
}
impl React<U> for X {
    type O = Cons<X, Cons<U, Nil>>;
}
impl React<V> for X {
    type O = Cons<X, Cons<V, Nil>>;
}
impl React<W> for X {
    type O = Cons<X, Cons<W, Nil>>;
}
impl React<X> for X {
    type O = Cons<X, Cons<X, Nil>>;
}
impl React<Y> for X {
    type O = Cons<X, Cons<Y, Nil>>;
}
impl React<Z> for X {
    type O = Cons<X, Cons<Z, Nil>>;
}
impl React<a> for X {
    type O = Cons<X, Cons<a, Nil>>;
}
impl React<b> for X {
    type O = Cons<X, Cons<b, Nil>>;
}
impl React<c> for X {
    type O = Cons<X, Cons<c, Nil>>;
}
impl React<d> for X {
    type O = Cons<X, Cons<d, Nil>>;
}
impl React<e> for X {
    type O = Cons<X, Cons<e, Nil>>;
}
impl React<f> for X {
    type O = Cons<X, Cons<f, Nil>>;
}
impl React<g> for X {
    type O = Cons<X, Cons<g, Nil>>;
}
impl React<h> for X {
    type O = Cons<X, Cons<h, Nil>>;
}
impl React<i> for X {
    type O = Cons<X, Cons<i, Nil>>;
}
impl React<j> for X {
    type O = Cons<X, Cons<j, Nil>>;
}
impl React<k> for X {
    type O = Cons<X, Cons<k, Nil>>;
}
impl React<l> for X {
    type O = Cons<X, Cons<l, Nil>>;
}
impl React<m> for X {
    type O = Cons<X, Cons<m, Nil>>;
}
impl React<n> for X {
    type O = Cons<X, Cons<n, Nil>>;
}
impl React<o> for X {
    type O = Cons<X, Cons<o, Nil>>;
}
impl React<p> for X {
    type O = Cons<X, Cons<p, Nil>>;
}
impl React<q> for X {
    type O = Cons<X, Cons<q, Nil>>;
}
impl React<r> for X {
    type O = Cons<X, Cons<r, Nil>>;
}
impl React<s> for X {
    type O = Cons<X, Cons<s, Nil>>;
}
impl React<t> for X {
    type O = Cons<X, Cons<t, Nil>>;
}
impl React<u> for X {
    type O = Cons<X, Cons<u, Nil>>;
}
impl React<v> for X {
    type O = Cons<X, Cons<v, Nil>>;
}
impl React<w> for X {
    type O = Cons<X, Cons<w, Nil>>;
}
impl React<y> for X {
    type O = Cons<X, Cons<y, Nil>>;
}
impl React<z> for X {
    type O = Cons<X, Cons<z, Nil>>;
}
struct Y;
impl React<y> for Y {
    type O = Nil;
}
impl React<A> for Y {
    type O = Cons<Y, Cons<A, Nil>>;
}
impl React<B> for Y {
    type O = Cons<Y, Cons<B, Nil>>;
}
impl React<C> for Y {
    type O = Cons<Y, Cons<C, Nil>>;
}
impl React<D> for Y {
    type O = Cons<Y, Cons<D, Nil>>;
}
impl React<E> for Y {
    type O = Cons<Y, Cons<E, Nil>>;
}
impl React<F> for Y {
    type O = Cons<Y, Cons<F, Nil>>;
}
impl React<G> for Y {
    type O = Cons<Y, Cons<G, Nil>>;
}
impl React<H> for Y {
    type O = Cons<Y, Cons<H, Nil>>;
}
impl React<I> for Y {
    type O = Cons<Y, Cons<I, Nil>>;
}
impl React<J> for Y {
    type O = Cons<Y, Cons<J, Nil>>;
}
impl React<K> for Y {
    type O = Cons<Y, Cons<K, Nil>>;
}
impl React<L> for Y {
    type O = Cons<Y, Cons<L, Nil>>;
}
impl React<M> for Y {
    type O = Cons<Y, Cons<M, Nil>>;
}
impl React<N> for Y {
    type O = Cons<Y, Cons<N, Nil>>;
}
impl React<O> for Y {
    type O = Cons<Y, Cons<O, Nil>>;
}
impl React<P> for Y {
    type O = Cons<Y, Cons<P, Nil>>;
}
impl React<Q> for Y {
    type O = Cons<Y, Cons<Q, Nil>>;
}
impl React<R> for Y {
    type O = Cons<Y, Cons<R, Nil>>;
}
impl React<S> for Y {
    type O = Cons<Y, Cons<S, Nil>>;
}
impl React<T> for Y {
    type O = Cons<Y, Cons<T, Nil>>;
}
impl React<U> for Y {
    type O = Cons<Y, Cons<U, Nil>>;
}
impl React<V> for Y {
    type O = Cons<Y, Cons<V, Nil>>;
}
impl React<W> for Y {
    type O = Cons<Y, Cons<W, Nil>>;
}
impl React<X> for Y {
    type O = Cons<Y, Cons<X, Nil>>;
}
impl React<Y> for Y {
    type O = Cons<Y, Cons<Y, Nil>>;
}
impl React<Z> for Y {
    type O = Cons<Y, Cons<Z, Nil>>;
}
impl React<a> for Y {
    type O = Cons<Y, Cons<a, Nil>>;
}
impl React<b> for Y {
    type O = Cons<Y, Cons<b, Nil>>;
}
impl React<c> for Y {
    type O = Cons<Y, Cons<c, Nil>>;
}
impl React<d> for Y {
    type O = Cons<Y, Cons<d, Nil>>;
}
impl React<e> for Y {
    type O = Cons<Y, Cons<e, Nil>>;
}
impl React<f> for Y {
    type O = Cons<Y, Cons<f, Nil>>;
}
impl React<g> for Y {
    type O = Cons<Y, Cons<g, Nil>>;
}
impl React<h> for Y {
    type O = Cons<Y, Cons<h, Nil>>;
}
impl React<i> for Y {
    type O = Cons<Y, Cons<i, Nil>>;
}
impl React<j> for Y {
    type O = Cons<Y, Cons<j, Nil>>;
}
impl React<k> for Y {
    type O = Cons<Y, Cons<k, Nil>>;
}
impl React<l> for Y {
    type O = Cons<Y, Cons<l, Nil>>;
}
impl React<m> for Y {
    type O = Cons<Y, Cons<m, Nil>>;
}
impl React<n> for Y {
    type O = Cons<Y, Cons<n, Nil>>;
}
impl React<o> for Y {
    type O = Cons<Y, Cons<o, Nil>>;
}
impl React<p> for Y {
    type O = Cons<Y, Cons<p, Nil>>;
}
impl React<q> for Y {
    type O = Cons<Y, Cons<q, Nil>>;
}
impl React<r> for Y {
    type O = Cons<Y, Cons<r, Nil>>;
}
impl React<s> for Y {
    type O = Cons<Y, Cons<s, Nil>>;
}
impl React<t> for Y {
    type O = Cons<Y, Cons<t, Nil>>;
}
impl React<u> for Y {
    type O = Cons<Y, Cons<u, Nil>>;
}
impl React<v> for Y {
    type O = Cons<Y, Cons<v, Nil>>;
}
impl React<w> for Y {
    type O = Cons<Y, Cons<w, Nil>>;
}
impl React<x> for Y {
    type O = Cons<Y, Cons<x, Nil>>;
}
impl React<z> for Y {
    type O = Cons<Y, Cons<z, Nil>>;
}
struct Z;
impl React<z> for Z {
    type O = Nil;
}
impl React<A> for Z {
    type O = Cons<Z, Cons<A, Nil>>;
}
impl React<B> for Z {
    type O = Cons<Z, Cons<B, Nil>>;
}
impl React<C> for Z {
    type O = Cons<Z, Cons<C, Nil>>;
}
impl React<D> for Z {
    type O = Cons<Z, Cons<D, Nil>>;
}
impl React<E> for Z {
    type O = Cons<Z, Cons<E, Nil>>;
}
impl React<F> for Z {
    type O = Cons<Z, Cons<F, Nil>>;
}
impl React<G> for Z {
    type O = Cons<Z, Cons<G, Nil>>;
}
impl React<H> for Z {
    type O = Cons<Z, Cons<H, Nil>>;
}
impl React<I> for Z {
    type O = Cons<Z, Cons<I, Nil>>;
}
impl React<J> for Z {
    type O = Cons<Z, Cons<J, Nil>>;
}
impl React<K> for Z {
    type O = Cons<Z, Cons<K, Nil>>;
}
impl React<L> for Z {
    type O = Cons<Z, Cons<L, Nil>>;
}
impl React<M> for Z {
    type O = Cons<Z, Cons<M, Nil>>;
}
impl React<N> for Z {
    type O = Cons<Z, Cons<N, Nil>>;
}
impl React<O> for Z {
    type O = Cons<Z, Cons<O, Nil>>;
}
impl React<P> for Z {
    type O = Cons<Z, Cons<P, Nil>>;
}
impl React<Q> for Z {
    type O = Cons<Z, Cons<Q, Nil>>;
}
impl React<R> for Z {
    type O = Cons<Z, Cons<R, Nil>>;
}
impl React<S> for Z {
    type O = Cons<Z, Cons<S, Nil>>;
}
impl React<T> for Z {
    type O = Cons<Z, Cons<T, Nil>>;
}
impl React<U> for Z {
    type O = Cons<Z, Cons<U, Nil>>;
}
impl React<V> for Z {
    type O = Cons<Z, Cons<V, Nil>>;
}
impl React<W> for Z {
    type O = Cons<Z, Cons<W, Nil>>;
}
impl React<X> for Z {
    type O = Cons<Z, Cons<X, Nil>>;
}
impl React<Y> for Z {
    type O = Cons<Z, Cons<Y, Nil>>;
}
impl React<Z> for Z {
    type O = Cons<Z, Cons<Z, Nil>>;
}
impl React<a> for Z {
    type O = Cons<Z, Cons<a, Nil>>;
}
impl React<b> for Z {
    type O = Cons<Z, Cons<b, Nil>>;
}
impl React<c> for Z {
    type O = Cons<Z, Cons<c, Nil>>;
}
impl React<d> for Z {
    type O = Cons<Z, Cons<d, Nil>>;
}
impl React<e> for Z {
    type O = Cons<Z, Cons<e, Nil>>;
}
impl React<f> for Z {
    type O = Cons<Z, Cons<f, Nil>>;
}
impl React<g> for Z {
    type O = Cons<Z, Cons<g, Nil>>;
}
impl React<h> for Z {
    type O = Cons<Z, Cons<h, Nil>>;
}
impl React<i> for Z {
    type O = Cons<Z, Cons<i, Nil>>;
}
impl React<j> for Z {
    type O = Cons<Z, Cons<j, Nil>>;
}
impl React<k> for Z {
    type O = Cons<Z, Cons<k, Nil>>;
}
impl React<l> for Z {
    type O = Cons<Z, Cons<l, Nil>>;
}
impl React<m> for Z {
    type O = Cons<Z, Cons<m, Nil>>;
}
impl React<n> for Z {
    type O = Cons<Z, Cons<n, Nil>>;
}
impl React<o> for Z {
    type O = Cons<Z, Cons<o, Nil>>;
}
impl React<p> for Z {
    type O = Cons<Z, Cons<p, Nil>>;
}
impl React<q> for Z {
    type O = Cons<Z, Cons<q, Nil>>;
}
impl React<r> for Z {
    type O = Cons<Z, Cons<r, Nil>>;
}
impl React<s> for Z {
    type O = Cons<Z, Cons<s, Nil>>;
}
impl React<t> for Z {
    type O = Cons<Z, Cons<t, Nil>>;
}
impl React<u> for Z {
    type O = Cons<Z, Cons<u, Nil>>;
}
impl React<v> for Z {
    type O = Cons<Z, Cons<v, Nil>>;
}
impl React<w> for Z {
    type O = Cons<Z, Cons<w, Nil>>;
}
impl React<x> for Z {
    type O = Cons<Z, Cons<x, Nil>>;
}
impl React<y> for Z {
    type O = Cons<Z, Cons<y, Nil>>;
}