// Path: src/main/java/com/shapesecurity/functional/F.java
// @CheckReturnValue
// @FunctionalInterface
// public interface F<A, R> {
//     @Nonnull
//     static <A extends B, B> F<A, B> id() {
//         return o -> o;
//     }
// 
//     @Nonnull
//     static <A, B> F<A, B> constant(@Nonnull final B b) {
//         return a -> b;
//     }
// 
//     @Nonnull
//     static <A, B, C> F2<A, B, C> uncurry(@Nonnull final F<A, F<B, C>> f) {
//         return (a, b) -> f.apply(a).apply(b);
//     }
// 
//     @Nonnull
//     static <A, B, C> F<B, F<A, C>> flip(@Nonnull final F<A, F<B, C>> f) {
//         return b -> a -> f.apply(a).apply(b);
//     }
// 
//     @Nonnull
//     R apply(@Nonnull A a);
// 
//     @Nonnull
//     default <C> F<C, R> compose(@Nonnull final F<C, A> f) {
//         return c -> this.apply(f.apply(c));
//     }
// 
// 
//     @Nonnull
//     default <B> F<A, B> then(@Nonnull final F<R, B> f) {
//         return c -> f.apply(this.apply(c));
//     }
// }
// 
// Path: src/main/java/com/shapesecurity/functional/F2.java
// @CheckReturnValue
// @FunctionalInterface
// public interface F2<A, B, R> {
//     @Nonnull
//     R apply(@Nonnull A a, @Nonnull B b);
// 
//     @Nonnull
//     default R applyTuple(@Nonnull Pair<A, B> args) {
//         return this.apply(args.left, args.right);
//     }
// 
//     @Nonnull
//     default F<B, R> curry(@Nonnull final A a) {
//         return b -> this.apply(a, b);
//     }
// 
//     @Nonnull
//     default F<A, F<B, R>> curry() {
//         return a -> b -> this.apply(a, b);
//     }
// 
//     @Nonnull
//     default F2<B, A, R> flip() {
//         return (b, a) -> this.apply(a, b);
//     }
// }
// 
// Path: src/main/java/com/shapesecurity/functional/Pair.java
// @CheckReturnValue
// public final class Pair<A, B> {
//     public final A left;
//     public final B right;
// 
//     @Deprecated
//     public final A a;
//     @Deprecated
//     public final B b;
// 
//     /**
//      * Constructor method to utilize type inference.
//      * @param left first component
//      * @param right second component
//      * @param <A> type of the first component
//      * @param <B> type of the second component
//      * @return the pair
//      */
//     @Nonnull
//     public static <A, B> Pair<A, B> of(A left, B right) {
//         return new Pair<>(left, right);
//     }
// 
//     @Nonnull
//     @Deprecated
//     public static <A, B> Pair<A, B> make(A left, B right) {
//         return Pair.of(left, right);
//     }
// 
//     public Pair(A left, B right) {
//         super();
//         this.left = this.a = left;
//         this.right = this.b = right;
// 
//     }
// 
//     public A left() {
//         return this.left;
//     }
// 
//     public B right() {
//         return this.right;
//     }
// 
//     @Nonnull
//     public Pair<B, A> swap() {
//         return new Pair<>(this.right, this.left);
//     }
// 
//     @Nonnull
//     public <A1, B1> Pair<A1, B1> map(@Nonnull F<A, A1> fA, @Nonnull F<B, B1> fB) {
//         return new Pair<>(fA.apply(this.left), fB.apply(this.right));
//     }
// 
//     @Nonnull
//     public <A1> Pair<A1, B> mapLeft(@Nonnull F<A, A1> f) {
//         return new Pair<>(f.apply(this.left), this.right);
//     }
// 
//     @Nonnull
//     @Deprecated
//     public <A1> Pair<A1, B> mapA(@Nonnull F<A, A1> f) {
//         return this.mapLeft(f);
//     }
// 
//     @Nonnull
//     public <B1> Pair<A, B1> mapRight(@Nonnull F<B, B1> f) {
//         return new Pair<>(this.left, f.apply(this.right));
//     }
// 
//     @Nonnull
//     @Deprecated
//     public <B1> Pair<A, B1> mapB(@Nonnull F<B, B1> f) {
//         return this.mapRight(f);
//     }
// 
//     @SuppressWarnings("unchecked")
//     @Override
//     public boolean equals(Object obj) {
//         return obj == this || obj instanceof Pair &&
//                 ((Pair<A, B>) obj).left.equals(this.left) &&
//                 ((Pair<A, B>) obj).right.equals(this.right);
//     }
// 
//     @Override
//     public int hashCode() {
//         int hash = HashCodeBuilder.put(HashCodeBuilder.init(), "Pair");
//         hash = HashCodeBuilder.put(hash, this.left);
//         return HashCodeBuilder.put(hash, this.right);
//     }
// }


