(BOOT-STRAP NQTHM)

[ 0.1 0.1 0.0 ]

GROUND-ZERO


(DEFN OPPOSITE-COLOR
      (X Y)
      (OR (AND (NUMBERP X) (NOT (NUMBERP Y)))
          (AND (NUMBERP Y) (NOT (NUMBERP X)))))

     Note that (OR (FALSEP (OPPOSITE-COLOR X Y)) (TRUEP (OPPOSITE-COLOR X Y)))
is a theorem.




[ 0.0 0.0 0.0 ]

OPPOSITE-COLOR


(DEFN ALTERNATING-COLORS
      (X)
      (IF (OR (NLISTP X) (NLISTP (CDR X)))
          T
          (AND (OPPOSITE-COLOR (CAR X) (CADR X))
               (ALTERNATING-COLORS (CDR X)))))

     Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the
definitions of OR and NLISTP inform us that the measure (COUNT X) decreases
according to the well-founded relation LESSP in each recursive call.  Hence,
ALTERNATING-COLORS is accepted under the definitional principle.  Note that:
      (OR (FALSEP (ALTERNATING-COLORS X))
          (TRUEP (ALTERNATING-COLORS X)))
is a theorem.




[ 0.0 0.0 0.0 ]

ALTERNATING-COLORS


(DEFN PAIRED-COLORS
      (X)
      (IF (OR (NLISTP X) (NLISTP (CDR X)))
          T
          (AND (OPPOSITE-COLOR (CAR X) (CADR X))
               (PAIRED-COLORS (CDDR X)))))

     Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the
definitions of OR and NLISTP inform us that the measure (COUNT X) decreases
according to the well-founded relation LESSP in each recursive call.  Hence,
PAIRED-COLORS is accepted under the definitional principle.  Observe that:
      (OR (FALSEP (PAIRED-COLORS X))
          (TRUEP (PAIRED-COLORS X)))
is a theorem.




[ 0.0 0.0 0.0 ]

PAIRED-COLORS


(DEFN PLISTP
      (X)
      (IF (NLISTP X)
          (EQUAL X NIL)
          (PLISTP (CDR X))))

     Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the
definition of NLISTP can be used to establish that the measure (COUNT X)
decreases according to the well-founded relation LESSP in each recursive call.
Hence, PLISTP is accepted under the principle of definition.  From the
definition we can conclude that (OR (FALSEP (PLISTP X)) (TRUEP (PLISTP X))) is
a theorem.




[ 0.0 0.0 0.0 ]

PLISTP


(DEFN SHUFFLEP
      (X Y Z)
      (IF (NLISTP Z)
          (AND (EQUAL X NIL)
               (EQUAL Y NIL)
               (EQUAL Z NIL))
          (IF (NLISTP X)
              (AND (EQUAL X NIL)
                   (EQUAL Y Z)
                   (PLISTP Y))
              (IF (NLISTP Y)
                  (AND (EQUAL Y NIL)
                       (EQUAL X Z)
                       (PLISTP X))
                  (OR (AND (EQUAL (CAR X) (CAR Z))
                           (SHUFFLEP (CDR X) Y (CDR Z)))
                      (AND (EQUAL (CAR Y) (CAR Z))
                           (SHUFFLEP X (CDR Y) (CDR Z))))))))

     Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the
definition of NLISTP can be used to establish that the measure (COUNT Z)
decreases according to the well-founded relation LESSP in each recursive call.
Hence, SHUFFLEP is accepted under the definitional principle.  From the
definition we can conclude that:
      (OR (FALSEP (SHUFFLEP X Y Z))
          (TRUEP (SHUFFLEP X Y Z)))
is a theorem.




[ 0.0 0.0 0.0 ]

SHUFFLEP


(DEFN EVEN-LENGTH
      (L)
      (IF (NLISTP L)
          T
          (IF (NLISTP (CDR L))
              F
              (EVEN-LENGTH (CDDR L)))))

     Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the
definition of NLISTP establish that the measure (COUNT L) decreases according
to the well-founded relation LESSP in each recursive call.  Hence, EVEN-LENGTH
is accepted under the principle of definition.  From the definition we can
conclude that (OR (FALSEP (EVEN-LENGTH L)) (TRUEP (EVEN-LENGTH L))) is a
theorem.




[ 0.0 0.0 0.0 ]

EVEN-LENGTH


(PROVE-LEMMA AL->PP
             (REWRITE)
             (IMPLIES (ALTERNATING-COLORS X)
                      (PAIRED-COLORS X)))


     Call the conjecture *1.


     Perhaps we can prove it by induction.  There are two plausible inductions.
However, they merge into one likely candidate induction.  We will induct
according to the following scheme:
      (AND (IMPLIES (OR (NLISTP X) (NLISTP (CDR X)))
                    (p X))
           (IMPLIES (AND (NOT (OR (NLISTP X) (NLISTP (CDR X))))
                         (p (CDDR X)))
                    (p X))).
Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definitions
of OR and NLISTP establish that the measure (COUNT X) decreases according to
the well-founded relation LESSP in each induction step of the scheme.  The
above induction scheme produces the following three new goals:

Case 3. (IMPLIES (AND (OR (NLISTP X) (NLISTP (CDR X)))
                      (ALTERNATING-COLORS X))
                 (PAIRED-COLORS X)).

  This simplifies, expanding the definitions of NLISTP, OR, ALTERNATING-COLORS,
  and PAIRED-COLORS, to:

        T.

Case 2. (IMPLIES (AND (NOT (OR (NLISTP X) (NLISTP (CDR X))))
                      (NOT (ALTERNATING-COLORS (CDDR X)))
                      (ALTERNATING-COLORS X))
                 (PAIRED-COLORS X)).

  This simplifies, expanding NLISTP, OR, ALTERNATING-COLORS, OPPOSITE-COLOR,
  and PAIRED-COLORS, to the following two new goals:

  Case 2.2.
          (IMPLIES (AND (LISTP X)
                        (LISTP (CDR X))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X))))
                   (PAIRED-COLORS (CDDR X))).

    But this further simplifies, expanding ALTERNATING-COLORS, to:

          T.

  Case 2.1.
          (IMPLIES (AND (LISTP X)
                        (LISTP (CDR X))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X))))
                   (PAIRED-COLORS (CDDR X))),

    which further simplifies, expanding the definition of ALTERNATING-COLORS,
    to:

          T.

Case 1. (IMPLIES (AND (NOT (OR (NLISTP X) (NLISTP (CDR X))))
                      (PAIRED-COLORS (CDDR X))
                      (ALTERNATING-COLORS X))
                 (PAIRED-COLORS X)),

  which simplifies, opening up the functions NLISTP, OR, ALTERNATING-COLORS,
  OPPOSITE-COLOR, and PAIRED-COLORS, to:

        T.


     That finishes the proof of *1.  Q.E.D.


[ 0.0 0.0 0.0 ]

AL->PP


(DEFN SILLY
      (X Y Z)
      (IF (NLISTP Z)
          T
          (LIST (SILLY (CDDR X) Y (CDDR Z))
                (SILLY (CDR X) (CDR Y) (CDDR Z))
                (SILLY X (CDDR Y) (CDDR Z)))))

     Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the
definition of NLISTP can be used to prove that the measure (COUNT Z) decreases
according to the well-founded relation LESSP in each recursive call.  Hence,
SILLY is accepted under the principle of definition.  Observe that:
      (OR (TRUEP (SILLY X Y Z))
          (LISTP (SILLY X Y Z)))
is a theorem.




[ 0.0 0.0 0.0 ]

SILLY


(PROVE-LEMMA MAIN
             (REWRITE)
             (IMPLIES (AND (SHUFFLEP X Y Z)
                           (ALTERNATING-COLORS X)
                           (ALTERNATING-COLORS Y)
                           (LISTP X)
                           (LISTP Y)
                           (OPPOSITE-COLOR (CAR X) (CAR Y)))
                      (PAIRED-COLORS Z))
             ((INDUCT (SILLY X Y Z))))

WARNING:  Note that MAIN contains the free variables Y and X which will be
chosen by instantiating the hypothesis (SHUFFLEP X Y Z).


This formula can be simplified, using the abbreviations IMPLIES, NLISTP, NOT,
OR, and AND, to the following two new formulas:

Case 2. (IMPLIES (AND (NOT (LISTP Z))
                      (SHUFFLEP X Y Z)
                      (ALTERNATING-COLORS X)
                      (ALTERNATING-COLORS Y)
                      (LISTP X)
                      (LISTP Y)
                      (OPPOSITE-COLOR (CAR X) (CAR Y)))
                 (PAIRED-COLORS Z)).

  This simplifies, expanding the definition of SHUFFLEP, to:

        T.