import com.shapesecurity.functional.F;
import com.shapesecurity.functional.F2;
import com.shapesecurity.functional.Pair;
import javax.annotation.Nonnull;
import java.util.ArrayList;
    @Override
    public boolean every(@Nonnull F<T, Boolean> f) {
        NonEmptyImmutableList<T> list = this;
        while (true) {
            if (!f.apply(list.head)) {
                return false;
            }
            if (list.tail instanceof Nil) {
                return true;
            }
            list = ((NonEmptyImmutableList<T>) list.tail);
        }
    }

    @Override
    public boolean contains(@Nonnull T a) {
        NonEmptyImmutableList<T> list = this;
        while (true) {
            if (list.head == a) {
                return true;
            }
            if (list.tail instanceof Nil) {
                return false;
            }
            list = ((NonEmptyImmutableList<T>) list.tail);
        }
    }

    @Nonnull
    @Override
// Path: src/main/java/com/shapesecurity/functional/F.java
// @CheckReturnValue
// @FunctionalInterface
// public interface F<A, R> {
//     @Nonnull
//     static <A extends B, B> F<A, B> id() {
//         return o -> o;
//     }
// 
//     @Nonnull
//     static <A, B> F<A, B> constant(@Nonnull final B b) {
//         return a -> b;
//     }
// 
//     @Nonnull
//     static <A, B, C> F2<A, B, C> uncurry(@Nonnull final F<A, F<B, C>> f) {
//         return (a, b) -> f.apply(a).apply(b);
//     }
// 
//     @Nonnull
//     static <A, B, C> F<B, F<A, C>> flip(@Nonnull final F<A, F<B, C>> f) {
//         return b -> a -> f.apply(a).apply(b);
//     }
// 
//     @Nonnull
//     R apply(@Nonnull A a);
// 
//     @Nonnull
//     default <C> F<C, R> compose(@Nonnull final F<C, A> f) {
//         return c -> this.apply(f.apply(c));
//     }
// 
// 
//     @Nonnull
//     default <B> F<A, B> then(@Nonnull final F<R, B> f) {
//         return c -> f.apply(this.apply(c));
//     }
// }
// 
// Path: src/main/java/com/shapesecurity/functional/F2.java
// @CheckReturnValue
// @FunctionalInterface
// public interface F2<A, B, R> {
//     @Nonnull
//     R apply(@Nonnull A a, @Nonnull B b);
// 
//     @Nonnull
//     default R applyTuple(@Nonnull Pair<A, B> args) {
//         return this.apply(args.left, args.right);
//     }
// 
//     @Nonnull
//     default F<B, R> curry(@Nonnull final A a) {
//         return b -> this.apply(a, b);
//     }
// 
//     @Nonnull
//     default F<A, F<B, R>> curry() {
//         return a -> b -> this.apply(a, b);
//     }
// 
//     @Nonnull
//     default F2<B, A, R> flip() {
//         return (b, a) -> this.apply(a, b);
//     }
// }
// 
// Path: src/main/java/com/shapesecurity/functional/Pair.java
// @CheckReturnValue
// public final class Pair<A, B> {
//     public final A left;
//     public final B right;
// 
//     @Deprecated
//     public final A a;
//     @Deprecated
//     public final B b;
// 
//     /**
//      * Constructor method to utilize type inference.
//      * @param left first component
//      * @param right second component
//      * @param <A> type of the first component
//      * @param <B> type of the second component
//      * @return the pair
//      */
//     @Nonnull
//     public static <A, B> Pair<A, B> of(A left, B right) {
//         return new Pair<>(left, right);
//     }
// 
//     @Nonnull
//     @Deprecated
//     public static <A, B> Pair<A, B> make(A left, B right) {
//         return Pair.of(left, right);
//     }
// 
//     public Pair(A left, B right) {
//         super();
//         this.left = this.a = left;
//         this.right = this.b = right;
// 
//     }
// 
//     public A left() {
//         return this.left;
//     }
// 
//     public B right() {
//         return this.right;
//     }
// 
//     @Nonnull
//     public Pair<B, A> swap() {
//         return new Pair<>(this.right, this.left);
//     }
// 
//     @Nonnull
//     public <A1, B1> Pair<A1, B1> map(@Nonnull F<A, A1> fA, @Nonnull F<B, B1> fB) {
//         return new Pair<>(fA.apply(this.left), fB.apply(this.right));
//     }
// 
//     @Nonnull
//     public <A1> Pair<A1, B> mapLeft(@Nonnull F<A, A1> f) {
//         return new Pair<>(f.apply(this.left), this.right);
//     }
// 
//     @Nonnull
//     @Deprecated
//     public <A1> Pair<A1, B> mapA(@Nonnull F<A, A1> f) {
//         return this.mapLeft(f);
//     }
// 
//     @Nonnull
//     public <B1> Pair<A, B1> mapRight(@Nonnull F<B, B1> f) {
//         return new Pair<>(this.left, f.apply(this.right));
//     }
// 
//     @Nonnull
//     @Deprecated
//     public <B1> Pair<A, B1> mapB(@Nonnull F<B, B1> f) {
//         return this.mapRight(f);
//     }
// 
//     @SuppressWarnings("unchecked")
//     @Override
//     public boolean equals(Object obj) {
//         return obj == this || obj instanceof Pair &&
//                 ((Pair<A, B>) obj).left.equals(this.left) &&
//                 ((Pair<A, B>) obj).right.equals(this.right);
//     }
// 
//     @Override
//     public int hashCode() {
//         int hash = HashCodeBuilder.put(HashCodeBuilder.init(), "Pair");
//         hash = HashCodeBuilder.put(hash, this.left);
//         return HashCodeBuilder.put(hash, this.right);
//     }
// }


// Path: src/main/java/com/shapesecurity/functional/data/NonEmptyImmutableList.java
import com.shapesecurity.functional.F;
import com.shapesecurity.functional.F2;
import com.shapesecurity.functional.Pair;
import javax.annotation.Nonnull;
import java.util.ArrayList;

    @Override
    public boolean every(@Nonnull F<T, Boolean> f) {
        NonEmptyImmutableList<T> list = this;
        while (true) {
            if (!f.apply(list.head)) {
                return false;
            }
            if (list.tail instanceof Nil) {
                return true;
            }
            list = ((NonEmptyImmutableList<T>) list.tail);
        }
    }

    @Override
    public boolean contains(@Nonnull T a) {
        NonEmptyImmutableList<T> list = this;
        while (true) {
            if (list.head == a) {
                return true;
            }
            if (list.tail instanceof Nil) {
                return false;
            }
            list = ((NonEmptyImmutableList<T>) list.tail);
        }
    }

    @Nonnull
    @Override
    public Pair<ImmutableList<T>, ImmutableList<T>> span(@Nonnull F<T, Boolean> f) {