Case 1. (IMPLIES (AND (LISTP Z)
                      (IMPLIES (AND (SHUFFLEP X (CDDR Y) (CDDR Z))
                                    (ALTERNATING-COLORS X)
                                    (ALTERNATING-COLORS (CDDR Y))
                                    (LISTP X)
                                    (LISTP (CDDR Y))
                                    (OPPOSITE-COLOR (CAR X) (CADDR Y)))
                               (PAIRED-COLORS (CDDR Z)))
                      (IMPLIES (AND (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                                    (ALTERNATING-COLORS (CDR X))
                                    (ALTERNATING-COLORS (CDR Y))
                                    (LISTP (CDR X))
                                    (LISTP (CDR Y))
                                    (OPPOSITE-COLOR (CADR X) (CADR Y)))
                               (PAIRED-COLORS (CDDR Z)))
                      (IMPLIES (AND (SHUFFLEP (CDDR X) Y (CDDR Z))
                                    (ALTERNATING-COLORS (CDDR X))
                                    (ALTERNATING-COLORS Y)
                                    (LISTP (CDDR X))
                                    (LISTP Y)
                                    (OPPOSITE-COLOR (CADDR X) (CAR Y)))
                               (PAIRED-COLORS (CDDR Z)))
                      (SHUFFLEP X Y Z)
                      (ALTERNATING-COLORS X)
                      (ALTERNATING-COLORS Y)
                      (LISTP X)
                      (LISTP Y)
                      (OPPOSITE-COLOR (CAR X) (CAR Y)))
                 (PAIRED-COLORS Z)).

  This simplifies, applying AL->PP and CDR-NLISTP, and unfolding the
  definitions of OPPOSITE-COLOR, ALTERNATING-COLORS, AND, IMPLIES, SHUFFLEP,
  PLISTP, PAIRED-COLORS, LISTP, EQUAL, CAR, and NUMBERP, to 572 new
  conjectures:

  Case 1.572.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, and opening up the
    functions CAR, NUMBERP, and LISTP, to:

          T.

  Case 1.571.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP, and unfolding the
    functions CAR, NUMBERP, and LISTP, to:

          T.

  Case 1.570.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP, and unfolding the
    definitions of CAR, NUMBERP, and LISTP, to:

          T.

  Case 1.569.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADDR X))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP, and unfolding the
    functions CAR, NUMBERP, and LISTP, to:

          T.

  Case 1.568.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, applying CDR-NLISTP, and opening up CAR, NUMBERP,
    and LISTP, to:

          T.

  Case 1.567.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CADR X)))
                        (NUMBERP (CADDR X))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, appealing to the lemma CDR-NLISTP, and
    opening up the functions CAR, NUMBERP, and LISTP, to:

          T.

  Case 1.566.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CDR-NLISTP, and unfolding the definitions
    of CAR, NUMBERP, and LISTP, to:

          T.

  Case 1.565.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with CDR-NLISTP, and unfolding the
    functions CAR, NUMBERP, and LISTP, to:

          T.

  Case 1.564.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP, and expanding CAR,
    NUMBERP, and LISTP, to:

          T.

  Case 1.563.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying CDR-NLISTP, and opening up the
    definitions of CAR, NUMBERP, and LISTP, to:

          T.

  Case 1.562.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP, and opening up the
    definitions of CAR, NUMBERP, and LISTP, to:

          T.

  Case 1.561.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying the lemma CDR-NLISTP, and unfolding
    the definitions of CAR, NUMBERP, and LISTP, to:

          T.

  Case 1.560.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, and opening up the
    definitions of CAR, NUMBERP, and LISTP, to:

          T.

  Case 1.559.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, appealing to the lemma CDR-NLISTP, and
    expanding the functions CAR, NUMBERP, and LISTP, to:

          T.

  Case 1.558.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, and unfolding CAR,
    NUMBERP, and LISTP, to:

          T.

  Case 1.557.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADDR X))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, applying CDR-NLISTP, and opening up CAR, NUMBERP,
    and LISTP, to:

          T.

  Case 1.556.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, applying CDR-NLISTP, and opening up the
    definitions of CAR, NUMBERP, and LISTP, to:

          T.

  Case 1.555.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CADR X)))
                        (NUMBERP (CADDR X))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying CDR-NLISTP, and unfolding the
    functions CAR, NUMBERP, and LISTP, to:

          T.

  Case 1.554.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, applying the lemma CDR-NLISTP, and unfolding the
    functions CAR, NUMBERP, and LISTP, to:

          T.

  Case 1.553.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, and expanding the
    definitions of CAR, NUMBERP, and LISTP, to:

          T.

  Case 1.552.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, applying CDR-NLISTP, and expanding the
    definitions of CAR, NUMBERP, and LISTP, to:

          T.

  Case 1.551.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, applying the lemma CDR-NLISTP, and
    expanding the functions CAR, NUMBERP, and LISTP, to:

          T.

  Case 1.550.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CDR-NLISTP, and unfolding the functions
    CAR, NUMBERP, and LISTP, to:

          T.

  Case 1.549.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, applying the lemma CDR-NLISTP, and
    unfolding the definitions of CAR, NUMBERP, and LISTP, to:

          T.

  Case 1.548.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR X))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CAR-NLISTP and CDR-NLISTP, and
    opening up the definitions of NUMBERP and LISTP, to:

          T.

  Case 1.547.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR X))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with CAR-NLISTP and CDR-NLISTP, and
    unfolding the functions NUMBERP and LISTP, to:

          T.

  Case 1.546.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR X))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, rewriting with CAR-NLISTP and CDR-NLISTP,
    and opening up the definitions of NUMBERP and LISTP, to:

          T.

  Case 1.545.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, applying CAR-NLISTP and CDR-NLISTP, and
    expanding the definitions of NUMBERP and LISTP, to:

          T.

  Case 1.544.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, appealing to the lemmas CAR-NLISTP and
    CDR-NLISTP, and unfolding NUMBERP and LISTP, to:

          T.

  Case 1.543.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CAR-NLISTP and CDR-NLISTP, and unfolding
    the definitions of NUMBERP and LISTP, to:

          T.

  Case 1.542.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, appealing to the lemmas CAR-NLISTP and CDR-NLISTP,
    and opening up NUMBERP and LISTP, to:

          T.

  Case 1.541.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying the lemmas CAR-NLISTP and CDR-NLISTP, and
    opening up NUMBERP and LISTP, to:

          T.

  Case 1.540.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CAR-NLISTP and CDR-NLISTP, and
    opening up NUMBERP and LISTP, to:

          T.

  Case 1.539.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (LISTP (CDR Y))
                        (NUMBERP (CADR Y))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, applying CAR-NLISTP and CDR-NLISTP, and
    unfolding the definitions of NUMBERP and LISTP, to:

          T.

  Case 1.538.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (LISTP (CDR Y))
                        (NUMBERP (CADR Y))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with CAR-NLISTP and CDR-NLISTP, and
    opening up the definitions of NUMBERP and LISTP, to:

          T.

  Case 1.537.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (LISTP (CDR Y))
                        (NUMBERP (CADR Y))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying CAR-NLISTP and CDR-NLISTP, and opening
    up NUMBERP and LISTP, to:

          T.

  Case 1.536.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with the lemmas CAR-NLISTP and
    CDR-NLISTP, and opening up the functions NUMBERP and LISTP, to:

          T.

  Case 1.535.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with the lemmas CAR-NLISTP and
    CDR-NLISTP, and opening up the functions NUMBERP and LISTP, to:

          T.

  Case 1.534.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with the lemmas CAR-NLISTP and
    CDR-NLISTP, and opening up the definitions of NUMBERP and LISTP, to:

          T.

  Case 1.533.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying the lemmas CAR-NLISTP and CDR-NLISTP, and
    expanding the functions NUMBERP and LISTP, to:

          T.

  Case 1.532.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CAR-NLISTP and CDR-NLISTP, and
    unfolding the definitions of NUMBERP and LISTP, to:

          T.

  Case 1.531.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, applying the lemmas CAR-NLISTP and
    CDR-NLISTP, and opening up the definitions of NUMBERP and LISTP, to:

          T.

  Case 1.530.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying the lemmas CAR-NLISTP and CDR-NLISTP, and
    expanding the functions NUMBERP and LISTP, to:

          T.

  Case 1.529.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CAR-NLISTP and CDR-NLISTP, and
    unfolding the definitions of NUMBERP and LISTP, to:

          T.

  Case 1.528.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, applying CAR-NLISTP and CDR-NLISTP, and unfolding
    NUMBERP and LISTP, to:

          T.

  Case 1.527.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, rewriting with the lemmas CAR-NLISTP and
    CDR-NLISTP, and expanding the functions NUMBERP, PLISTP, SHUFFLEP, and CAR,
    to:

          T.

  Case 1.526.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CAR-NLISTP, and expanding the function
    NUMBERP, to:

          T.

  Case 1.525.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, rewriting with CAR-NLISTP and CDR-NLISTP,
    and unfolding the functions NUMBERP, PLISTP, SHUFFLEP, and CAR, to:

          T.

  Case 1.524.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, appealing to the lemma CAR-NLISTP, and
    expanding NUMBERP, to:

          T.

  Case 1.523.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, appealing to the lemmas CDR-NLISTP and CAR-NLISTP,
    and unfolding the functions CAR, NUMBERP, PLISTP, and SHUFFLEP, to:

          T.

  Case 1.522.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CAR-NLISTP, and unfolding the function
    NUMBERP, to:

          T.

  Case 1.521.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying CAR-NLISTP, CDR-NLISTP, and AL->PP,
    and unfolding the functions NUMBERP, PLISTP, SHUFFLEP, EQUAL, LISTP, and
    ALTERNATING-COLORS, to:

          T.

  Case 1.520.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (NUMBERP (CADR X)))
                        (NUMBERP (CADDR X))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with CAR-NLISTP and AL->PP, and opening
    up NUMBERP, PLISTP, SHUFFLEP, LISTP, ALTERNATING-COLORS, OPPOSITE-COLOR,
    and CAR, to:

          T.

  Case 1.519.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying CAR-NLISTP and AL->PP, and opening up
    the definitions of NUMBERP, PLISTP, SHUFFLEP, CAR, LISTP,
    ALTERNATING-COLORS, and OPPOSITE-COLOR, to:

          T.

  Case 1.518.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, applying the lemmas CAR-NLISTP, CDR-NLISTP,
    and AL->PP, and unfolding NUMBERP, PLISTP, SHUFFLEP, EQUAL, LISTP, and
    ALTERNATING-COLORS, to:

          T.

  Case 1.517.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (NUMBERP (CADR X)))
                        (NUMBERP (CADDR X))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CAR-NLISTP and AL->PP, and expanding the
    functions NUMBERP, PLISTP, SHUFFLEP, LISTP, ALTERNATING-COLORS,
    OPPOSITE-COLOR, and CAR, to:

          T.

  Case 1.516.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, rewriting with CAR-NLISTP and AL->PP, and
    opening up the definitions of NUMBERP, PLISTP, SHUFFLEP, CAR, LISTP,
    ALTERNATING-COLORS, and OPPOSITE-COLOR, to:

          T.

  Case 1.515.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying CAR-NLISTP and CDR-NLISTP, and
    unfolding NUMBERP, PLISTP, SHUFFLEP, and ALTERNATING-COLORS, to:

          T.

  Case 1.514.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying the lemma CAR-NLISTP, and unfolding
    the definitions of NUMBERP and ALTERNATING-COLORS, to:

          T.

  Case 1.513.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CAR-NLISTP and CDR-NLISTP, and opening up
    the definitions of NUMBERP, PLISTP, SHUFFLEP, and ALTERNATING-COLORS, to:

          T.

  Case 1.512.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, applying CAR-NLISTP, and expanding the functions
    NUMBERP and ALTERNATING-COLORS, to:

          T.

  Case 1.511.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with CDR-NLISTP, and expanding the
    definitions of CAR, NUMBERP, PLISTP, SHUFFLEP, and ALTERNATING-COLORS, to:

          T.

  Case 1.510.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with CAR-NLISTP, and unfolding the
    definitions of NUMBERP and ALTERNATING-COLORS, to:

          T.

  Case 1.509.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, applying CAR-NLISTP, CDR-NLISTP, and AL->PP,
    and expanding the functions NUMBERP, PLISTP, SHUFFLEP, LISTP, and
    ALTERNATING-COLORS, to:

          T.

  Case 1.508.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CAR-NLISTP and AL->PP, and
    expanding NUMBERP, PLISTP, SHUFFLEP, LISTP, ALTERNATING-COLORS,
    OPPOSITE-COLOR, and CAR, to:

          T.

  Case 1.507.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, appealing to the lemmas CAR-NLISTP, CDR-NLISTP, and
    AL->PP, and opening up NUMBERP, PLISTP, SHUFFLEP, LISTP, and
    ALTERNATING-COLORS, to:

          T.

  Case 1.506.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying the lemmas CAR-NLISTP and AL->PP, and
    expanding the definitions of NUMBERP, PLISTP, SHUFFLEP, LISTP,
    ALTERNATING-COLORS, OPPOSITE-COLOR, and CAR, to:

          T.

  Case 1.505.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (LISTP (CDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CAR-NLISTP and AL->PP, and expanding
    NUMBERP, PLISTP, SHUFFLEP, LISTP, and ALTERNATING-COLORS, to:

          T.

  Case 1.504.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (LISTP (CDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, applying CAR-NLISTP and AL->PP, and
    expanding the definitions of NUMBERP, PLISTP, SHUFFLEP, LISTP, and
    ALTERNATING-COLORS, to:

          T.

  Case 1.503.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (LISTP (CDR Y)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying CDR-NLISTP and CAR-NLISTP, and
    expanding CAR and NUMBERP, to:

          T.

  Case 1.502.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (LISTP (CDR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP, and expanding the
    definitions of CAR, NUMBERP, and ALTERNATING-COLORS, to:

          T.

  Case 1.501.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, applying CDR-NLISTP and CAR-NLISTP, and expanding
    CAR and NUMBERP, to:

          T.

  Case 1.500.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with CDR-NLISTP and CAR-NLISTP, and
    unfolding the definitions of CAR and NUMBERP, to:

          T.

  Case 1.499.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with CDR-NLISTP and CAR-NLISTP, and
    expanding the definitions of CAR and NUMBERP, to:

          T.

  Case 1.498.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, rewriting with the lemmas CDR-NLISTP and
    CAR-NLISTP, and unfolding CAR and NUMBERP, to:

          T.

  Case 1.497.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CADDR X))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP and CAR-NLISTP, and
    opening up the functions CAR and NUMBERP, to:

          T.

  Case 1.496.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP and CAR-NLISTP, and
    expanding the functions CAR and NUMBERP, to:

          T.

  Case 1.495.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CADDR X))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying the lemmas CDR-NLISTP and CAR-NLISTP,
    and expanding the functions CAR and NUMBERP, to:

          T.

  Case 1.494.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, appealing to the lemmas CDR-NLISTP and CAR-NLISTP,
    and unfolding CAR and NUMBERP, to:

          T.

  Case 1.493.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with the lemmas CDR-NLISTP and
    CAR-NLISTP, and expanding the functions CAR and NUMBERP, to:

          T.

  Case 1.492.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying the lemmas CDR-NLISTP and CAR-NLISTP, and
    opening up the definitions of CAR and NUMBERP, to:

          T.

  Case 1.491.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP and CAR-NLISTP, and
    opening up the functions CAR and NUMBERP, to:

          T.

  Case 1.490.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP and CAR-NLISTP, and
    opening up the functions CAR and NUMBERP, to:

          T.

  Case 1.489.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying CAR-NLISTP and CDR-NLISTP, and opening
    up the functions NUMBERP and CAR, to:

          T.

  Case 1.488.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying CAR-NLISTP and CDR-NLISTP, and
    expanding the functions NUMBERP and CAR, to:

          T.

  Case 1.487.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, applying CAR-NLISTP and CDR-NLISTP, and unfolding
    the definitions of NUMBERP and CAR, to:

          T.

  Case 1.486.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, rewriting with CAR-NLISTP, CDR-NLISTP, and
    AL->PP, and expanding the definitions of NUMBERP, EQUAL, LISTP, SHUFFLEP,
    PLISTP, and ALTERNATING-COLORS, to:

          T.

  Case 1.485.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, rewriting with CAR-NLISTP, CDR-NLISTP, and
    AL->PP, and expanding the functions NUMBERP, EQUAL, LISTP, SHUFFLEP,
    PLISTP, and ALTERNATING-COLORS, to:

          T.

  Case 1.484.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CAR-NLISTP, CDR-NLISTP, and
    AL->PP, and opening up the definitions of NUMBERP, EQUAL, LISTP, SHUFFLEP,
    PLISTP, and ALTERNATING-COLORS, to:

          T.

  Case 1.483.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, appealing to the lemmas CAR-NLISTP and
    CDR-NLISTP, and opening up the definitions of NUMBERP and
    ALTERNATING-COLORS, to:

          T.

  Case 1.482.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CAR-NLISTP and CDR-NLISTP, and unfolding
    NUMBERP and ALTERNATING-COLORS, to:

          T.

  Case 1.481.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, applying the lemmas CAR-NLISTP and CDR-NLISTP, and
    opening up the functions NUMBERP and ALTERNATING-COLORS, to:

          T.

  Case 1.480.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, appealing to the lemmas CAR-NLISTP, CDR-NLISTP,
    and AL->PP, and expanding NUMBERP, LISTP, PLISTP, SHUFFLEP, and
    ALTERNATING-COLORS, to:

          T.

  Case 1.479.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CAR-NLISTP, CDR-NLISTP, and AL->PP,
    and opening up the definitions of NUMBERP, LISTP, PLISTP, SHUFFLEP, and
    ALTERNATING-COLORS, to:

          T.

  Case 1.478.
          (IMPLIES (AND (LISTP Z)
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR Y))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, applying CAR-NLISTP, CDR-NLISTP, and AL->PP, and
    unfolding the functions NUMBERP, LISTP, PLISTP, SHUFFLEP, and
    ALTERNATING-COLORS, to:

          T.

  Case 1.477.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP, and expanding the
    definitions of CAR and NUMBERP, to:

          T.

  Case 1.476.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP, and expanding CAR
    and NUMBERP, to:

          T.

  Case 1.475.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, applying CDR-NLISTP, and opening up the definitions
    of CAR and NUMBERP, to:

          T.

  Case 1.474.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADDR X)))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying CDR-NLISTP, and unfolding CAR and
    NUMBERP, to:

          T.

  Case 1.473.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with the lemma CDR-NLISTP, and
    expanding CAR and NUMBERP, to:

          T.

  Case 1.472.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CADR X))
                        (NOT (NUMBERP (CADDR X)))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with the lemma CDR-NLISTP, and unfolding
    the functions CAR and NUMBERP, to:

          T.

  Case 1.471.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CDR-NLISTP, and opening up CAR and
    NUMBERP, to:

          T.

  Case 1.470.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP, and opening up the
    functions CAR and NUMBERP, to:

          T.

  Case 1.469.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, rewriting with CDR-NLISTP, and expanding
    CAR and NUMBERP, to:

          T.

  Case 1.468.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with CDR-NLISTP, and unfolding the
    functions CAR and NUMBERP, to:

          T.

  Case 1.467.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying CDR-NLISTP, and unfolding the
    functions CAR and NUMBERP, to:

          T.

  Case 1.466.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying CDR-NLISTP, and opening up CAR and
    NUMBERP, to:

          T.

  Case 1.465.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying CDR-NLISTP, and unfolding CAR and
    NUMBERP, to:

          T.

  Case 1.464.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, applying CDR-NLISTP, and unfolding CAR and
    NUMBERP, to:

          T.

  Case 1.463.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, applying CDR-NLISTP, and opening up the definitions
    of CAR and NUMBERP, to:

          T.

  Case 1.462.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADDR X)))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP, and opening up the
    definitions of CAR and NUMBERP, to:

          T.

  Case 1.461.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, applying CDR-NLISTP, and unfolding the
    definitions of CAR and NUMBERP, to:

          T.

  Case 1.460.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CADR X))
                        (NOT (NUMBERP (CADDR X)))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying the lemma CDR-NLISTP, and opening up
    CAR and NUMBERP, to:

          T.

  Case 1.459.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CDR-NLISTP, and expanding CAR and NUMBERP,
    to:

          T.

  Case 1.458.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with CDR-NLISTP, and expanding the
    functions CAR and NUMBERP, to:

          T.

  Case 1.457.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with the lemma CDR-NLISTP, and
    unfolding the functions CAR and NUMBERP, to:

          T.

  Case 1.456.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, and opening up the
    definitions of CAR and NUMBERP, to:

          T.

  Case 1.455.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, applying CDR-NLISTP, and expanding the definitions
    of CAR and NUMBERP, to:

          T.

  Case 1.454.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, applying CDR-NLISTP, and opening up the functions
    CAR and NUMBERP, to:

          T.

  Case 1.453.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR X))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying the lemma CAR-NLISTP, and expanding
    the definition of NUMBERP, to:

          T.

  Case 1.452.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR X))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CAR-NLISTP, and opening up the
    function NUMBERP, to:

          T.

  Case 1.451.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR X))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with CAR-NLISTP, and opening up NUMBERP,
    to:

          T.

  Case 1.450.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (LISTP (CDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, rewriting with CAR-NLISTP, and opening up
    NUMBERP, to:

          T.

  Case 1.449.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (LISTP (CDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with the lemma CAR-NLISTP, and unfolding
    NUMBERP, to:

          T.

  Case 1.448.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (LISTP (CDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CAR-NLISTP, and unfolding NUMBERP, to:

          T.

  Case 1.447.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CAR-NLISTP, and unfolding the
    definition of NUMBERP, to:

          T.

  Case 1.446.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying CAR-NLISTP, and expanding NUMBERP, to:

          T.

  Case 1.445.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, appealing to the lemma CAR-NLISTP, and unfolding
    the definition of NUMBERP, to:

          T.

  Case 1.444.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CAR-NLISTP, and expanding the
    definition of NUMBERP, to:

          T.

  Case 1.443.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying the lemma CAR-NLISTP, and unfolding
    NUMBERP, to:

          T.

  Case 1.442.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CAR-NLISTP, and opening up NUMBERP, to:

          T.

  Case 1.441.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying the lemma CAR-NLISTP, and opening up
    the definition of NUMBERP, to:

          T.

  Case 1.440.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CAR-NLISTP, and expanding the definition
    of NUMBERP, to:

          T.

  Case 1.439.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, applying CAR-NLISTP, and unfolding NUMBERP,
    to:

          T.

  Case 1.438.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying CAR-NLISTP, and opening up NUMBERP, to:

          T.

  Case 1.437.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, applying the lemma CAR-NLISTP, and opening up the
    function NUMBERP, to:

          T.

  Case 1.436.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CAR-NLISTP, and unfolding the
    function NUMBERP, to:

          T.

  Case 1.435.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, rewriting with the lemma CAR-NLISTP, and
    expanding the function NUMBERP, to:

          T.

  Case 1.434.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CAR-NLISTP, and expanding NUMBERP,
    to:

          T.

  Case 1.433.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying CAR-NLISTP, and opening up NUMBERP, to:

          T.

  Case 1.432.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with CAR-NLISTP, and expanding the
    function NUMBERP, to:

          T.

  Case 1.431.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, applying CAR-NLISTP, and unfolding the
    definition of NUMBERP, to:

          T.

  Case 1.430.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CAR-NLISTP, and unfolding the
    function NUMBERP, to:

          T.

  Case 1.429.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with CAR-NLISTP, and unfolding NUMBERP,
    to:

          T.

  Case 1.428.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying the lemma CDR-NLISTP, and opening up
    the functions CAR and NUMBERP, to:

          T.

  Case 1.427.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying the lemma CAR-NLISTP, and opening up
    NUMBERP, to:

          T.

  Case 1.426.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with the lemma CAR-NLISTP, and expanding
    NUMBERP, to:

          T.

  Case 1.425.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NUMBERP (CADR X))
                        (NOT (NUMBERP (CADDR X)))
                        (ALTERNATING-COLORS (CDDR X))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, appealing to the lemma CAR-NLISTP, and expanding
    the function NUMBERP, to:

          T.

  Case 1.424.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with the lemma CAR-NLISTP, and opening
    up the definition of NUMBERP, to:

          T.

  Case 1.423.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CAR-NLISTP, and opening up the
    definition of NUMBERP, to:

          T.

  Case 1.422.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NUMBERP (CADR X))
                        (NOT (NUMBERP (CADDR X)))
                        (ALTERNATING-COLORS (CDDR X))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, appealing to the lemma CAR-NLISTP, and unfolding
    the function NUMBERP, to:

          T.

  Case 1.421.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CAR-NLISTP, and opening up NUMBERP, to:

          T.

  Case 1.420.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CAR-NLISTP, and expanding the
    function NUMBERP, to:

          T.

  Case 1.419.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying CAR-NLISTP, and expanding the function
    NUMBERP, to:

          T.

  Case 1.418.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CAR-NLISTP, and expanding the
    function NUMBERP, to:

          T.

  Case 1.417.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with CAR-NLISTP, and expanding the
    definition of NUMBERP, to:

          T.

  Case 1.416.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, appealing to the lemma CDR-NLISTP, and opening
    up the definitions of CAR and NUMBERP, to:

          T.

  Case 1.415.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with the lemma CAR-NLISTP, and expanding
    NUMBERP, to:

          T.

  Case 1.414.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, appealing to the lemma CAR-NLISTP, and expanding
    NUMBERP, to:

          T.

  Case 1.413.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NUMBERP (CADR X))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CAR-NLISTP, and opening up NUMBERP, to:

          T.

  Case 1.412.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with CAR-NLISTP, and expanding the
    definition of NUMBERP, to:

          T.

  Case 1.411.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NUMBERP (CADR X))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, rewriting with CAR-NLISTP, and expanding
    the definition of NUMBERP, to:

          T.

  Case 1.410.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (LISTP (CDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, rewriting with CAR-NLISTP, and expanding
    NUMBERP, to:

          T.

  Case 1.409.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (LISTP (CDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with the lemma CAR-NLISTP, and
    unfolding the definition of NUMBERP, to:

          T.

  Case 1.408.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (LISTP (CDR Y)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, appealing to the lemma CDR-NLISTP, and unfolding
    the functions CAR and NUMBERP, to:

          T.

  Case 1.407.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (LISTP (CDR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, and expanding CAR and
    NUMBERP, to:

          T.

  Case 1.406.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, rewriting with the lemma CAR-NLISTP, and
    expanding the definition of NUMBERP, to:

          T.

  Case 1.405.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CAR-NLISTP, and opening up the
    definition of NUMBERP, to:

          T.

  Case 1.404.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, rewriting with CAR-NLISTP, and unfolding
    the function NUMBERP, to:

          T.

  Case 1.403.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, applying CAR-NLISTP, and opening up NUMBERP,
    to:

          T.

  Case 1.402.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, applying the lemma CAR-NLISTP, and opening
    up NUMBERP, to:

          T.

  Case 1.401.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CAR-NLISTP, and expanding the definition
    of NUMBERP, to:

          T.

  Case 1.400.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, appealing to the lemma CAR-NLISTP, and
    expanding the definition of NUMBERP, to:

          T.

  Case 1.399.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CAR-NLISTP, and expanding the definition
    of NUMBERP, to:

          T.

  Case 1.398.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, applying CAR-NLISTP, and unfolding NUMBERP,
    to:

          T.

  Case 1.397.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, applying the lemma CAR-NLISTP, and opening
    up the function NUMBERP, to:

          T.

  Case 1.396.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying the lemma CAR-NLISTP, and unfolding the
    definition of NUMBERP, to:

          T.

  Case 1.395.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CAR-NLISTP, and unfolding NUMBERP,
    to:

          T.

  Case 1.394.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying CDR-NLISTP, and opening up the
    definitions of CAR and NUMBERP, to:

          T.

  Case 1.393.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP, and expanding the
    functions CAR and NUMBERP, to:

          T.

  Case 1.392.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, rewriting with CDR-NLISTP, and opening up
    the definitions of CAR and NUMBERP, to:

          T.

  Case 1.391.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP, and unfolding the
    definitions of CAR and NUMBERP, to:

          T.

  Case 1.390.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CADDR X)))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with the lemma CDR-NLISTP, and opening up
    the definitions of CAR and NUMBERP, to:

          T.

  Case 1.389.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, and opening up the
    functions CAR and NUMBERP, to:

          T.

  Case 1.388.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CADDR X)))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with CDR-NLISTP, and expanding CAR and
    NUMBERP, to:

          T.

  Case 1.387.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP, and expanding CAR
    and NUMBERP, to:

          T.

  Case 1.386.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with the lemma CDR-NLISTP, and opening up
    the functions CAR and NUMBERP, to:

          T.

  Case 1.385.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, and unfolding the
    functions CAR and NUMBERP, to:

          T.

  Case 1.384.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, applying CDR-NLISTP, and unfolding the
    definitions of CAR and NUMBERP, to:

          T.

  Case 1.383.
          (IMPLIES (AND (LISTP Z)
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, applying the lemma CDR-NLISTP, and expanding CAR
    and NUMBERP, to:

          T.

  Case 1.382.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, and opening up the
    functions EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.381.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with CDR-NLISTP, and opening up the
    functions EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.380.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with CDR-NLISTP, and expanding the
    functions EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.379.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, applying CDR-NLISTP, and unfolding EQUAL, LISTP,
    and SHUFFLEP, to:

          T.

  Case 1.378.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with the lemma CDR-NLISTP, and
    opening up the functions EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.377.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, and opening up the
    definitions of EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.376.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADDR X))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying CDR-NLISTP, and expanding the
    functions EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.375.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADDR X)))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP, and opening up EQUAL,
    LISTP, and SHUFFLEP, to:

          T.

  Case 1.374.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, rewriting with CDR-NLISTP, and unfolding
    the functions EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.373.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, appealing to the lemma CDR-NLISTP, and expanding
    the definitions of EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.372.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NUMBERP (CADDR X))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, and unfolding EQUAL,
    LISTP, and SHUFFLEP, to:

          T.

  Case 1.371.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (NUMBERP (CADDR X)))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, appealing to the lemma CDR-NLISTP, and expanding
    the functions EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.370.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with the lemma CDR-NLISTP, and opening
    up the definitions of EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.369.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with the lemma CDR-NLISTP, and opening
    up the functions EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.368.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, and expanding EQUAL,
    LISTP, and SHUFFLEP, to:

          T.

  Case 1.367.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP, and opening up the
    definitions of EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.366.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, applying the lemma CDR-NLISTP, and
    expanding the definitions of EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.365.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CDR-NLISTP, and expanding the functions
    EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.364.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, applying the lemma CDR-NLISTP, and unfolding the
    functions EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.363.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with the lemma CDR-NLISTP, and opening
    up EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.362.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, and expanding the
    definitions of EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.361.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP, and unfolding EQUAL,
    LISTP, and SHUFFLEP, to:

          T.

  Case 1.360.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with the lemma CDR-NLISTP, and unfolding
    the definitions of EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.359.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, and expanding the
    definitions of EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.358.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NUMBERP (CADDR Y))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP, and expanding EQUAL,
    LISTP, and SHUFFLEP, to:

          T.

  Case 1.357.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NUMBERP (CADDR Y))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, appealing to the lemma CDR-NLISTP, and opening up
    the functions EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.356.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NUMBERP (CADDR Y))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, and expanding EQUAL,
    LISTP, and SHUFFLEP, to:

          T.

  Case 1.355.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NUMBERP (CADDR Y))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, applying CDR-NLISTP, and unfolding the
    functions EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.354.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NUMBERP (CADDR Y))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, applying CDR-NLISTP, and opening up the
    functions EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.353.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NUMBERP (CADDR Y))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with CDR-NLISTP, and opening up the
    functions EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.352.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NUMBERP (CADDR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADDR X))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, applying the lemma CDR-NLISTP, and unfolding the
    definitions of EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.351.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NUMBERP (CADDR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADDR X)))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, appealing to the lemma CDR-NLISTP, and expanding
    EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.350.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NUMBERP (CADDR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CDR-NLISTP, and unfolding EQUAL, LISTP,
    and SHUFFLEP, to:

          T.

  Case 1.349.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NUMBERP (CADDR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, appealing to the lemma CDR-NLISTP, and
    expanding the definitions of EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.348.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NUMBERP (CADDR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NUMBERP (CADDR X))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, and expanding the
    functions EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.347.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NUMBERP (CADDR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (NUMBERP (CADDR X)))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, appealing to the lemma CDR-NLISTP, and expanding
    the definitions of EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.346.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NUMBERP (CADDR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, appealing to the lemma CDR-NLISTP, and opening up
    EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.345.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NUMBERP (CADDR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, and unfolding the
    definitions of EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.344.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NUMBERP (CADDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, appealing to the lemma CDR-NLISTP, and
    expanding EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.343.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NUMBERP (CADDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, and unfolding EQUAL,
    LISTP, and SHUFFLEP, to:

          T.

  Case 1.342.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NUMBERP (CADDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, applying CDR-NLISTP, and expanding EQUAL, LISTP,
    and SHUFFLEP, to:

          T.

  Case 1.341.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NUMBERP (CADDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, applying CDR-NLISTP, and opening up EQUAL,
    LISTP, and SHUFFLEP, to:

          T.

  Case 1.340.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NUMBERP (CADDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP, and unfolding EQUAL,
    LISTP, and SHUFFLEP, to:

          T.

  Case 1.339.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NUMBERP (CADDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP, and expanding EQUAL,
    LISTP, and SHUFFLEP, to:

          T.

  Case 1.338.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NUMBERP (CADDR Y))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, applying CDR-NLISTP, and opening up the functions
    EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.337.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NUMBERP (CADDR Y))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying the lemma CDR-NLISTP, and unfolding
    the functions EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.336.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NUMBERP (CADDR Y))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, appealing to the lemma CDR-NLISTP, and opening up
    the definitions of EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.335.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADR Y))
                        (NUMBERP (CADDR Y))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, and unfolding the
    definitions of EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.334.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, rewriting with CDR-NLISTP, and opening up
    EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.333.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, rewriting with CDR-NLISTP, and expanding
    the definitions of EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.332.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, applying the lemma CDR-NLISTP, and expanding the
    definitions of EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.331.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, and opening up EQUAL,
    LISTP, and SHUFFLEP, to:

          T.

  Case 1.330.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, rewriting with CDR-NLISTP, and unfolding
    EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.329.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP, and expanding EQUAL,
    LISTP, and SHUFFLEP, to:

          T.

  Case 1.328.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADDR X))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP, and expanding the
    functions EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.327.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADDR X)))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, appealing to the lemma CDR-NLISTP, and expanding
    the definitions of EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.326.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CDR-NLISTP, and expanding the definitions
    of EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.325.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying CDR-NLISTP, and opening up the
    definitions of EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.324.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NUMBERP (CADDR X))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with CDR-NLISTP, and expanding EQUAL,
    LISTP, and SHUFFLEP, to:

          T.

  Case 1.323.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (NUMBERP (CADDR X)))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, appealing to the lemma CDR-NLISTP, and unfolding
    the functions EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.322.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CDR-NLISTP, and expanding the definitions
    of EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.321.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, applying CDR-NLISTP, and expanding EQUAL, LISTP,
    and SHUFFLEP, to:

          T.

  Case 1.320.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying CDR-NLISTP, and unfolding the
    functions EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.319.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying CDR-NLISTP, and unfolding the
    definitions of EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.318.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with the lemma CDR-NLISTP, and opening up
    the functions EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.317.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CDR-NLISTP, and unfolding the definitions
    of EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.316.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, rewriting with CDR-NLISTP, and expanding
    the functions EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.315.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP, and opening up EQUAL,
    LISTP, and SHUFFLEP, to:

          T.

  Case 1.314.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying CDR-NLISTP, and expanding the
    functions EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.313.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying CDR-NLISTP, and opening up the
    functions EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.312.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, applying CDR-NLISTP, and expanding EQUAL, LISTP,
    and SHUFFLEP, to:

          T.

  Case 1.311.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, applying the lemma CDR-NLISTP, and
    unfolding the definitions of EQUAL, LISTP, and SHUFFLEP, to:

          T.

  Case 1.310.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR X))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NUMBERP (CADDR Y))
                        (ALTERNATING-COLORS (CDDR Y))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CDR-NLISTP, and opening up the function
    LISTP, to:

          T.

  Case 1.309.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR X))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (NUMBERP (CADDR Y)))
                        (ALTERNATING-COLORS (CDDR Y))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with CDR-NLISTP, and opening up the
    function LISTP, to:

          T.

  Case 1.308.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR X))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP, and opening up the
    definitions of PLISTP, SHUFFLEP, and LISTP, to:

          T.

  Case 1.307.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR X))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, applying CDR-NLISTP, and expanding the
    definitions of PLISTP, SHUFFLEP, and LISTP, to:

          T.

  Case 1.306.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NUMBERP (CADDR Y))
                        (ALTERNATING-COLORS (CDDR Y))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, rewriting with CDR-NLISTP, and expanding
    the definition of LISTP, to:

          T.

  Case 1.305.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP, and unfolding the
    definitions of PLISTP, SHUFFLEP, and LISTP, to:

          T.

  Case 1.304.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NUMBERP (CADDR Y))
                        (ALTERNATING-COLORS (CDDR Y))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, rewriting with CDR-NLISTP, and expanding
    the definition of LISTP, to:

          T.

  Case 1.303.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (NUMBERP (CADDR Y)))
                        (ALTERNATING-COLORS (CDDR Y))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with CDR-NLISTP, and expanding the
    definition of LISTP, to:

          T.

  Case 1.302.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with CDR-NLISTP, and opening up the
    definitions of PLISTP, SHUFFLEP, and LISTP, to:

          T.

  Case 1.301.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, applying the lemma CDR-NLISTP, and unfolding PLISTP,
    SHUFFLEP, and LISTP, to:

          T.

  Case 1.300.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NUMBERP (CADDR Y))
                        (ALTERNATING-COLORS (CDDR Y))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying the lemma CDR-NLISTP, and expanding LISTP,
    to:

          T.

  Case 1.299.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (NUMBERP (CADDR Y)))
                        (ALTERNATING-COLORS (CDDR Y))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CDR-NLISTP, and opening up the function
    LISTP, to:

          T.

  Case 1.298.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with the lemma CDR-NLISTP, and
    unfolding the definitions of PLISTP, SHUFFLEP, and LISTP, to:

          T.

  Case 1.297.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CDR-NLISTP, and unfolding the definitions
    of PLISTP, SHUFFLEP, and LISTP, to:

          T.

  Case 1.296.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (LISTP (CDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NUMBERP (CADDR Y))
                        (ALTERNATING-COLORS (CDDR Y))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, rewriting with the lemma CDR-NLISTP, and
    expanding the function LISTP, to:

          T.

  Case 1.295.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (LISTP (CDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with the lemma CDR-NLISTP, and expanding
    the definitions of PLISTP, SHUFFLEP, and LISTP, to:

          T.

  Case 1.294.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (LISTP (CDR Y))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADDR Y))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (ALTERNATING-COLORS (CDDR Y))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, appealing to the lemma CDR-NLISTP, and opening up
    LISTP, to:

          T.

  Case 1.293.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CADR Y))
                        (NOT (NUMBERP (CADDR Y)))
                        (ALTERNATING-COLORS (CDDR Y))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, and opening up LISTP,
    to:

          T.

  Case 1.292.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with CDR-NLISTP, and expanding the
    definitions of PLISTP, SHUFFLEP, and LISTP, to:

          T.

  Case 1.291.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NUMBERP (CADDR Y))
                        (ALTERNATING-COLORS (CDDR Y))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP, and opening up the
    function LISTP, to:

          T.

  Case 1.290.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (NUMBERP (CADDR Y)))
                        (ALTERNATING-COLORS (CDDR Y))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, rewriting with CDR-NLISTP, and unfolding
    the definition of LISTP, to:

          T.

  Case 1.289.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, applying CDR-NLISTP, and opening up the definitions
    of PLISTP, SHUFFLEP, and LISTP, to:

          T.

  Case 1.288.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, rewriting with CDR-NLISTP, and expanding
    PLISTP, SHUFFLEP, and LISTP, to:

          T.

  Case 1.287.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NUMBERP (CADDR Y))
                        (ALTERNATING-COLORS (CDDR Y))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying CDR-NLISTP, and expanding the
    definition of LISTP, to:

          T.

  Case 1.286.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (NUMBERP (CADDR Y)))
                        (ALTERNATING-COLORS (CDDR Y))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, applying the lemma CDR-NLISTP, and unfolding the
    definition of LISTP, to:

          T.

  Case 1.285.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, and unfolding PLISTP,
    SHUFFLEP, and LISTP, to:

          T.

  Case 1.284.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, rewriting with CDR-NLISTP, and expanding
    PLISTP, SHUFFLEP, and LISTP, to:

          T.

  Case 1.283.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (LISTP (CDR Y))
                        (NUMBERP (CADR Y))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (NUMBERP (CADDR Y)))
                        (ALTERNATING-COLORS (CDDR Y))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, applying the lemma CDR-NLISTP, and
    expanding LISTP, to:

          T.

  Case 1.282.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (LISTP (CDR Y))
                        (NUMBERP (CADR Y))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, and expanding the
    definitions of PLISTP, SHUFFLEP, and LISTP, to:

          T.

  Case 1.281.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (LISTP (CDR Y))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADDR Y)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (ALTERNATING-COLORS (CDDR Y))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying CDR-NLISTP, and expanding LISTP, to:

          T.

  Case 1.280.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, rewriting with CDR-NLISTP, CAR-NLISTP, and
    AL->PP, and opening up the functions EQUAL, LISTP, SHUFFLEP, PLISTP,
    NUMBERP, and ALTERNATING-COLORS, to:

          T.

  Case 1.279.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NUMBERP (CADDR Y))
                        (ALTERNATING-COLORS (CDDR Y))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, appealing to the lemmas CAR-NLISTP and
    AL->PP, and unfolding NUMBERP, PLISTP, SHUFFLEP, LISTP, ALTERNATING-COLORS,
    OPPOSITE-COLOR, and CAR, to:

          T.

  Case 1.278.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, appealing to the lemmas CAR-NLISTP and AL->PP, and
    unfolding the functions PLISTP, SHUFFLEP, NUMBERP, LISTP, CAR,
    ALTERNATING-COLORS, and OPPOSITE-COLOR, to:

          T.

  Case 1.277.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with the lemmas CDR-NLISTP and
    CAR-NLISTP, and opening up the definitions of EQUAL, LISTP, SHUFFLEP,
    PLISTP, and NUMBERP, to:

          T.

  Case 1.276.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NUMBERP (CADR Y))
                        (NOT (NUMBERP (CADDR Y)))
                        (ALTERNATING-COLORS (CDDR Y))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CAR-NLISTP, and opening up the
    definition of NUMBERP, to:

          T.

  Case 1.275.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with the lemma CAR-NLISTP, and unfolding
    PLISTP, SHUFFLEP, and NUMBERP, to:

          T.

  Case 1.274.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, and unfolding the
    definitions of EQUAL, LISTP, SHUFFLEP, PLISTP, and ALTERNATING-COLORS, to:

          T.

  Case 1.273.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (NUMBERP (CADDR Y)))
                        (ALTERNATING-COLORS (CDDR Y))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, unfolding the function ALTERNATING-COLORS, to:

          T.

  Case 1.272.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding PLISTP, SHUFFLEP, and ALTERNATING-COLORS,
    to:

          T.

  Case 1.271.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, and opening up EQUAL,
    LISTP, SHUFFLEP, PLISTP, and ALTERNATING-COLORS, to:

          T.

  Case 1.270.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NUMBERP (CADDR Y))
                        (ALTERNATING-COLORS (CDDR Y))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, expanding the definition of ALTERNATING-COLORS,
    to:

          T.

  Case 1.269.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding PLISTP, SHUFFLEP, and ALTERNATING-COLORS,
    to:

          T.

  Case 1.268.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (LISTP (CDR Y)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, CAR-NLISTP, and AL->PP,
    and unfolding the definitions of EQUAL, LISTP, SHUFFLEP, NUMBERP, PLISTP,
    and ALTERNATING-COLORS, to:

          T.

  Case 1.267.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (LISTP (CDR Y)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP and CAR-NLISTP, and
    opening up the functions EQUAL, LISTP, SHUFFLEP, and NUMBERP, to:

          T.

  Case 1.266.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (LISTP (CDR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP, and expanding the
    functions EQUAL, LISTP, SHUFFLEP, and ALTERNATING-COLORS, to:

          T.

  Case 1.265.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (LISTP (CDR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, applying CDR-NLISTP, and expanding the definitions
    of EQUAL, LISTP, SHUFFLEP, and ALTERNATING-COLORS, to:

          T.

  Case 1.264.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, appealing to the lemma CAR-NLISTP, and
    expanding the functions PLISTP, SHUFFLEP, and NUMBERP, to:

          T.

  Case 1.263.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CADDR Y))
                        (ALTERNATING-COLORS (CDDR Y))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, appealing to the lemma CAR-NLISTP, and unfolding
    the definition of NUMBERP, to:

          T.

  Case 1.262.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying the lemmas CDR-NLISTP and CAR-NLISTP, and
    opening up the definitions of EQUAL, LISTP, SHUFFLEP, and NUMBERP, to:

          T.

  Case 1.261.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP and CAR-NLISTP, and
    expanding EQUAL, LISTP, SHUFFLEP, and NUMBERP, to:

          T.

  Case 1.260.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, rewriting with the lemmas CDR-NLISTP and
    CAR-NLISTP, and opening up EQUAL, LISTP, SHUFFLEP, and NUMBERP, to:

          T.

  Case 1.259.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NUMBERP (CADDR Y))
                        (ALTERNATING-COLORS (CDDR Y))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CAR-NLISTP, and opening up NUMBERP,
    to:

          T.

  Case 1.258.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with CAR-NLISTP, and opening up the
    definitions of PLISTP, SHUFFLEP, and NUMBERP, to:

          T.

  Case 1.257.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR X))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with the lemmas CDR-NLISTP and CAR-NLISTP,
    and opening up EQUAL, LISTP, SHUFFLEP, and NUMBERP, to:

          T.

  Case 1.256.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CDR-NLISTP and CAR-NLISTP, and unfolding
    the functions EQUAL, LISTP, SHUFFLEP, and NUMBERP, to:

          T.

  Case 1.255.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR X))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with the lemmas CDR-NLISTP and
    CAR-NLISTP, and expanding EQUAL, LISTP, SHUFFLEP, and NUMBERP, to:

          T.

  Case 1.254.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CDR-NLISTP and CAR-NLISTP, and opening up
    the definitions of EQUAL, LISTP, SHUFFLEP, and NUMBERP, to:

          T.

  Case 1.253.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NUMBERP (CADDR Y))
                        (ALTERNATING-COLORS (CDDR Y))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, applying CAR-NLISTP, and expanding NUMBERP, to:

          T.

  Case 1.252.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, applying CAR-NLISTP, and unfolding the functions
    PLISTP, SHUFFLEP, and NUMBERP, to:

          T.

  Case 1.251.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP and CAR-NLISTP, and
    expanding EQUAL, LISTP, SHUFFLEP, and NUMBERP, to:

          T.

  Case 1.250.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, applying CDR-NLISTP and CAR-NLISTP, and
    opening up EQUAL, LISTP, SHUFFLEP, and NUMBERP, to:

          T.

  Case 1.249.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, rewriting with CDR-NLISTP and CAR-NLISTP,
    and expanding the functions EQUAL, LISTP, SHUFFLEP, and NUMBERP, to:

          T.

  Case 1.248.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NUMBERP (CADDR Y))
                        (ALTERNATING-COLORS (CDDR Y))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, applying the lemma CAR-NLISTP, and expanding
    NUMBERP, to:

          T.

  Case 1.247.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CAR-NLISTP, and unfolding the definitions
    of PLISTP, SHUFFLEP, and NUMBERP, to:

          T.

  Case 1.246.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with the lemmas CDR-NLISTP and CAR-NLISTP,
    and opening up EQUAL, LISTP, SHUFFLEP, and NUMBERP, to:

          T.

  Case 1.245.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying the lemmas CDR-NLISTP and CAR-NLISTP, and
    unfolding EQUAL, LISTP, SHUFFLEP, and NUMBERP, to:

          T.

  Case 1.244.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying the lemmas CDR-NLISTP, CAR-NLISTP, and
    AL->PP, and expanding EQUAL, LISTP, SHUFFLEP, NUMBERP, PLISTP, and
    ALTERNATING-COLORS, to:

          T.

  Case 1.243.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with the lemmas CDR-NLISTP, CAR-NLISTP,
    and AL->PP, and unfolding the functions EQUAL, LISTP, SHUFFLEP, NUMBERP,
    PLISTP, and ALTERNATING-COLORS, to:

          T.

  Case 1.242.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CDR-NLISTP, CAR-NLISTP, and AL->PP, and
    expanding EQUAL, LISTP, SHUFFLEP, NUMBERP, PLISTP, and ALTERNATING-COLORS,
    to:

          T.

  Case 1.241.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with CAR-NLISTP and CDR-NLISTP, and
    expanding the functions PLISTP, SHUFFLEP, NUMBERP, and CAR, to:

          T.

  Case 1.240.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CADDR Y)))
                        (ALTERNATING-COLORS (CDDR Y))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with the lemmas CAR-NLISTP and CDR-NLISTP,
    and unfolding NUMBERP and CAR, to:

          T.

  Case 1.239.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (NUMBERP (CADDR Y)))
                        (ALTERNATING-COLORS (CDDR Y))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with the lemmas CAR-NLISTP, CDR-NLISTP,
    and AL->PP, and unfolding NUMBERP, EQUAL, LISTP, SHUFFLEP, PLISTP,
    ALTERNATING-COLORS, and OPPOSITE-COLOR, to:

          T.

  Case 1.238.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with the lemmas CAR-NLISTP, CDR-NLISTP,
    and AL->PP, and opening up PLISTP, SHUFFLEP, NUMBERP, EQUAL, LISTP, and
    ALTERNATING-COLORS, to:

          T.

  Case 1.237.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, appealing to the lemmas CDR-NLISTP, CAR-NLISTP,
    and AL->PP, and opening up EQUAL, LISTP, SHUFFLEP, NUMBERP, PLISTP,
    ALTERNATING-COLORS, and OPPOSITE-COLOR, to:

          T.

  Case 1.236.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, appealing to the lemmas CDR-NLISTP, CAR-NLISTP,
    and AL->PP, and unfolding the functions EQUAL, LISTP, SHUFFLEP, NUMBERP,
    PLISTP, and ALTERNATING-COLORS, to:

          T.

  Case 1.235.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, CAR-NLISTP, and AL->PP,
    and unfolding the functions EQUAL, LISTP, SHUFFLEP, NUMBERP, PLISTP,
    ALTERNATING-COLORS, and OPPOSITE-COLOR, to:

          T.

  Case 1.234.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying CDR-NLISTP, CAR-NLISTP, and AL->PP,
    and opening up EQUAL, LISTP, SHUFFLEP, NUMBERP, PLISTP, and
    ALTERNATING-COLORS, to:

          T.

  Case 1.233.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (NUMBERP (CADDR Y)))
                        (ALTERNATING-COLORS (CDDR Y))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CAR-NLISTP and CDR-NLISTP, and
    expanding the definitions of NUMBERP and ALTERNATING-COLORS, to:

          T.

  Case 1.232.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, appealing to the lemmas CAR-NLISTP and
    CDR-NLISTP, and opening up the definitions of PLISTP, SHUFFLEP, NUMBERP,
    and ALTERNATING-COLORS, to:

          T.

  Case 1.231.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP and CAR-NLISTP, and
    opening up the functions EQUAL, LISTP, SHUFFLEP, NUMBERP, and
    ALTERNATING-COLORS, to:

          T.

  Case 1.230.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with the lemmas CDR-NLISTP and
    CAR-NLISTP, and opening up the functions EQUAL, LISTP, SHUFFLEP, NUMBERP,
    and ALTERNATING-COLORS, to:

          T.

  Case 1.229.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CDR-NLISTP and CAR-NLISTP, and unfolding
    EQUAL, LISTP, SHUFFLEP, NUMBERP, and ALTERNATING-COLORS, to:

          T.

  Case 1.228.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (NUMBERP (CADDR Y)))
                        (ALTERNATING-COLORS (CDDR Y))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying CAR-NLISTP, CDR-NLISTP, and AL->PP,
    and opening up the definitions of NUMBERP, LISTP, PLISTP, SHUFFLEP,
    ALTERNATING-COLORS, and OPPOSITE-COLOR, to:

          T.

  Case 1.227.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CAR-NLISTP, CDR-NLISTP, and
    AL->PP, and unfolding PLISTP, SHUFFLEP, NUMBERP, LISTP, and
    ALTERNATING-COLORS, to:

          T.

  Case 1.226.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP, CAR-NLISTP, and
    AL->PP, and unfolding the functions EQUAL, LISTP, SHUFFLEP, NUMBERP,
    PLISTP, and ALTERNATING-COLORS, to:

          T.

  Case 1.225.
          (IMPLIES (AND (LISTP Z)
                        (NOT (SHUFFLEP X (CDDR Y) (CDDR Z)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying CDR-NLISTP, CAR-NLISTP, and AL->PP,
    and unfolding the functions EQUAL, LISTP, SHUFFLEP, NUMBERP, PLISTP, and
    ALTERNATING-COLORS, to:

          T.

  Case 1.224.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, applying CDR-NLISTP, and unfolding the
    function ALTERNATING-COLORS, to:

          T.

  Case 1.223.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, rewriting with CDR-NLISTP, and unfolding
    ALTERNATING-COLORS, to:

          T.

  Case 1.222.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR Y))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with CDR-NLISTP, and expanding
    ALTERNATING-COLORS, to:

          T.

  Case 1.221.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with the lemma CDR-NLISTP, and expanding
    the function ALTERNATING-COLORS, to:

          T.

  Case 1.220.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying the lemma CDR-NLISTP, and expanding
    ALTERNATING-COLORS, to:

          T.

  Case 1.219.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, appealing to the lemma CDR-NLISTP, and unfolding
    ALTERNATING-COLORS, to:

          T.

  Case 1.218.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADDR X))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, appealing to the lemma CDR-NLISTP, and expanding
    ALTERNATING-COLORS, to:

          T.

  Case 1.217.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADDR X)))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying the lemma CDR-NLISTP, and opening up the
    function ALTERNATING-COLORS, to:

          T.

  Case 1.216.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying the lemma CDR-NLISTP, and opening up the
    definition of ALTERNATING-COLORS, to:

          T.

  Case 1.215.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with the lemma CDR-NLISTP, and unfolding
    the function ALTERNATING-COLORS, to:

          T.

  Case 1.214.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NUMBERP (CADDR X))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CDR-NLISTP, and opening up the definition
    of ALTERNATING-COLORS, to:

          T.

  Case 1.213.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (NUMBERP (CADDR X)))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, appealing to the lemma CDR-NLISTP, and
    expanding ALTERNATING-COLORS, to:

          T.

  Case 1.212.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, and opening up
    ALTERNATING-COLORS, to:

          T.

  Case 1.211.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, applying CDR-NLISTP, and expanding
    ALTERNATING-COLORS, to:

          T.

  Case 1.210.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying the lemma CDR-NLISTP, and opening up
    the function ALTERNATING-COLORS, to:

          T.

  Case 1.209.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying the lemma CDR-NLISTP, and expanding the
    definition of ALTERNATING-COLORS, to:

          T.

  Case 1.208.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with the lemma CDR-NLISTP, and expanding
    the function ALTERNATING-COLORS, to:

          T.

  Case 1.207.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, and opening up the
    function ALTERNATING-COLORS, to:

          T.

  Case 1.206.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, appealing to the lemma CDR-NLISTP, and opening up
    the definition of ALTERNATING-COLORS, to:

          T.

  Case 1.205.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying the lemma CDR-NLISTP, and unfolding the
    definition of ALTERNATING-COLORS, to:

          T.

  Case 1.204.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, and unfolding the
    function ALTERNATING-COLORS, to:

          T.

  Case 1.203.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, applying the lemma CDR-NLISTP, and opening up
    ALTERNATING-COLORS, to:

          T.

  Case 1.202.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with the lemma CDR-NLISTP, and expanding
    ALTERNATING-COLORS, to:

          T.

  Case 1.201.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR Y))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying the lemma CDR-NLISTP, and unfolding
    ALTERNATING-COLORS, to:

          T.

  Case 1.200.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, opening up the function ALTERNATING-COLORS, to:

          T.

  Case 1.199.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding the definition of ALTERNATING-COLORS, to:

          T.

  Case 1.198.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding the definition of ALTERNATING-COLORS, to:

          T.

  Case 1.197.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CAR X))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding the function ALTERNATING-COLORS, to:

          T.

  Case 1.196.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding ALTERNATING-COLORS, to:

          T.

  Case 1.195.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding the definition of ALTERNATING-COLORS, to:

          T.

  Case 1.194.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (LISTP (CDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, opening up ALTERNATING-COLORS, to:

          T.

  Case 1.193.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (LISTP (CDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding ALTERNATING-COLORS, to:

          T.

  Case 1.192.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (LISTP (CDR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding ALTERNATING-COLORS, to:

          T.

  Case 1.191.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding ALTERNATING-COLORS, to:

          T.

  Case 1.190.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding the function ALTERNATING-COLORS, to:

          T.

  Case 1.189.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding the definition of ALTERNATING-COLORS, to:

          T.

  Case 1.188.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CAR X))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding ALTERNATING-COLORS, to:

          T.

  Case 1.187.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding the function ALTERNATING-COLORS, to:

          T.

  Case 1.186.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding the function ALTERNATING-COLORS, to:

          T.

  Case 1.185.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding the definition of ALTERNATING-COLORS, to:

          T.

  Case 1.184.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding the function ALTERNATING-COLORS, to:

          T.

  Case 1.183.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, opening up ALTERNATING-COLORS, to:

          T.

  Case 1.182.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CAR X))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding the function ALTERNATING-COLORS, to:

          T.

  Case 1.181.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding ALTERNATING-COLORS, to:

          T.

  Case 1.180.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding ALTERNATING-COLORS, to:

          T.

  Case 1.179.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, opening up ALTERNATING-COLORS, to:

          T.

  Case 1.178.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding the definition of ALTERNATING-COLORS, to:

          T.

  Case 1.177.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding the definition of ALTERNATING-COLORS, to:

          T.

  Case 1.176.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (LISTP (CDR Y))
                        (NUMBERP (CADR Y))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, opening up ALTERNATING-COLORS, to:

          T.

  Case 1.175.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (LISTP (CDR Y))
                        (NUMBERP (CADR Y))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, opening up the function ALTERNATING-COLORS, to:

          T.

  Case 1.174.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (LISTP (CDR Y))
                        (NUMBERP (CADR Y))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding ALTERNATING-COLORS, to:

          T.

  Case 1.173.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding the definition of ALTERNATING-COLORS, to:

          T.

  Case 1.172.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding ALTERNATING-COLORS, to:

          T.

  Case 1.171.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, opening up the definition of ALTERNATING-COLORS,
    to:

          T.

  Case 1.170.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CAR X))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, opening up the definition of ALTERNATING-COLORS,
    to:

          T.

  Case 1.169.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, opening up the definition of ALTERNATING-COLORS,
    to:

          T.

  Case 1.168.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding the function ALTERNATING-COLORS, to:

          T.

  Case 1.167.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding the function ALTERNATING-COLORS, to:

          T.

  Case 1.166.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding the definition of ALTERNATING-COLORS, to:

          T.

  Case 1.165.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding ALTERNATING-COLORS, to:

          T.

  Case 1.164.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CAR X))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding ALTERNATING-COLORS, to:

          T.

  Case 1.163.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding the function ALTERNATING-COLORS, to:

          T.

  Case 1.162.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding ALTERNATING-COLORS, to:

          T.

  Case 1.161.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding the function ALTERNATING-COLORS, to:

          T.

  Case 1.160.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR X))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding ALTERNATING-COLORS, to:

          T.

  Case 1.159.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (LISTP (CDDR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding the function ALTERNATING-COLORS, to:

          T.

  Case 1.158.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, opening up the definition of ALTERNATING-COLORS,
    to:

          T.

  Case 1.157.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding the function ALTERNATING-COLORS, to:

          T.

  Case 1.156.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, opening up ALTERNATING-COLORS, to:

          T.

  Case 1.155.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding ALTERNATING-COLORS, to:

          T.

  Case 1.154.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, appealing to the lemma CDR-NLISTP, and expanding
    the definition of ALTERNATING-COLORS, to:

          T.

  Case 1.153.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, opening up the function ALTERNATING-COLORS, to:

          T.

  Case 1.152.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding the definition of ALTERNATING-COLORS, to:

          T.

  Case 1.151.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, opening up ALTERNATING-COLORS, to:

          T.

  Case 1.150.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR X))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding ALTERNATING-COLORS, to:

          T.

  Case 1.149.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding the definition of ALTERNATING-COLORS, to:

          T.

  Case 1.148.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CDR-NLISTP, and expanding the function
    ALTERNATING-COLORS, to:

          T.

  Case 1.147.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, expanding the definition of ALTERNATING-COLORS, to:

          T.

  Case 1.146.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding the function ALTERNATING-COLORS, to:

          T.

  Case 1.145.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding ALTERNATING-COLORS, to:

          T.

  Case 1.144.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NUMBERP (CADDR X))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, opening up the definition of ALTERNATING-COLORS,
    to:

          T.

  Case 1.143.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (NUMBERP (CADDR X)))
                        (ALTERNATING-COLORS (CDDR X))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, opening up ALTERNATING-COLORS, to:

          T.

  Case 1.142.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding ALTERNATING-COLORS, to:

          T.

  Case 1.141.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding ALTERNATING-COLORS, to:

          T.

  Case 1.140.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding the function ALTERNATING-COLORS, to:

          T.

  Case 1.139.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CAR X))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding the definition of ALTERNATING-COLORS, to:

          T.

  Case 1.138.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NUMBERP (CADDR X))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, opening up ALTERNATING-COLORS, to:

          T.

  Case 1.137.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (NUMBERP (CADDR X)))
                        (ALTERNATING-COLORS (CDDR X))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding the function ALTERNATING-COLORS, to:

          T.

  Case 1.136.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding ALTERNATING-COLORS, to:

          T.

  Case 1.135.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, opening up the definition of ALTERNATING-COLORS,
    to:

          T.

  Case 1.134.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding the function ALTERNATING-COLORS, to:

          T.

  Case 1.133.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding ALTERNATING-COLORS, to:

          T.

  Case 1.132.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding the definition of ALTERNATING-COLORS, to:

          T.

  Case 1.131.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding ALTERNATING-COLORS, to:

          T.

  Case 1.130.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding ALTERNATING-COLORS, to:

          T.

  Case 1.129.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CAR X))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, opening up ALTERNATING-COLORS, to:

          T.

  Case 1.128.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding ALTERNATING-COLORS, to:

          T.

  Case 1.127.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding the definition of ALTERNATING-COLORS, to:

          T.

  Case 1.126.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, and expanding the
    definition of ALTERNATING-COLORS, to:

          T.

  Case 1.125.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, unfolding ALTERNATING-COLORS, to:

          T.

  Case 1.124.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CDR-NLISTP, and unfolding
    ALTERNATING-COLORS, to:

          T.

  Case 1.123.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, opening up ALTERNATING-COLORS, to:

          T.

  Case 1.122.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding the function ALTERNATING-COLORS, to:

          T.

  Case 1.121.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding ALTERNATING-COLORS, to:

          T.

  Case 1.120.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding the function ALTERNATING-COLORS, to:

          T.

  Case 1.119.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding the function ALTERNATING-COLORS, to:

          T.

  Case 1.118.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding ALTERNATING-COLORS, to:

          T.

  Case 1.117.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, opening up ALTERNATING-COLORS, to:

          T.

  Case 1.116.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, opening up the definition of ALTERNATING-COLORS,
    to:

          T.

  Case 1.115.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (SHUFFLEP (CDR X) (CDR Y) (CDDR Z)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CAR X))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding the definition of ALTERNATING-COLORS, to:

          T.

  Case 1.114.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (LISTP (CDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding ALTERNATING-COLORS, to:

          T.

  Case 1.113.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (LISTP (CDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding the function ALTERNATING-COLORS, to:

          T.

  Case 1.112.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (LISTP (CDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NUMBERP (CAR Y))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding ALTERNATING-COLORS, to:

          T.

  Case 1.111.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (LISTP (CDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR Y)))
                        (NUMBERP (CAR X))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding the definition of ALTERNATING-COLORS, to:

          T.

  Case 1.110.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (LISTP (CDR Y)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with the lemma CDR-NLISTP, and unfolding
    the function ALTERNATING-COLORS, to:

          T.

  Case 1.109.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (LISTP (CDR Y)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CDR-NLISTP, and opening up the definition
    of ALTERNATING-COLORS, to:

          T.

  Case 1.108.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (LISTP (CDR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying CDR-NLISTP, and expanding the
    definition of ALTERNATING-COLORS, to:

          T.

  Case 1.107.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (LISTP (CDR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP, and unfolding the
    function ALTERNATING-COLORS, to:

          T.

  Case 1.106.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, unfolding the definition of
    ALTERNATING-COLORS, to:

          T.

  Case 1.105.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding ALTERNATING-COLORS, to:

          T.

  Case 1.104.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, opening up ALTERNATING-COLORS, to:

          T.

  Case 1.103.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, and opening up the
    function ALTERNATING-COLORS, to:

          T.

  Case 1.102.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP, and expanding
    ALTERNATING-COLORS, to:

          T.

  Case 1.101.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP, and unfolding
    ALTERNATING-COLORS, to:

          T.

  Case 1.100.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, unfolding the function ALTERNATING-COLORS,
    to:

          T.

  Case 1.99.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding the definition of ALTERNATING-COLORS, to:

          T.

  Case 1.98.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, opening up the definition of ALTERNATING-COLORS,
    to:

          T.

  Case 1.97.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR X))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, and opening up the
    function ALTERNATING-COLORS, to:

          T.

  Case 1.96.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, applying CDR-NLISTP, and opening up the
    definition of ALTERNATING-COLORS, to:

          T.

  Case 1.95.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NUMBERP (CADDR X))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with the lemma CDR-NLISTP, and expanding
    the function ALTERNATING-COLORS, to:

          T.

  Case 1.94.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, and expanding
    ALTERNATING-COLORS, to:

          T.

  Case 1.93.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, unfolding the definition of ALTERNATING-COLORS, to:

          T.

  Case 1.92.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding the function ALTERNATING-COLORS, to:

          T.

  Case 1.91.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, opening up the function ALTERNATING-COLORS, to:

          T.

  Case 1.90.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CDR-NLISTP, and opening up
    ALTERNATING-COLORS, to:

          T.

  Case 1.89.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP, and opening up
    ALTERNATING-COLORS, to:

          T.

  Case 1.88.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP, and expanding the
    definition of ALTERNATING-COLORS, to:

          T.

  Case 1.87.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, expanding ALTERNATING-COLORS, to:

          T.

  Case 1.86.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, opening up ALTERNATING-COLORS, to:

          T.

  Case 1.85.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NUMBERP (CAR Y))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding ALTERNATING-COLORS, to:

          T.

  Case 1.84.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, and opening up
    ALTERNATING-COLORS, to:

          T.

  Case 1.83.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (NUMBERP (CADR Y)))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR Y))))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, rewriting with CDR-NLISTP, and expanding the
    definition of ALTERNATING-COLORS, to:

          T.

  Case 1.82.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    However this again simplifies, rewriting with CDR-NLISTP, and opening up
    ALTERNATING-COLORS, to:

          T.

  Case 1.81.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying the lemma CDR-NLISTP, and opening up
    ALTERNATING-COLORS, to:

          T.

  Case 1.80.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, appealing to the lemma CDR-NLISTP, and opening up
    ALTERNATING-COLORS, to:

          T.

  Case 1.79.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, opening up the definition of ALTERNATING-COLORS,
    to:

          T.

  Case 1.78.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding the definition of ALTERNATING-COLORS, to:

          T.

  Case 1.77.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding ALTERNATING-COLORS, to:

          T.

  Case 1.76.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding the definition of ALTERNATING-COLORS, to:

          T.

  Case 1.75.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding ALTERNATING-COLORS, to:

          T.

  Case 1.74.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, opening up ALTERNATING-COLORS, to:

          T.

  Case 1.73.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CDR-NLISTP, and unfolding the function
    ALTERNATING-COLORS, to:

          T.

  Case 1.72.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with the lemma CDR-NLISTP, and expanding
    the definition of ALTERNATING-COLORS, to:

          T.

  Case 1.71.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADDR X)))
                        (ALTERNATING-COLORS (CDDR X))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, appealing to the lemma CDR-NLISTP, and opening up
    the function ALTERNATING-COLORS, to:

          T.

  Case 1.70.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (SHUFFLEP (CDDR X) Y (CDDR Z)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CDR-NLISTP, and unfolding the definition
    of ALTERNATING-COLORS, to:

          T.

  Case 1.69.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, unfolding the definition of ALTERNATING-COLORS,
    to:

          T.

  Case 1.68.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding the function ALTERNATING-COLORS, to:

          T.

  Case 1.67.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding ALTERNATING-COLORS, to:

          T.

  Case 1.66.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, rewriting with CDR-NLISTP, and unfolding the
    function ALTERNATING-COLORS, to:

          T.

  Case 1.65.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    But this again simplifies, applying CDR-NLISTP, and unfolding
    ALTERNATING-COLORS, to:

          T.

  Case 1.64.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (ALTERNATING-COLORS (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (LISTP (CDDR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, applying the lemma CDR-NLISTP, and opening up the
    definition of ALTERNATING-COLORS, to:

          T.

  Case 1.63.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (NOT (EQUAL (CAR X) (CADR Z)))
                        (EQUAL (CADR Y) (CADR Z))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, unfolding ALTERNATING-COLORS, to:

          T.

  Case 1.62.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (EQUAL (CADR Y) (CAR X))
                        (SHUFFLEP X (CDDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, expanding the function ALTERNATING-COLORS, to:

          T.

  Case 1.61.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR X)))
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR Y))
                        (EQUAL (CAR X) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (LISTP (CDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (LISTP (CDDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, opening up ALTERNATING-COLORS, to:

          T.

  Case 1.60.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (EQUAL (CAR Y) (CADR X))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying the lemma CDR-NLISTP, and opening up the
    function ALTERNATING-COLORS, to:

          T.

  Case 1.59.
          (IMPLIES (AND (LISTP Z)
                        (NOT (ALTERNATING-COLORS (CDDR Y)))
                        (NUMBERP (CADR X))
                        (NUMBERP (CADR Y))
                        (NOT (LISTP (CDDR X)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (NOT (EQUAL (CADR X) (CADR Z)))
                        (EQUAL (CAR Y) (CADR Z))
                        (SHUFFLEP (CDR X) (CDR Y) (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (LISTP (CDR Y)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR Y)))
                   (PAIRED-COLORS (CDDR Z))),

    which again simplifies, applying CDR-NLISTP, and expanding
    ALTERNATING-COLORS, to:

          T.

  Case 1.58.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (CDDR Y)))
                        (NOT (LISTP (CDR Y)))
                        (NUMBERP (CADDR X))
                        (NUMBERP (CAR Y))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (CDDR X)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, rewriting with CDR-NLISTP, CAR-NLISTP, and AL->PP,
    and unfolding LISTP, NUMBERP, PLISTP, SHUFFLEP, and ALTERNATING-COLORS, to:

          T.

  Case 1.57.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (CDDR Y)))
                        (NOT (LISTP (CDR Y)))
                        (NOT (NUMBERP (CADDR X)))
                        (NOT (NUMBERP (CAR Y)))
                        (EQUAL (CAR X) (CAR Z))
                        (LISTP (CDR Z))
                        (LISTP (CDR X))
                        (EQUAL (CADR X) (CADR Z))
                        (SHUFFLEP (CDDR X) Y (CDDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (CDDR X)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, applying the lemmas CDR-NLISTP and CAR-NLISTP, and
    expanding the functions LISTP and NUMBERP, to:

          T.

  Case 1.56.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (CDDR Y)))
                        (NOT (LISTP (CDR Y)))