(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)))
                        (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))),

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

          T.

  Case 1.55.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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))).

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

          T.

  Case 1.54.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

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

          T.

  Case 1.53.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))).

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

          T.

  Case 1.52.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))).

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

          T.

  Case 1.51.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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))
                        (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.50.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))).

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

          T.

  Case 1.49.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))).

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

          T.

  Case 1.48.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))).

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

          T.

  Case 1.47.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))).

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

          T.

  Case 1.46.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

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

          T.

  Case 1.45.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))).

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

          T.

  Case 1.44.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))).

    This again simplifies, applying CDR-NLISTP, and expanding the function
    LISTP, to:

          T.

  Case 1.43.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))).

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

          T.

  Case 1.42.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))).

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

          T.

  Case 1.41.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

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

          T.

  Case 1.40.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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))).

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

          T.

  Case 1.39.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

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

          T.

  Case 1.38.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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))).

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

          T.

  Case 1.37.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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))
                        (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.36.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))).

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

          T.

  Case 1.35.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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, applying the lemma CDR-NLISTP, and expanding LISTP,
    PLISTP, SHUFFLEP, and ALTERNATING-COLORS, to:

          T.

  Case 1.34.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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)))
                        (LISTP X)
                        (LISTP Y))
                   (PAIRED-COLORS (CDDR Z))),

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

          T.

  Case 1.33.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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, rewriting with CDR-NLISTP, and unfolding the
    definitions of LISTP, PLISTP, SHUFFLEP, and ALTERNATING-COLORS, to:

          T.

  Case 1.32.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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)))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))).

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

          T.

  Case 1.31.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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, applying CDR-NLISTP and CAR-NLISTP, and opening up
    LISTP and NUMBERP, to:

          T.

  Case 1.30.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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))).

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

          T.

  Case 1.29.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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))).

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

          T.

  Case 1.28.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))).

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

          T.

  Case 1.27.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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))).

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

          T.

  Case 1.26.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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))),

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

          T.

  Case 1.25.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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 lemmas CDR-NLISTP and CAR-NLISTP,
    and unfolding LISTP and NUMBERP, to:

          T.

  Case 1.24.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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, applying CDR-NLISTP and CAR-NLISTP, and expanding
    the definitions of LISTP and NUMBERP, to:

          T.

  Case 1.23.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))).

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

          T.

  Case 1.22.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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 CAR-NLISTP, and opening up
    the definitions of LISTP and NUMBERP, to:

          T.

  Case 1.21.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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))).

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

          T.

  Case 1.20.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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))).

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

          T.

  Case 1.19.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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))
                        (LISTP X)
                        (LISTP Y)
                        (NOT (NUMBERP (CAR X))))
                   (PAIRED-COLORS (CDDR Z))).

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

          T.

  Case 1.18.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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 CAR-NLISTP, and
    opening up the functions LISTP and NUMBERP, to:

          T.

  Case 1.17.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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))).

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

          T.

  Case 1.16.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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, CAR-NLISTP, and
    AL->PP, and unfolding the definitions of LISTP, NUMBERP, PLISTP, SHUFFLEP,
    and ALTERNATING-COLORS, to:

          T.

  Case 1.15.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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, appealing to the lemmas CDR-NLISTP, CAR-NLISTP,
    and AL->PP, and opening up LISTP, NUMBERP, PLISTP, SHUFFLEP, and
    ALTERNATING-COLORS, to:

          T.

  Case 1.14.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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, rewriting with CDR-NLISTP, CAR-NLISTP, and AL->PP,
    and expanding LISTP, NUMBERP, PLISTP, SHUFFLEP, and ALTERNATING-COLORS, to:

          T.

  Case 1.13.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))).

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

          T.

  Case 1.12.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))).

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

          T.

  Case 1.11.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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, appealing to the lemmas CDR-NLISTP, CAR-NLISTP,
    and AL->PP, and unfolding the functions LISTP, NUMBERP, PLISTP, SHUFFLEP,
    ALTERNATING-COLORS, and OPPOSITE-COLOR, to:

          T.

  Case 1.10.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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))),

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

          T.

  Case 1.9.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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))).

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

          T.

  Case 1.8.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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))).

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

          T.

  Case 1.7.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))).

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

          T.

  Case 1.6.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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))).

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

          T.

  Case 1.5.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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, appealing to the lemmas CDR-NLISTP and
    CAR-NLISTP, and unfolding LISTP, NUMBERP, and ALTERNATING-COLORS, to:

          T.

  Case 1.4.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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))),

    which again simplifies, appealing to the lemmas CDR-NLISTP and CAR-NLISTP,
    and opening up the functions LISTP, NUMBERP, and ALTERNATING-COLORS, to:

          T.

  Case 1.3.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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)))
                        (LISTP X)
                        (LISTP Y)
                        (NUMBERP (CAR X)))
                   (PAIRED-COLORS (CDDR Z))),

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

          T.

  Case 1.2.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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))).

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

          T.

  Case 1.1.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP (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))).

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

          T.

Q.E.D.


[ 0.0 26.0 2.4 ]

MAIN


(PROVE-LEMMA F2
             (REWRITE)
             (IMPLIES (AND (PLISTP D) (PLISTP C))
                      (SHUFFLEP C D (APPEND C D))))


     Give the conjecture the name *1.


     We will appeal to induction.  There are three plausible inductions.  They
merge into two likely candidate inductions.  However, only one is unflawed.
We will induct according to the following scheme:
      (AND (IMPLIES (NLISTP C) (p C D))
           (IMPLIES (AND (NOT (NLISTP C)) (p (CDR C) D))
                    (p C D))).
Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of
NLISTP establish that the measure (COUNT C) decreases according to the
well-founded relation LESSP in each induction step of the scheme.  The above
induction scheme produces the following three new formulas:

Case 3. (IMPLIES (AND (NLISTP C) (PLISTP D) (PLISTP C))
                 (SHUFFLEP C D (APPEND C D))).

  This simplifies, opening up NLISTP, PLISTP, LISTP, APPEND, EQUAL, and
  SHUFFLEP, to:

        (IMPLIES (AND (NOT (LISTP C))
                      (PLISTP D)
                      (EQUAL C NIL)
                      (NOT (LISTP D)))
                 (EQUAL D NIL)),

  which again simplifies, expanding LISTP and PLISTP, to:

        T.

Case 2. (IMPLIES (AND (NOT (NLISTP C))
                      (NOT (PLISTP (CDR C)))
                      (PLISTP D)
                      (PLISTP C))
                 (SHUFFLEP C D (APPEND C D))),

  which simplifies, expanding the functions NLISTP and PLISTP, to:

        T.

Case 1. (IMPLIES (AND (NOT (NLISTP C))
                      (SHUFFLEP (CDR C)
                                D
                                (APPEND (CDR C) D))
                      (PLISTP D)
                      (PLISTP C))
                 (SHUFFLEP C D (APPEND C D))),

  which simplifies, applying CDR-CONS and CAR-CONS, and unfolding the
  functions NLISTP, PLISTP, APPEND, and SHUFFLEP, to the following two new
  conjectures:

  Case 1.2.
          (IMPLIES (AND (LISTP C)
                        (SHUFFLEP (CDR C)
                                  D
                                  (APPEND (CDR C) D))
                        (PLISTP D)
                        (PLISTP (CDR C))
                        (NOT (LISTP D)))
                   (EQUAL C
                          (CONS (CAR C) (APPEND (CDR C) D)))).

    However this again simplifies, appealing to the lemmas CAR-CONS, CDR-CONS,
    and CONS-CAR-CDR, and opening up SHUFFLEP, PLISTP, LISTP, and EQUAL, to:

          T.

  Case 1.1.
          (IMPLIES (AND (LISTP C)
                        (SHUFFLEP (CDR C)
                                  D
                                  (APPEND (CDR C) D))
                        (PLISTP D)
                        (PLISTP (CDR C))
                        (NOT (LISTP D)))
                   (EQUAL D NIL)),

    which again simplifies, opening up the function SHUFFLEP, to:

          T.


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


[ 0.0 0.0 0.0 ]

F2


(PROVE-LEMMA F3
             (REWRITE)
             (IMPLIES (AND (PLISTP D) (PLISTP C))
                      (SHUFFLEP C D (APPEND D C))))


     Give the conjecture the name *1.


     We will appeal to induction.  There are three plausible inductions.  They
merge into two likely candidate inductions.  However, only one is unflawed.
We will induct according to the following scheme:
      (AND (IMPLIES (NLISTP D) (p C D))
           (IMPLIES (AND (NOT (NLISTP D)) (p C (CDR D)))
                    (p C D))).
Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of
NLISTP establish that the measure (COUNT D) decreases according to the
well-founded relation LESSP in each induction step of the scheme.  The above
induction scheme produces the following three new formulas:

Case 3. (IMPLIES (AND (NLISTP D) (PLISTP D) (PLISTP C))
                 (SHUFFLEP C D (APPEND D C))).

  This simplifies, opening up NLISTP, PLISTP, LISTP, APPEND, EQUAL, and
  SHUFFLEP, to:

        (IMPLIES (AND (NOT (LISTP D))
                      (EQUAL D NIL)
                      (PLISTP C)
                      (NOT (LISTP C)))
                 (EQUAL C NIL)),

  which again simplifies, expanding LISTP and PLISTP, to:

        T.

Case 2. (IMPLIES (AND (NOT (NLISTP D))
                      (NOT (PLISTP (CDR D)))
                      (PLISTP D)
                      (PLISTP C))
                 (SHUFFLEP C D (APPEND D C))),

  which simplifies, expanding the functions NLISTP and PLISTP, to:

        T.

Case 1. (IMPLIES (AND (NOT (NLISTP D))
                      (SHUFFLEP C
                                (CDR D)
                                (APPEND (CDR D) C))
                      (PLISTP D)
                      (PLISTP C))
                 (SHUFFLEP C D (APPEND D C))),

  which simplifies, applying CDR-CONS and CAR-CONS, and unfolding the
  functions NLISTP, PLISTP, APPEND, and SHUFFLEP, to the following two new
  conjectures:

  Case 1.2.
          (IMPLIES (AND (LISTP D)
                        (SHUFFLEP C
                                  (CDR D)
                                  (APPEND (CDR D) C))
                        (PLISTP (CDR D))
                        (PLISTP C)
                        (NOT (LISTP C)))
                   (EQUAL D
                          (CONS (CAR D) (APPEND (CDR D) C)))).

    However this again simplifies, appealing to the lemmas CAR-CONS, CDR-CONS,
    and CONS-CAR-CDR, and opening up SHUFFLEP, PLISTP, LISTP, and EQUAL, to:

          T.

  Case 1.1.
          (IMPLIES (AND (LISTP D)
                        (SHUFFLEP C
                                  (CDR D)
                                  (APPEND (CDR D) C))
                        (PLISTP (CDR D))
                        (PLISTP C)
                        (NOT (LISTP C)))
                   (EQUAL C NIL)),

    which again simplifies, opening up the function SHUFFLEP, to:

          T.


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


[ 0.0 0.0 0.0 ]

F3


(PROVE-LEMMA CDR-APPEND
             (REWRITE)
             (EQUAL (CDR (APPEND C D))
                    (IF (LISTP C)
                        (APPEND (CDR C) D)
                        (CDR D))))

This simplifies, unfolding the function APPEND, to:

      (IMPLIES (LISTP C)
               (EQUAL (CDR (CONS (CAR C) (APPEND (CDR C) D)))
                      (APPEND (CDR C) D))),

which again simplifies, rewriting with the lemma CDR-CONS, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

CDR-APPEND


(PROVE-LEMMA F4
             (REWRITE)
             (IMPLIES (AND (PLISTP W) (SHUFFLEP X Y Z))
                      (SHUFFLEP X
                                (APPEND Y W)
                                (APPEND Z W))))


     Name the conjecture *1.


     We will try to prove it by induction.  Four inductions are suggested by
terms in the conjecture.  They merge into two likely candidate inductions.
However, only one is unflawed.  We will induct according to the following
scheme:
      (AND (IMPLIES (NLISTP Z) (p X Y W Z))
           (IMPLIES (AND (NOT (NLISTP Z)) (NLISTP X))
                    (p X Y W Z))
           (IMPLIES (AND (NOT (NLISTP Z))
                         (NOT (NLISTP X))
                         (NLISTP Y))
                    (p X Y W Z))
           (IMPLIES (AND (NOT (NLISTP Z))
                         (NOT (NLISTP X))
                         (NOT (NLISTP Y))
                         (p X (CDR Y) W (CDR Z))
                         (p (CDR X) Y W (CDR Z)))
                    (p X Y W Z))).
Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of
NLISTP establish that the measure (COUNT Z) decreases according to the
well-founded relation LESSP in each induction step of the scheme.  Note,
however, the inductive instances chosen for X and Y.  The above induction
scheme generates seven new conjectures:

Case 7. (IMPLIES (AND (NLISTP Z)
                      (PLISTP W)
                      (SHUFFLEP X Y Z))
                 (SHUFFLEP X
                           (APPEND Y W)
                           (APPEND Z W))),

  which simplifies, opening up NLISTP, SHUFFLEP, LISTP, APPEND, and EQUAL, to
  three new goals:

  Case 7.3.
          (IMPLIES (AND (NOT (LISTP Z))
                        (PLISTP W)
                        (EQUAL X NIL)
                        (EQUAL Y NIL)
                        (EQUAL Z NIL)
                        (NOT (LISTP W)))
                   (EQUAL W NIL)),

    which again simplifies, expanding the functions LISTP and PLISTP, to:

          T.

  Case 7.2.
          (IMPLIES (AND (NOT (LISTP Z))
                        (PLISTP W)
                        (EQUAL X NIL)
                        (EQUAL Y NIL)
                        (EQUAL Z NIL)
                        (NOT (LISTP W)))
                   (EQUAL (APPEND Y W) NIL)),

    which again simplifies, expanding the functions LISTP, PLISTP, APPEND, and
    EQUAL, to:

          T.

  Case 7.1.
          (IMPLIES (AND (NOT (LISTP Z))
                        (PLISTP W)
                        (EQUAL X NIL)
                        (EQUAL Y NIL)
                        (EQUAL Z NIL)
                        (LISTP W))
                   (EQUAL (APPEND Y W) W)),

    which again simplifies, unfolding the definitions of LISTP and APPEND, to:

          T.

Case 6. (IMPLIES (AND (NOT (NLISTP Z))
                      (NLISTP X)
                      (PLISTP W)
                      (SHUFFLEP X Y Z))
                 (SHUFFLEP X
                           (APPEND Y W)
                           (APPEND Z W))),

  which simplifies, unfolding the definitions of NLISTP, SHUFFLEP, APPEND,
  EQUAL, and LISTP, to two new formulas:

  Case 6.2.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP X))
                        (PLISTP W)
                        (EQUAL X NIL)
                        (EQUAL Y Z)
                        (PLISTP Y))
                   (EQUAL (APPEND Y W)
                          (CONS (CAR Y) (APPEND (CDR Y) W)))),

    which again simplifies, expanding the functions LISTP and APPEND, to:

          T.

  Case 6.1.
          (IMPLIES (AND (LISTP Z)
                        (NOT (LISTP X))
                        (PLISTP W)
                        (EQUAL X NIL)
                        (EQUAL Y Z)
                        (PLISTP Y))
                   (PLISTP (APPEND Y W))),

    which again simplifies, applying the lemma CDR-CONS, and unfolding the
    definitions of LISTP, APPEND, and PLISTP, to the formula:

          (IMPLIES (AND (LISTP Z) (PLISTP W) (PLISTP Z))
                   (PLISTP (APPEND (CDR Z) W))).

    Appealing to the lemma CAR-CDR-ELIM, we now replace Z by (CONS D V) to
    eliminate (CDR Z) and (CAR Z).  This generates:

          (IMPLIES (AND (PLISTP W) (PLISTP (CONS D V)))
                   (PLISTP (APPEND V W))).

    However this further simplifies, rewriting with CDR-CONS, and opening up
    PLISTP, to:

          (IMPLIES (AND (PLISTP W) (PLISTP V))
                   (PLISTP (APPEND V W))),

    which we will name *1.1.

Case 5. (IMPLIES (AND (NOT (NLISTP Z))
                      (NOT (NLISTP X))
                      (NLISTP Y)
                      (PLISTP W)
                      (SHUFFLEP X Y Z))
                 (SHUFFLEP X
                           (APPEND Y W)
                           (APPEND Z W))).

  This simplifies, unfolding the definitions of NLISTP and SHUFFLEP, to:

        (IMPLIES (AND (LISTP Z)
                      (LISTP X)
                      (NOT (LISTP Y))
                      (PLISTP W)
                      (EQUAL Y NIL)
                      (EQUAL X Z)
                      (PLISTP X))
                 (SHUFFLEP X
                           (APPEND Y W)
                           (APPEND X W))),

  which again simplifies, applying CDR-CONS and CAR-CONS, and opening up the
  functions LISTP, APPEND, and SHUFFLEP, to the following four new conjectures:

  Case 5.4.
          (IMPLIES (AND (LISTP Z)
                        (PLISTP W)
                        (PLISTP Z)
                        (NOT (LISTP W)))
                   (EQUAL Z
                          (CONS (CAR Z) (APPEND (CDR Z) W)))).

    However this again simplifies, rewriting with CAR-CONS and CDR-CONS, and
    expanding PLISTP and LISTP, to the new formula:

          (IMPLIES (AND (LISTP Z)
                        (EQUAL W NIL)
                        (PLISTP Z))
                   (EQUAL Z
                          (CONS (CAR Z) (APPEND (CDR Z) W)))),

    which again simplifies, appealing to the lemmas CAR-CONS and CDR-CONS, to:

          (IMPLIES (AND (LISTP Z) (PLISTP Z))
                   (EQUAL Z
                          (CONS (CAR Z) (APPEND (CDR Z) NIL)))).

    Appealing to the lemma CAR-CDR-ELIM, we now replace Z by (CONS V D) to
    eliminate (CAR Z) and (CDR Z).  This generates the formula:

          (IMPLIES (PLISTP (CONS V D))
                   (EQUAL (CONS V D)
                          (CONS V (APPEND D NIL)))).

    However this further simplifies, rewriting with the lemmas CDR-CONS,
    CAR-CONS, and CONS-EQUAL, and opening up the definition of PLISTP, to the
    formula:

          (IMPLIES (PLISTP D)
                   (EQUAL D (APPEND D NIL))).

    Finally name the above subgoal *1.2.

  Case 5.3.
          (IMPLIES (AND (LISTP Z)
                        (PLISTP W)
                        (PLISTP Z)
                        (NOT (LISTP W)))
                   (EQUAL W NIL)).

    This again simplifies, opening up PLISTP, to:

          T.

  Case 5.2.
          (IMPLIES (AND (LISTP Z)
                        (PLISTP W)
                        (PLISTP Z)
                        (LISTP W)
                        (NOT (SHUFFLEP (CDR Z)
                                       W
                                       (APPEND (CDR Z) W))))
                   (EQUAL (CAR W) (CAR Z))).

    Applying the lemma CAR-CDR-ELIM, replace Z by (CONS D V) to eliminate
    (CDR Z) and (CAR Z).  We would thus like to prove:

          (IMPLIES (AND (PLISTP W)
                        (PLISTP (CONS D V))
                        (LISTP W)
                        (NOT (SHUFFLEP V W (APPEND V W))))
                   (EQUAL (CAR W) D)),

    which further simplifies, applying CDR-CONS and F2, and expanding the
    function PLISTP, to:

          T.

  Case 5.1.
          (IMPLIES (AND (LISTP Z)
                        (PLISTP W)
                        (PLISTP Z)
                        (LISTP W)
                        (NOT (SHUFFLEP (CDR Z)
                                       W
                                       (APPEND (CDR Z) W))))
                   (SHUFFLEP Z
                             (CDR W)
                             (APPEND (CDR Z) W))).

    Appealing to the lemma CAR-CDR-ELIM, we now replace Z by (CONS D V) to
    eliminate (CDR Z) and (CAR Z).  This generates:

          (IMPLIES (AND (PLISTP W)
                        (PLISTP (CONS D V))
                        (LISTP W)
                        (NOT (SHUFFLEP V W (APPEND V W))))
                   (SHUFFLEP (CONS D V)
                             (CDR W)
                             (APPEND V W))).

    This further simplifies, appealing to the lemmas CDR-CONS and F2, and
    unfolding the function PLISTP, to:

          T.

Case 4. (IMPLIES (AND (NOT (NLISTP Z))
                      (NOT (NLISTP X))
                      (NOT (NLISTP Y))
                      (NOT (SHUFFLEP X (CDR Y) (CDR Z)))
                      (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                      (PLISTP W)
                      (SHUFFLEP X Y Z))
                 (SHUFFLEP X
                           (APPEND Y W)
                           (APPEND Z W))),

  which simplifies, opening up the functions NLISTP and SHUFFLEP, to:

        T.

Case 3. (IMPLIES (AND (NOT (NLISTP Z))
                      (NOT (NLISTP X))
                      (NOT (NLISTP Y))
                      (SHUFFLEP X
                                (APPEND (CDR Y) W)
                                (APPEND (CDR Z) W))
                      (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                      (PLISTP W)
                      (SHUFFLEP X Y Z))
                 (SHUFFLEP X
                           (APPEND Y W)
                           (APPEND Z W))),

  which simplifies, applying CDR-APPEND, CDR-CONS, and CAR-CONS, and expanding
  the definitions of NLISTP, SHUFFLEP, APPEND, and PLISTP, to the following
  nine new goals:

  Case 3.9.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP X
                                  (APPEND (CDR Y) W)
                                  (APPEND (CDR Z) W))
                        (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                        (PLISTP W)
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (SHUFFLEP X (CDR Y) (CDR Z))
                        (NOT (LISTP (APPEND Y W))))
                   (PLISTP (CDR X))).

    This again simplifies, clearly, to:

          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP X
                                  (APPEND (CDR Y) W)
                                  (APPEND (CDR Z) W))
                        (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                        (PLISTP W)
                        (NOT (EQUAL (CAR X) (CAR Y)))
                        (EQUAL (CAR Y) (CAR Z))
                        (SHUFFLEP X (CDR Y) (CDR Z))
                        (NOT (LISTP (APPEND Y W))))
                   (PLISTP (CDR X))),

    which further simplifies, unfolding the function APPEND, to:

          T.

  Case 3.8.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP X
                                  (APPEND (CDR Y) W)
                                  (APPEND (CDR Z) W))
                        (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                        (PLISTP W)
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (SHUFFLEP X (CDR Y) (CDR Z))
                        (NOT (LISTP (APPEND Y W))))
                   (EQUAL X
                          (CONS (CAR Y) (APPEND (CDR Z) W)))),

    which again simplifies, appealing to the lemma CAR-CONS, to:

          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP X
                                  (APPEND (CDR Y) W)
                                  (APPEND (CDR Z) W))
                        (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                        (PLISTP W)
                        (NOT (EQUAL (CAR X) (CAR Y)))
                        (EQUAL (CAR Y) (CAR Z))
                        (SHUFFLEP X (CDR Y) (CDR Z)))
                   (LISTP (APPEND Y W))).

    But this further simplifies, expanding the definition of APPEND, to:

          T.

  Case 3.7.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP X
                                  (APPEND (CDR Y) W)
                                  (APPEND (CDR Z) W))
                        (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                        (PLISTP W)
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (SHUFFLEP X (CDR Y) (CDR Z))
                        (NOT (LISTP (APPEND Y W))))
                   (EQUAL (APPEND Y W) NIL)),

    which again simplifies, clearly, to the new goal:

          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP X
                                  (APPEND (CDR Y) W)
                                  (APPEND (CDR Z) W))
                        (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                        (PLISTP W)
                        (NOT (EQUAL (CAR X) (CAR Y)))
                        (EQUAL (CAR Y) (CAR Z))
                        (SHUFFLEP X (CDR Y) (CDR Z))
                        (NOT (LISTP (APPEND Y W))))
                   (EQUAL (APPEND Y W) NIL)),

    which further simplifies, expanding the function APPEND, to:

          T.

  Case 3.6.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP X
                                  (APPEND (CDR Y) W)
                                  (APPEND (CDR Z) W))
                        (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                        (PLISTP W)
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (SHUFFLEP X (CDR Y) (CDR Z))
                        (LISTP (APPEND Y W))
                        (EQUAL (CAR X) (CAR Y))
                        (NOT (SHUFFLEP (CDR X)
                                       (APPEND Y W)
                                       (APPEND (CDR Z) W))))
                   (EQUAL (CAR (APPEND Y W)) (CAR X))),

    which again simplifies, trivially, to:

          T.

  Case 3.5.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP X
                                  (APPEND (CDR Y) W)
                                  (APPEND (CDR Z) W))
                        (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                        (PLISTP W)
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (SHUFFLEP X (CDR Y) (CDR Z))
                        (LISTP (APPEND Y W))
                        (NOT (EQUAL (CAR X) (CAR Y))))
                   (EQUAL (CAR (APPEND Y W)) (CAR Y))).

    This again simplifies, obviously, to the new conjecture:

          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP X
                                  (APPEND (CDR Y) W)
                                  (APPEND (CDR Z) W))
                        (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                        (PLISTP W)
                        (EQUAL (CAR Y) (CAR Z))
                        (SHUFFLEP X (CDR Y) (CDR Z))
                        (LISTP (APPEND Y W))
                        (NOT (EQUAL (CAR X) (CAR Y))))
                   (EQUAL (CAR (APPEND Y W)) (CAR Y))),

    which further simplifies, applying CAR-CONS, and unfolding APPEND, to:

          T.

  Case 3.4.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP X
                                  (APPEND (CDR Y) W)
                                  (APPEND (CDR Z) W))
                        (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                        (PLISTP W)
                        (EQUAL (CAR X) (CAR Z))
                        (EQUAL (CAR Y) (CAR X))
                        (SHUFFLEP X (CDR Y) (CDR Z))
                        (NOT (LISTP (APPEND Y W))))
                   (PLISTP (CDR X))).

    However this further simplifies, unfolding the function APPEND, to:

          T.

  Case 3.3.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP X
                                  (APPEND (CDR Y) W)
                                  (APPEND (CDR Z) W))
                        (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                        (PLISTP W)
                        (EQUAL (CAR X) (CAR Z))
                        (EQUAL (CAR Y) (CAR X))
                        (SHUFFLEP X (CDR Y) (CDR Z))
                        (NOT (LISTP (APPEND Y W))))
                   (EQUAL X
                          (CONS (CAR X) (APPEND (CDR Z) W)))),

    which further simplifies, opening up APPEND, to:

          T.

  Case 3.2.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP X
                                  (APPEND (CDR Y) W)
                                  (APPEND (CDR Z) W))
                        (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                        (PLISTP W)
                        (EQUAL (CAR X) (CAR Z))
                        (EQUAL (CAR Y) (CAR X))
                        (SHUFFLEP X (CDR Y) (CDR Z))
                        (NOT (LISTP (APPEND Y W))))
                   (EQUAL (APPEND Y W) NIL)),

    which further simplifies, unfolding the function APPEND, to:

          T.

  Case 3.1.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP X
                                  (APPEND (CDR Y) W)
                                  (APPEND (CDR Z) W))
                        (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                        (PLISTP W)
                        (EQUAL (CAR X) (CAR Z))
                        (EQUAL (CAR Y) (CAR X))
                        (SHUFFLEP X (CDR Y) (CDR Z))
                        (LISTP (APPEND Y W))
                        (NOT (SHUFFLEP (CDR X)
                                       (APPEND Y W)
                                       (APPEND (CDR Z) W))))
                   (EQUAL (CAR (APPEND Y W)) (CAR X))),

    which further simplifies, applying CAR-CONS, and unfolding APPEND, to:

          T.

Case 2. (IMPLIES (AND (NOT (NLISTP Z))
                      (NOT (NLISTP X))
                      (NOT (NLISTP Y))
                      (NOT (SHUFFLEP X (CDR Y) (CDR Z)))
                      (SHUFFLEP (CDR X)
                                (APPEND Y W)
                                (APPEND (CDR Z) W))
                      (PLISTP W)
                      (SHUFFLEP X Y Z))
                 (SHUFFLEP X
                           (APPEND Y W)
                           (APPEND Z W))).

  This simplifies, applying CDR-CONS and CAR-CONS, and expanding the functions
  NLISTP, SHUFFLEP, APPEND, and PLISTP, to three new formulas:

  Case 2.3.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (NOT (SHUFFLEP X (CDR Y) (CDR Z)))
                        (SHUFFLEP (CDR X)
                                  (APPEND Y W)
                                  (APPEND (CDR Z) W))
                        (PLISTP W)
                        (EQUAL (CAR X) (CAR Z))
                        (SHUFFLEP (CDR X) Y (CDR Z))
                        (NOT (LISTP (APPEND Y W))))
                   (PLISTP (CDR X))),

    which again simplifies, expanding SHUFFLEP, LISTP, and PLISTP, to:

          T.

  Case 2.2.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (NOT (SHUFFLEP X (CDR Y) (CDR Z)))
                        (SHUFFLEP (CDR X)
                                  (APPEND Y W)
                                  (APPEND (CDR Z) W))
                        (PLISTP W)
                        (EQUAL (CAR X) (CAR Z))
                        (SHUFFLEP (CDR X) Y (CDR Z))
                        (NOT (LISTP (APPEND Y W))))
                   (EQUAL X
                          (CONS (CAR X) (APPEND (CDR Z) W)))),

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

          T.

  Case 2.1.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (NOT (SHUFFLEP X (CDR Y) (CDR Z)))
                        (SHUFFLEP (CDR X)
                                  (APPEND Y W)
                                  (APPEND (CDR Z) W))
                        (PLISTP W)
                        (EQUAL (CAR X) (CAR Z))
                        (SHUFFLEP (CDR X) Y (CDR Z))
                        (NOT (LISTP (APPEND Y W))))
                   (EQUAL (APPEND Y W) NIL)),

    which again simplifies, expanding SHUFFLEP, to:

          T.

Case 1. (IMPLIES (AND (NOT (NLISTP Z))
                      (NOT (NLISTP X))
                      (NOT (NLISTP Y))
                      (SHUFFLEP X
                                (APPEND (CDR Y) W)
                                (APPEND (CDR Z) W))
                      (SHUFFLEP (CDR X)
                                (APPEND Y W)
                                (APPEND (CDR Z) W))
                      (PLISTP W)
                      (SHUFFLEP X Y Z))
                 (SHUFFLEP X
                           (APPEND Y W)
                           (APPEND Z W))),

  which simplifies, applying CDR-APPEND, CDR-CONS, and CAR-CONS, and opening
  up the definitions of NLISTP, SHUFFLEP, APPEND, and PLISTP, to the following
  ten new conjectures:

  Case 1.10.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP X
                                  (APPEND (CDR Y) W)
                                  (APPEND (CDR Z) W))
                        (SHUFFLEP (CDR X)
                                  (APPEND Y W)
                                  (APPEND (CDR Z) W))
                        (PLISTP W)
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (SHUFFLEP X (CDR Y) (CDR Z))
                        (NOT (LISTP (APPEND Y W))))
                   (PLISTP (CDR X))).

    This again simplifies, unfolding the functions SHUFFLEP, LISTP, and PLISTP,
    to:

          T.

  Case 1.9.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP X
                                  (APPEND (CDR Y) W)
                                  (APPEND (CDR Z) W))
                        (SHUFFLEP (CDR X)
                                  (APPEND Y W)
                                  (APPEND (CDR Z) W))
                        (PLISTP W)
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (SHUFFLEP X (CDR Y) (CDR Z))
                        (NOT (LISTP (APPEND Y W))))
                   (EQUAL X
                          (CONS (CAR Y) (APPEND (CDR Z) W)))),

    which again simplifies, applying CAR-CONS, and unfolding the functions
    SHUFFLEP and LISTP, to the following two new goals:

    Case 1.9.2.
            (IMPLIES (AND (LISTP Z)
                          (LISTP X)
                          (LISTP Y)
                          (SHUFFLEP X
                                    (APPEND (CDR Y) W)
                                    (APPEND (CDR Z) W))
                          (NOT (LISTP (APPEND (CDR Z) W)))
                          (EQUAL (CDR X) NIL)
                          (EQUAL (APPEND Y W) NIL)
                          (EQUAL (APPEND (CDR Z) W) NIL)
                          (PLISTP W)
                          (NOT (EQUAL (CAR X) (CAR Y)))
                          (EQUAL (CAR Y) (CAR Z)))
                     (NOT (SHUFFLEP X (CDR Y) (CDR Z)))).

      However this again simplifies, unfolding LISTP and SHUFFLEP, to:

            T.

    Case 1.9.1.
            (IMPLIES (AND (LISTP Z)
                          (LISTP X)
                          (LISTP Y)
                          (SHUFFLEP X
                                    (APPEND (CDR Y) W)
                                    (APPEND (CDR Z) W))
                          (LISTP (APPEND (CDR Z) W))
                          (LISTP (CDR X))
                          (EQUAL (APPEND Y W) NIL)
                          (EQUAL (CDR X) (APPEND (CDR Z) W))
                          (PLISTP (CDR X))
                          (PLISTP W)
                          (NOT (EQUAL (CAR X) (CAR Y)))
                          (EQUAL (CAR Y) (CAR Z)))
                     (NOT (SHUFFLEP X (CDR Y) (CDR Z)))),

      which again simplifies, clearly, to the new conjecture:

            (IMPLIES (AND (LISTP Z)
                          (LISTP X)
                          (LISTP Y)
                          (SHUFFLEP X
                                    (APPEND (CDR Y) W)
                                    (CDR X))
                          (LISTP (CDR X))
                          (EQUAL (APPEND Y W) NIL)
                          (EQUAL (CDR X) (APPEND (CDR Z) W))
                          (PLISTP (CDR X))
                          (PLISTP W)
                          (NOT (EQUAL (CAR X) (CAR Y)))
                          (EQUAL (CAR Y) (CAR Z)))
                     (NOT (SHUFFLEP X (CDR Y) (CDR Z)))),

      which further simplifies, unfolding the definition of APPEND, to:

            T.

  Case 1.8.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP X
                                  (APPEND (CDR Y) W)
                                  (APPEND (CDR Z) W))
                        (SHUFFLEP (CDR X)
                                  (APPEND Y W)
                                  (APPEND (CDR Z) W))
                        (PLISTP W)
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (SHUFFLEP X (CDR Y) (CDR Z))
                        (NOT (LISTP (APPEND Y W))))
                   (EQUAL (APPEND Y W) NIL)),

    which again simplifies, expanding SHUFFLEP, to:

          T.

  Case 1.7.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP X
                                  (APPEND (CDR Y) W)
                                  (APPEND (CDR Z) W))
                        (SHUFFLEP (CDR X)
                                  (APPEND Y W)
                                  (APPEND (CDR Z) W))
                        (PLISTP W)
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (SHUFFLEP X (CDR Y) (CDR Z))
                        (LISTP (APPEND Y W))
                        (NOT (EQUAL (CAR X) (CAR Y))))
                   (EQUAL (CAR (APPEND Y W)) (CAR Y))),

    which again simplifies, clearly, to:

          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP X
                                  (APPEND (CDR Y) W)
                                  (APPEND (CDR Z) W))
                        (SHUFFLEP (CDR X)
                                  (APPEND Y W)
                                  (APPEND (CDR Z) W))
                        (PLISTP W)
                        (EQUAL (CAR Y) (CAR Z))
                        (SHUFFLEP X (CDR Y) (CDR Z))
                        (LISTP (APPEND Y W))
                        (NOT (EQUAL (CAR X) (CAR Y))))
                   (EQUAL (CAR (APPEND Y W)) (CAR Y))),

    which further simplifies, applying CAR-CONS, and unfolding the definition
    of APPEND, to:

          T.

  Case 1.6.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP X
                                  (APPEND (CDR Y) W)
                                  (APPEND (CDR Z) W))
                        (SHUFFLEP (CDR X)
                                  (APPEND Y W)
                                  (APPEND (CDR Z) W))
                        (PLISTP W)
                        (EQUAL (CAR X) (CAR Z))
                        (EQUAL (CAR Y) (CAR X))
                        (SHUFFLEP X (CDR Y) (CDR Z))
                        (NOT (LISTP (APPEND Y W))))
                   (PLISTP (CDR X))).

    This again simplifies, opening up SHUFFLEP, LISTP, and PLISTP, to:

          T.

  Case 1.5.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP X
                                  (APPEND (CDR Y) W)
                                  (APPEND (CDR Z) W))
                        (SHUFFLEP (CDR X)
                                  (APPEND Y W)
                                  (APPEND (CDR Z) W))
                        (PLISTP W)
                        (EQUAL (CAR X) (CAR Z))
                        (EQUAL (CAR Y) (CAR X))
                        (SHUFFLEP X (CDR Y) (CDR Z))
                        (NOT (LISTP (APPEND Y W))))
                   (EQUAL X
                          (CONS (CAR X) (APPEND (CDR Z) W)))),

    which again simplifies, rewriting with CAR-CONS, CDR-CONS, and
    CONS-CAR-CDR, and unfolding the functions SHUFFLEP, LISTP, and EQUAL, to:

          T.

  Case 1.4.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP X
                                  (APPEND (CDR Y) W)
                                  (APPEND (CDR Z) W))
                        (SHUFFLEP (CDR X)
                                  (APPEND Y W)
                                  (APPEND (CDR Z) W))
                        (PLISTP W)
                        (EQUAL (CAR X) (CAR Z))
                        (EQUAL (CAR Y) (CAR X))
                        (SHUFFLEP X (CDR Y) (CDR Z))
                        (NOT (LISTP (APPEND Y W))))
                   (EQUAL (APPEND Y W) NIL)).

    However this again simplifies, expanding the function SHUFFLEP, to:

          T.

  Case 1.3.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP X
                                  (APPEND (CDR Y) W)
                                  (APPEND (CDR Z) W))
                        (SHUFFLEP (CDR X)
                                  (APPEND Y W)
                                  (APPEND (CDR Z) W))
                        (PLISTP W)
                        (EQUAL (CAR X) (CAR Z))
                        (SHUFFLEP (CDR X) Y (CDR Z))
                        (NOT (LISTP (APPEND Y W))))
                   (PLISTP (CDR X))),

    which again simplifies, expanding SHUFFLEP, LISTP, and PLISTP, to:

          T.

  Case 1.2.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP X
                                  (APPEND (CDR Y) W)
                                  (APPEND (CDR Z) W))
                        (SHUFFLEP (CDR X)
                                  (APPEND Y W)
                                  (APPEND (CDR Z) W))
                        (PLISTP W)
                        (EQUAL (CAR X) (CAR Z))
                        (SHUFFLEP (CDR X) Y (CDR Z))
                        (NOT (LISTP (APPEND Y W))))
                   (EQUAL X
                          (CONS (CAR X) (APPEND (CDR Z) W)))),

    which again simplifies, rewriting with the lemmas CAR-CONS, CDR-CONS, and
    CONS-CAR-CDR, and unfolding the functions SHUFFLEP, LISTP, and EQUAL, to:

          T.

  Case 1.1.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP X
                                  (APPEND (CDR Y) W)
                                  (APPEND (CDR Z) W))
                        (SHUFFLEP (CDR X)
                                  (APPEND Y W)
                                  (APPEND (CDR Z) W))
                        (PLISTP W)
                        (EQUAL (CAR X) (CAR Z))
                        (SHUFFLEP (CDR X) Y (CDR Z))
                        (NOT (LISTP (APPEND Y W))))
                   (EQUAL (APPEND Y W) NIL)),

    which again simplifies, expanding the definition of SHUFFLEP, to:

          T.


     So we now return to:

      (IMPLIES (PLISTP D)
               (EQUAL D (APPEND D NIL))),

which is formula *1.2 above.  We will try to prove it by induction.  Two
inductions are suggested by terms in the conjecture.  However, they merge into
one likely candidate induction.  We will induct according to the following
scheme:
      (AND (IMPLIES (NLISTP D) (p D))
           (IMPLIES (AND (NOT (NLISTP D)) (p (CDR D)))
                    (p D))).
Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of
NLISTP can be used to show that the measure (COUNT D) decreases according to
the well-founded relation LESSP in each induction step of the scheme.  The
above induction scheme produces the following three new conjectures:

Case 3. (IMPLIES (AND (NLISTP D) (PLISTP D))
                 (EQUAL D (APPEND D NIL))).

  This simplifies, unfolding NLISTP, PLISTP, APPEND, and EQUAL, to:

        T.

Case 2. (IMPLIES (AND (NOT (NLISTP D))
                      (NOT (PLISTP (CDR D)))
                      (PLISTP D))
                 (EQUAL D (APPEND D NIL))).

  This simplifies, expanding the functions NLISTP and PLISTP, to:

        T.

Case 1. (IMPLIES (AND (NOT (NLISTP D))
                      (EQUAL (CDR D) (APPEND (CDR D) NIL))
                      (PLISTP D))
                 (EQUAL D (APPEND D NIL))).

  This simplifies, rewriting with CONS-CAR-CDR, and opening up the functions
  NLISTP, PLISTP, and APPEND, to:

        T.


     That finishes the proof of *1.2.


     So next consider:

      (IMPLIES (AND (PLISTP W) (PLISTP V))
               (PLISTP (APPEND V W))),

which is formula *1.1 above.  Let us appeal to the induction principle.  The
recursive terms in the conjecture suggest three inductions.  They merge into
two likely candidate inductions.  However, only one is unflawed.  We will
induct according to the following scheme:
      (AND (IMPLIES (NLISTP V) (p V W))
           (IMPLIES (AND (NOT (NLISTP V)) (p (CDR V) W))
                    (p V W))).
Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of
NLISTP establish that the measure (COUNT V) decreases according to the
well-founded relation LESSP in each induction step of the scheme.  The above
induction scheme generates three new goals:

Case 3. (IMPLIES (AND (NLISTP V) (PLISTP W) (PLISTP V))
                 (PLISTP (APPEND V W))),

  which simplifies, unfolding the functions NLISTP, PLISTP, LISTP, and APPEND,
  to:

        T.

Case 2. (IMPLIES (AND (NOT (NLISTP V))
                      (NOT (PLISTP (CDR V)))
                      (PLISTP W)
                      (PLISTP V))
                 (PLISTP (APPEND V W))),

  which simplifies, unfolding the functions NLISTP and PLISTP, to:

        T.

Case 1. (IMPLIES (AND (NOT (NLISTP V))
                      (PLISTP (APPEND (CDR V) W))
                      (PLISTP W)
                      (PLISTP V))
                 (PLISTP (APPEND V W))),

  which simplifies, rewriting with CDR-CONS, and unfolding the functions
  NLISTP, PLISTP, and APPEND, to:

        T.


     That finishes the proof of *1.1, which also finishes the proof of *1.
Q.E.D.


[ 0.0 0.3 0.1 ]

F4


(PROVE-LEMMA F5
             (REWRITE)
             (IMPLIES (AND (PLISTP W) (SHUFFLEP X Y Z))
                      (SHUFFLEP (APPEND X W)
                                Y
                                (APPEND Z W))))


     Name the conjecture *1.


     We will try to prove it by induction.  Four inductions are suggested by
terms in the conjecture.  They merge into two likely candidate inductions.
However, only one is unflawed.  We will induct according to the following
scheme:
      (AND (IMPLIES (NLISTP Z) (p X W Y Z))
           (IMPLIES (AND (NOT (NLISTP Z)) (NLISTP X))
                    (p X W Y Z))
           (IMPLIES (AND (NOT (NLISTP Z))
                         (NOT (NLISTP X))
                         (NLISTP Y))
                    (p X W Y Z))
           (IMPLIES (AND (NOT (NLISTP Z))
                         (NOT (NLISTP X))
                         (NOT (NLISTP Y))
                         (p X W (CDR Y) (CDR Z))
                         (p (CDR X) W Y (CDR Z)))
                    (p X W Y Z))).
Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of
NLISTP establish that the measure (COUNT Z) decreases according to the
well-founded relation LESSP in each induction step of the scheme.  Note,
however, the inductive instances chosen for X and Y.  The above induction
scheme generates seven new conjectures:

Case 7. (IMPLIES (AND (NLISTP Z)
                      (PLISTP W)
                      (SHUFFLEP X Y Z))
                 (SHUFFLEP (APPEND X W)
                           Y
                           (APPEND Z W))),

  which simplifies, opening up NLISTP, SHUFFLEP, LISTP, APPEND, and EQUAL, to
  three new goals:

  Case 7.3.
          (IMPLIES (AND (NOT (LISTP Z))
                        (PLISTP W)
                        (EQUAL X NIL)
                        (EQUAL Y NIL)
                        (EQUAL Z NIL)
                        (NOT (LISTP W)))
                   (EQUAL W NIL)),

    which again simplifies, expanding the functions LISTP and PLISTP, to:

          T.

  Case 7.2.
          (IMPLIES (AND (NOT (LISTP Z))
                        (PLISTP W)
                        (EQUAL X NIL)
                        (EQUAL Y NIL)
                        (EQUAL Z NIL)
                        (NOT (LISTP W)))
                   (EQUAL (APPEND X W) NIL)),

    which again simplifies, expanding the functions LISTP, PLISTP, APPEND, and
    EQUAL, to:

          T.

  Case 7.1.
          (IMPLIES (AND (NOT (LISTP Z))
                        (PLISTP W)
                        (EQUAL X NIL)
                        (EQUAL Y NIL)
                        (EQUAL Z NIL)
                        (LISTP W))
                   (EQUAL (APPEND X W) W)),

    which again simplifies, unfolding the definitions of LISTP and APPEND, to:

          T.

Case 6. (IMPLIES (AND (NOT (NLISTP Z))
                      (NLISTP X)
                      (PLISTP W)
                      (SHUFFLEP X Y Z))
                 (SHUFFLEP (APPEND X W)
                           Y
                           (APPEND Z W))),

  which simplifies, unfolding the definitions of NLISTP and SHUFFLEP, to the
  conjecture:

        (IMPLIES (AND (LISTP Z)
                      (NOT (LISTP X))
                      (PLISTP W)
                      (EQUAL X NIL)
                      (EQUAL Y Z)
                      (PLISTP Y))
                 (SHUFFLEP (APPEND X W)
                           Y
                           (APPEND Y W))).

  This again simplifies, applying CDR-CONS and CAR-CONS, and unfolding the
  functions LISTP, APPEND, and SHUFFLEP, to the following four new formulas:

  Case 6.4.
          (IMPLIES (AND (LISTP Z)
                        (PLISTP W)
                        (PLISTP Z)
                        (NOT (LISTP W)))
                   (EQUAL Z
                          (CONS (CAR Z) (APPEND (CDR Z) W)))).

    But this again simplifies, rewriting with CAR-CONS and CDR-CONS, and
    unfolding PLISTP and LISTP, to the new formula:

          (IMPLIES (AND (LISTP Z)
                        (EQUAL W NIL)
                        (PLISTP Z))
                   (EQUAL Z
                          (CONS (CAR Z) (APPEND (CDR Z) W)))),

    which again simplifies, rewriting with CAR-CONS and CDR-CONS, to the new
    conjecture:

          (IMPLIES (AND (LISTP Z) (PLISTP Z))
                   (EQUAL Z
                          (CONS (CAR Z) (APPEND (CDR Z) NIL)))).

    Applying the lemma CAR-CDR-ELIM, replace Z by (CONS V D) to eliminate
    (CAR Z) and (CDR Z).  We would thus like to prove:

          (IMPLIES (PLISTP (CONS V D))
                   (EQUAL (CONS V D)
                          (CONS V (APPEND D NIL)))),

    which further simplifies, rewriting with CDR-CONS, CAR-CONS, and
    CONS-EQUAL, and expanding the definition of PLISTP, to the new conjecture:

          (IMPLIES (PLISTP D)
                   (EQUAL D (APPEND D NIL))),

    which we will finally name *1.1.

  Case 6.3.
          (IMPLIES (AND (LISTP Z)
                        (PLISTP W)
                        (PLISTP Z)
                        (NOT (LISTP W)))
                   (EQUAL W NIL)).

    However this again simplifies, unfolding the definition of PLISTP, to:

          T.

  Case 6.2.
          (IMPLIES (AND (LISTP Z)
                        (PLISTP W)
                        (PLISTP Z)
                        (LISTP W)
                        (NOT (EQUAL (CAR W) (CAR Z))))
                   (SHUFFLEP W
                             (CDR Z)
                             (APPEND (CDR Z) W))).

    Applying the lemma CAR-CDR-ELIM, replace W by (CONS V D) to eliminate
    (CAR W) and (CDR W).  We thus obtain:

          (IMPLIES (AND (LISTP Z)
                        (PLISTP (CONS V D))
                        (PLISTP Z)
                        (NOT (EQUAL V (CAR Z))))
                   (SHUFFLEP (CONS V D)
                             (CDR Z)
                             (APPEND (CDR Z) (CONS V D)))),

    which further simplifies, appealing to the lemma CDR-CONS, and unfolding
    PLISTP, to:

          (IMPLIES (AND (LISTP Z)
                        (PLISTP D)
                        (PLISTP Z)
                        (NOT (EQUAL V (CAR Z))))
                   (SHUFFLEP (CONS V D)
                             (CDR Z)
                             (APPEND (CDR Z) (CONS V D)))).

    Appealing to the lemma CAR-CDR-ELIM, we now replace Z by (CONS C X1) to
    eliminate (CAR Z) and (CDR Z).  This generates:

          (IMPLIES (AND (PLISTP D)
                        (PLISTP (CONS C X1))
                        (NOT (EQUAL V C)))
                   (SHUFFLEP (CONS V D)
                             X1
                             (APPEND X1 (CONS V D)))).

    However this finally simplifies, rewriting with the lemmas CDR-CONS and F3,
    and opening up the definition of PLISTP, to:

          T.

  Case 6.1.
          (IMPLIES (AND (LISTP Z)
                        (PLISTP W)
                        (PLISTP Z)
                        (LISTP W)
                        (NOT (SHUFFLEP (CDR W)
                                       Z
                                       (APPEND (CDR Z) W))))
                   (SHUFFLEP W
                             (CDR Z)
                             (APPEND (CDR Z) W))).

    Applying the lemma CAR-CDR-ELIM, replace W by (CONS D V) to eliminate
    (CDR W) and (CAR W).  This produces the new goal:

          (IMPLIES (AND (LISTP Z)
                        (PLISTP (CONS D V))
                        (PLISTP Z)
                        (NOT (SHUFFLEP V Z
                                       (APPEND (CDR Z) (CONS D V)))))
                   (SHUFFLEP (CONS D V)
                             (CDR Z)
                             (APPEND (CDR Z) (CONS D V)))),

    which further simplifies, rewriting with the lemma CDR-CONS, and unfolding
    PLISTP, to:

          (IMPLIES (AND (LISTP Z)
                        (PLISTP V)
                        (PLISTP Z)
                        (NOT (SHUFFLEP V Z
                                       (APPEND (CDR Z) (CONS D V)))))
                   (SHUFFLEP (CONS D V)
                             (CDR Z)
                             (APPEND (CDR Z) (CONS D V)))).

    Appealing to the lemma CAR-CDR-ELIM, we now replace Z by (CONS X1 C) to
    eliminate (CDR Z) and (CAR Z).  We must thus prove:

          (IMPLIES (AND (PLISTP V)
                        (PLISTP (CONS X1 C))
                        (NOT (SHUFFLEP V
                                       (CONS X1 C)
                                       (APPEND C (CONS D V)))))
                   (SHUFFLEP (CONS D V)
                             C
                             (APPEND C (CONS D V)))).

    But this finally simplifies, rewriting with CDR-CONS and F3, and opening
    up the definition of PLISTP, to:

          T.

Case 5. (IMPLIES (AND (NOT (NLISTP Z))
                      (NOT (NLISTP X))
                      (NLISTP Y)
                      (PLISTP W)
                      (SHUFFLEP X Y Z))
                 (SHUFFLEP (APPEND X W)
                           Y
                           (APPEND Z W))).

  This simplifies, rewriting with CAR-CONS, and opening up the functions
  NLISTP, SHUFFLEP, APPEND, EQUAL, and LISTP, to three new goals:

  Case 5.3.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (NOT (LISTP Y))
                        (PLISTP W)
                        (EQUAL Y NIL)
                        (EQUAL X Z)
                        (PLISTP X))
                   (LISTP (APPEND X W))),

    which again simplifies, opening up the functions LISTP and APPEND, to:

          T.

  Case 5.2.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (NOT (LISTP Y))
                        (PLISTP W)
                        (EQUAL Y NIL)
                        (EQUAL X Z)
                        (PLISTP X))
                   (EQUAL (APPEND X W)
                          (CONS (CAR X) (APPEND (CDR X) W)))),

    which again simplifies, expanding the definitions of LISTP and APPEND, to:

          T.

  Case 5.1.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (NOT (LISTP Y))
                        (PLISTP W)
                        (EQUAL Y NIL)
                        (EQUAL X Z)
                        (PLISTP X))
                   (PLISTP (APPEND X W))),

    which again simplifies, rewriting with the lemma CDR-CONS, and unfolding
    LISTP, APPEND, and PLISTP, to:

          (IMPLIES (AND (LISTP Z) (PLISTP W) (PLISTP Z))
                   (PLISTP (APPEND (CDR Z) W))).

    Appealing to the lemma CAR-CDR-ELIM, we now replace Z by (CONS D V) to
    eliminate (CDR Z) and (CAR Z).  This generates:

          (IMPLIES (AND (PLISTP W) (PLISTP (CONS D V)))
                   (PLISTP (APPEND V W))).

    But this further simplifies, appealing to the lemma CDR-CONS, and
    unfolding the definition of PLISTP, to the conjecture:

          (IMPLIES (AND (PLISTP W) (PLISTP V))
                   (PLISTP (APPEND V W))).

    Name the above subgoal *1.2.

Case 4. (IMPLIES (AND (NOT (NLISTP Z))
                      (NOT (NLISTP X))
                      (NOT (NLISTP Y))
                      (NOT (SHUFFLEP X (CDR Y) (CDR Z)))
                      (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                      (PLISTP W)
                      (SHUFFLEP X Y Z))
                 (SHUFFLEP (APPEND X W)
                           Y
                           (APPEND Z W))).

  This simplifies, opening up NLISTP and SHUFFLEP, to:

        T.

Case 3. (IMPLIES (AND (NOT (NLISTP Z))
                      (NOT (NLISTP X))
                      (NOT (NLISTP Y))
                      (SHUFFLEP (APPEND X W)
                                (CDR Y)
                                (APPEND (CDR Z) W))
                      (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                      (PLISTP W)
                      (SHUFFLEP X Y Z))
                 (SHUFFLEP (APPEND X W)
                           Y
                           (APPEND Z W))).

  This simplifies, applying the lemmas CDR-CONS, CDR-APPEND, and CAR-CONS, and
  opening up the functions NLISTP, SHUFFLEP, APPEND, and PLISTP, to the
  following six new goals:

  Case 3.6.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP (APPEND X W)
                                  (CDR Y)
                                  (APPEND (CDR Z) W))
                        (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                        (PLISTP W)
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (SHUFFLEP X (CDR Y) (CDR Z))
                        (NOT (LISTP (APPEND X W))))
                   (PLISTP (CDR Y))).

    However this again simplifies, unfolding the functions SHUFFLEP, LISTP,
    and PLISTP, to:

          T.

  Case 3.5.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP (APPEND X W)
                                  (CDR Y)
                                  (APPEND (CDR Z) W))
                        (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                        (PLISTP W)
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (SHUFFLEP X (CDR Y) (CDR Z))
                        (NOT (LISTP (APPEND X W))))
                   (EQUAL Y
                          (CONS (CAR Y) (APPEND (CDR Z) W)))),

    which again simplifies, applying the lemmas CAR-CONS, CDR-CONS, and
    CONS-CAR-CDR, and expanding SHUFFLEP, LISTP, and EQUAL, to:

          T.

  Case 3.4.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP (APPEND X W)
                                  (CDR Y)
                                  (APPEND (CDR Z) W))
                        (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                        (PLISTP W)
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (SHUFFLEP X (CDR Y) (CDR Z))
                        (NOT (LISTP (APPEND X W))))
                   (EQUAL (APPEND X W) NIL)),

    which again simplifies, unfolding SHUFFLEP, to:

          T.

  Case 3.3.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP (APPEND X W)
                                  (CDR Y)
                                  (APPEND (CDR Z) W))
                        (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                        (PLISTP W)
                        (EQUAL (CAR X) (CAR Z))
                        (EQUAL (CAR Y) (CAR X))
                        (SHUFFLEP X (CDR Y) (CDR Z))
                        (NOT (LISTP (APPEND X W))))
                   (PLISTP (CDR Y))),

    which again simplifies, opening up SHUFFLEP, LISTP, and PLISTP, to:

          T.

  Case 3.2.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP (APPEND X W)
                                  (CDR Y)
                                  (APPEND (CDR Z) W))
                        (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                        (PLISTP W)
                        (EQUAL (CAR X) (CAR Z))
                        (EQUAL (CAR Y) (CAR X))
                        (SHUFFLEP X (CDR Y) (CDR Z))
                        (NOT (LISTP (APPEND X W))))
                   (EQUAL Y
                          (CONS (CAR X) (APPEND (CDR Z) W)))),

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

          T.

  Case 3.1.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP (APPEND X W)
                                  (CDR Y)
                                  (APPEND (CDR Z) W))
                        (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                        (PLISTP W)
                        (EQUAL (CAR X) (CAR Z))
                        (EQUAL (CAR Y) (CAR X))
                        (SHUFFLEP X (CDR Y) (CDR Z))
                        (NOT (LISTP (APPEND X W))))
                   (EQUAL (APPEND X W) NIL)).

    However this again simplifies, expanding SHUFFLEP, to:

          T.

Case 2. (IMPLIES (AND (NOT (NLISTP Z))
                      (NOT (NLISTP X))
                      (NOT (NLISTP Y))
                      (NOT (SHUFFLEP X (CDR Y) (CDR Z)))
                      (SHUFFLEP (APPEND (CDR X) W)
                                Y
                                (APPEND (CDR Z) W))
                      (PLISTP W)
                      (SHUFFLEP X Y Z))
                 (SHUFFLEP (APPEND X W)
                           Y
                           (APPEND Z W))),

  which simplifies, applying CDR-CONS, CDR-APPEND, and CAR-CONS, and expanding
  the definitions of NLISTP, SHUFFLEP, APPEND, and PLISTP, to the following
  five new goals:

  Case 2.5.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (NOT (SHUFFLEP X (CDR Y) (CDR Z)))
                        (SHUFFLEP (APPEND (CDR X) W)
                                  Y
                                  (APPEND (CDR Z) W))
                        (PLISTP W)
                        (EQUAL (CAR X) (CAR Z))
                        (SHUFFLEP (CDR X) Y (CDR Z))
                        (NOT (LISTP (APPEND X W))))
                   (PLISTP (CDR Y))).

    But this further simplifies, expanding APPEND, to:

          T.

  Case 2.4.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (NOT (SHUFFLEP X (CDR Y) (CDR Z)))
                        (SHUFFLEP (APPEND (CDR X) W)
                                  Y
                                  (APPEND (CDR Z) W))
                        (PLISTP W)
                        (EQUAL (CAR X) (CAR Z))
                        (SHUFFLEP (CDR X) Y (CDR Z))
                        (NOT (LISTP (APPEND X W))))
                   (EQUAL Y
                          (CONS (CAR X) (APPEND (CDR Z) W)))),

    which further simplifies, opening up the definition of APPEND, to:

          T.

  Case 2.3.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (NOT (SHUFFLEP X (CDR Y) (CDR Z)))
                        (SHUFFLEP (APPEND (CDR X) W)
                                  Y
                                  (APPEND (CDR Z) W))
                        (PLISTP W)
                        (EQUAL (CAR X) (CAR Z))
                        (SHUFFLEP (CDR X) Y (CDR Z))
                        (NOT (LISTP (APPEND X W))))
                   (EQUAL (APPEND X W) NIL)),

    which further simplifies, opening up APPEND, to:

          T.

  Case 2.2.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (NOT (SHUFFLEP X (CDR Y) (CDR Z)))
                        (SHUFFLEP (APPEND (CDR X) W)
                                  Y
                                  (APPEND (CDR Z) W))
                        (PLISTP W)
                        (EQUAL (CAR X) (CAR Z))
                        (SHUFFLEP (CDR X) Y (CDR Z))
                        (LISTP (APPEND X W))
                        (NOT (EQUAL (CAR (APPEND X W)) (CAR X))))
                   (EQUAL (CAR Y) (CAR X))),

    which further simplifies, appealing to the lemma CAR-CONS, and expanding
    the function APPEND, to:

          T.

  Case 2.1.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (NOT (SHUFFLEP X (CDR Y) (CDR Z)))
                        (SHUFFLEP (APPEND (CDR X) W)
                                  Y
                                  (APPEND (CDR Z) W))
                        (PLISTP W)
                        (EQUAL (CAR X) (CAR Z))
                        (SHUFFLEP (CDR X) Y (CDR Z))
                        (LISTP (APPEND X W))
                        (NOT (EQUAL (CAR (APPEND X W)) (CAR X))))
                   (SHUFFLEP (APPEND X W)
                             (CDR Y)
                             (APPEND (CDR Z) W))),

    which further simplifies, applying CAR-CONS, and opening up the definition
    of APPEND, to:

          T.

Case 1. (IMPLIES (AND (NOT (NLISTP Z))
                      (NOT (NLISTP X))
                      (NOT (NLISTP Y))
                      (SHUFFLEP (APPEND X W)
                                (CDR Y)
                                (APPEND (CDR Z) W))
                      (SHUFFLEP (APPEND (CDR X) W)
                                Y
                                (APPEND (CDR Z) W))
                      (PLISTP W)
                      (SHUFFLEP X Y Z))
                 (SHUFFLEP (APPEND X W)
                           Y
                           (APPEND Z W))).

  This simplifies, applying the lemmas CDR-CONS, CDR-APPEND, and CAR-CONS, and
  expanding the definitions of NLISTP, SHUFFLEP, APPEND, and PLISTP, to the
  following ten new goals:

  Case 1.10.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP (APPEND X W)
                                  (CDR Y)
                                  (APPEND (CDR Z) W))
                        (SHUFFLEP (APPEND (CDR X) W)
                                  Y
                                  (APPEND (CDR Z) W))
                        (PLISTP W)
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (SHUFFLEP X (CDR Y) (CDR Z))
                        (NOT (LISTP (APPEND X W))))
                   (PLISTP (CDR Y))).

    But this again simplifies, unfolding the definitions of SHUFFLEP and LISTP,
    to:

          T.

  Case 1.9.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP (APPEND X W)
                                  (CDR Y)
                                  (APPEND (CDR Z) W))
                        (SHUFFLEP (APPEND (CDR X) W)
                                  Y
                                  (APPEND (CDR Z) W))
                        (PLISTP W)
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (SHUFFLEP X (CDR Y) (CDR Z))
                        (NOT (LISTP (APPEND X W))))
                   (EQUAL Y
                          (CONS (CAR Y) (APPEND (CDR Z) W)))),

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

          T.

  Case 1.8.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP (APPEND X W)
                                  (CDR Y)
                                  (APPEND (CDR Z) W))
                        (SHUFFLEP (APPEND (CDR X) W)
                                  Y
                                  (APPEND (CDR Z) W))
                        (PLISTP W)
                        (NOT (EQUAL (CAR X) (CAR Z)))
                        (EQUAL (CAR Y) (CAR Z))
                        (SHUFFLEP X (CDR Y) (CDR Z))
                        (NOT (LISTP (APPEND X W))))
                   (EQUAL (APPEND X W) NIL)).

    However this again simplifies, unfolding the function SHUFFLEP, to:

          T.

  Case 1.7.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP (APPEND X W)
                                  (CDR Y)
                                  (APPEND (CDR Z) W))
                        (SHUFFLEP (APPEND (CDR X) W)
                                  Y
                                  (APPEND (CDR Z) W))
                        (PLISTP W)
                        (EQUAL (CAR X) (CAR Z))
                        (EQUAL (CAR Y) (CAR X))
                        (SHUFFLEP X (CDR Y) (CDR Z))
                        (NOT (LISTP (APPEND X W))))
                   (PLISTP (CDR Y))),

    which again simplifies, opening up SHUFFLEP and LISTP, to:

          T.

  Case 1.6.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP (APPEND X W)
                                  (CDR Y)
                                  (APPEND (CDR Z) W))
                        (SHUFFLEP (APPEND (CDR X) W)
                                  Y
                                  (APPEND (CDR Z) W))
                        (PLISTP W)
                        (EQUAL (CAR X) (CAR Z))
                        (EQUAL (CAR Y) (CAR X))
                        (SHUFFLEP X (CDR Y) (CDR Z))
                        (NOT (LISTP (APPEND X W))))
                   (EQUAL Y
                          (CONS (CAR X) (APPEND (CDR Z) W)))),

    which again simplifies, applying the lemmas CAR-CONS and CDR-CONS, and
    expanding SHUFFLEP and LISTP, to:

          T.

  Case 1.5.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP (APPEND X W)
                                  (CDR Y)
                                  (APPEND (CDR Z) W))
                        (SHUFFLEP (APPEND (CDR X) W)
                                  Y
                                  (APPEND (CDR Z) W))
                        (PLISTP W)
                        (EQUAL (CAR X) (CAR Z))
                        (EQUAL (CAR Y) (CAR X))
                        (SHUFFLEP X (CDR Y) (CDR Z))
                        (NOT (LISTP (APPEND X W))))
                   (EQUAL (APPEND X W) NIL)),

    which again simplifies, expanding SHUFFLEP, to:

          T.

  Case 1.4.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP (APPEND X W)
                                  (CDR Y)
                                  (APPEND (CDR Z) W))
                        (SHUFFLEP (APPEND (CDR X) W)
                                  Y
                                  (APPEND (CDR Z) W))
                        (PLISTP W)
                        (EQUAL (CAR X) (CAR Z))
                        (SHUFFLEP (CDR X) Y (CDR Z))
                        (NOT (LISTP (APPEND X W))))
                   (PLISTP (CDR Y))),

    which again simplifies, expanding the definitions of SHUFFLEP and LISTP,
    to:

          T.

  Case 1.3.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP (APPEND X W)
                                  (CDR Y)
                                  (APPEND (CDR Z) W))
                        (SHUFFLEP (APPEND (CDR X) W)
                                  Y
                                  (APPEND (CDR Z) W))
                        (PLISTP W)
                        (EQUAL (CAR X) (CAR Z))
                        (SHUFFLEP (CDR X) Y (CDR Z))
                        (NOT (LISTP (APPEND X W))))
                   (EQUAL Y
                          (CONS (CAR X) (APPEND (CDR Z) W)))),

    which again simplifies, rewriting with the lemma CAR-CONS, and unfolding
    SHUFFLEP and LISTP, to the formula:

          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (LISTP (APPEND (CDR Z) W))
                        (EQUAL (APPEND X W) NIL)
                        (EQUAL (CDR Y) (APPEND (CDR Z) W))
                        (PLISTP (CDR Y))
                        (SHUFFLEP (APPEND (CDR X) W)
                                  Y
                                  (CDR Y))
                        (PLISTP W)
                        (EQUAL (CAR X) (CAR Z))
                        (SHUFFLEP (CDR X) Y (CDR Z)))
                   (EQUAL Y (CONS (CAR X) (CDR Y)))).

    This again simplifies, applying the lemma CAR-CONS, to:

          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (LISTP (CDR Y))
                        (EQUAL (APPEND X W) NIL)
                        (EQUAL (CDR Y) (APPEND (CDR Z) W))
                        (PLISTP (CDR Y))
                        (SHUFFLEP (APPEND (CDR X) W)
                                  Y
                                  (CDR Y))
                        (PLISTP W)
                        (EQUAL (CAR X) (CAR Z))
                        (SHUFFLEP (CDR X) Y (CDR Z)))
                   (EQUAL Y (CONS (CAR X) (CDR Y)))).

    This further simplifies, opening up APPEND, to:

          T.

  Case 1.2.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP (APPEND X W)
                                  (CDR Y)
                                  (APPEND (CDR Z) W))
                        (SHUFFLEP (APPEND (CDR X) W)
                                  Y
                                  (APPEND (CDR Z) W))
                        (PLISTP W)
                        (EQUAL (CAR X) (CAR Z))
                        (SHUFFLEP (CDR X) Y (CDR Z))
                        (NOT (LISTP (APPEND X W))))
                   (EQUAL (APPEND X W) NIL)),

    which again simplifies, opening up the definition of SHUFFLEP, to:

          T.

  Case 1.1.
          (IMPLIES (AND (LISTP Z)
                        (LISTP X)
                        (LISTP Y)
                        (SHUFFLEP (APPEND X W)
                                  (CDR Y)
                                  (APPEND (CDR Z) W))
                        (SHUFFLEP (APPEND (CDR X) W)
                                  Y
                                  (APPEND (CDR Z) W))
                        (PLISTP W)
                        (EQUAL (CAR X) (CAR Z))
                        (SHUFFLEP (CDR X) Y (CDR Z))
                        (LISTP (APPEND X W))
                        (NOT (EQUAL (CAR (APPEND X W)) (CAR X))))
                   (EQUAL (CAR Y) (CAR X))),

    which further simplifies, rewriting with CAR-CONS, and unfolding the
    definition of APPEND, to:

          T.


     So let us turn our attention to:

      (IMPLIES (AND (PLISTP W) (PLISTP V))
               (PLISTP (APPEND V W))),

which is formula *1.2 above.  Perhaps we can prove it by induction.  There are
three plausible inductions.  They merge into two likely candidate inductions.
However, only one is unflawed.  We will induct according to the following
scheme:
      (AND (IMPLIES (NLISTP V) (p V W))
           (IMPLIES (AND (NOT (NLISTP V)) (p (CDR V) W))
                    (p V W))).
Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of
NLISTP inform us that the measure (COUNT V) decreases according to the
well-founded relation LESSP in each induction step of the scheme.  The above
induction scheme generates the following three new goals:

Case 3. (IMPLIES (AND (NLISTP V) (PLISTP W) (PLISTP V))
                 (PLISTP (APPEND V W))).

  This simplifies, unfolding the functions NLISTP, PLISTP, LISTP, and APPEND,
  to:

        T.

Case 2. (IMPLIES (AND (NOT (NLISTP V))
                      (NOT (PLISTP (CDR V)))
                      (PLISTP W)
                      (PLISTP V))
                 (PLISTP (APPEND V W))).

  This simplifies, unfolding NLISTP and PLISTP, to:

        T.

Case 1. (IMPLIES (AND (NOT (NLISTP V))
                      (PLISTP (APPEND (CDR V) W))
                      (PLISTP W)
                      (PLISTP V))
                 (PLISTP (APPEND V W))).

  This simplifies, appealing to the lemma CDR-CONS, and unfolding the
  functions NLISTP, PLISTP, and APPEND, to:

        T.


     That finishes the proof of *1.2.


     So we now return to:

      (IMPLIES (PLISTP D)
               (EQUAL D (APPEND D NIL))),

which we named *1.1 above.  We will appeal to induction.  There are two
plausible inductions.  However, they merge into one likely candidate induction.
We will induct according to the following scheme:
      (AND (IMPLIES (NLISTP D) (p D))
           (IMPLIES (AND (NOT (NLISTP D)) (p (CDR D)))
                    (p D))).
Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of
NLISTP inform us that the measure (COUNT D) decreases according to the
well-founded relation LESSP in each induction step of the scheme.  The above
induction scheme produces the following three new formulas:

Case 3. (IMPLIES (AND (NLISTP D) (PLISTP D))
                 (EQUAL D (APPEND D NIL))).

  This simplifies, opening up NLISTP, PLISTP, APPEND, and EQUAL, to:

        T.

Case 2. (IMPLIES (AND (NOT (NLISTP D))
                      (NOT (PLISTP (CDR D)))
                      (PLISTP D))
                 (EQUAL D (APPEND D NIL))).

  This simplifies, expanding NLISTP and PLISTP, to:

        T.

Case 1. (IMPLIES (AND (NOT (NLISTP D))
                      (EQUAL (CDR D) (APPEND (CDR D) NIL))
                      (PLISTP D))
                 (EQUAL D (APPEND D NIL))).

  This simplifies, rewriting with CONS-CAR-CDR, and opening up NLISTP, PLISTP,
  and APPEND, to:

        T.


     That finishes the proof of *1.1, which, consequently, finishes the proof
of *1.  Q.E.D.


[ 0.0 0.2 0.1 ]

F5


(PROVE-LEMMA TRICK
             (REWRITE)
             (IMPLIES (AND (LISTP X)
                           (LISTP Y)
                           (SHUFFLEP X Y Z))
                      (OR (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                                    Y
                                    (APPEND (CDR Z) (LIST (CAR Z))))
                          (SHUFFLEP X
                                    (APPEND (CDR Y) (LIST (CAR Y)))
                                    (APPEND (CDR Z) (LIST (CAR Z)))))))

WARNING:  Note that the rewrite rule TRICK will be stored so as to apply only
to terms with the nonrecursive function symbol OR.


This formula simplifies, rewriting with the lemmas CDR-CONS, F5, and F4, and
opening up SHUFFLEP and PLISTP, to:

      T.

Q.E.D.


[ 0.0 0.0 0.0 ]

TRICK


(PROVE-LEMMA CAR-APPEND
             (REWRITE)
             (EQUAL (CAR (APPEND X Y))
                    (IF (LISTP X) (CAR X) (CAR Y))))

This simplifies, trivially, to the following two new goals:

Case 2. (IMPLIES (NOT (LISTP X))
                 (EQUAL (CAR (APPEND X Y)) (CAR Y))).

  This again simplifies, expanding APPEND, to:

        T.

Case 1. (IMPLIES (LISTP X)
                 (EQUAL (CAR (APPEND X Y)) (CAR X))).

  Applying the lemma CAR-CDR-ELIM, replace X by (CONS Z V) to eliminate
  (CAR X) and (CDR X).  This produces:

        (EQUAL (CAR (APPEND (CONS Z V) Y)) Z),

  which further simplifies, rewriting with the lemmas CDR-CONS and CAR-CONS,
  and expanding the function APPEND, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

CAR-APPEND


(PROVE-LEMMA F12
             (REWRITE)
             (IMPLIES (AND (ALTERNATING-COLORS (APPEND C (LIST D)))
                           (NOT (OPPOSITE-COLOR D E)))
                      (ALTERNATING-COLORS (APPEND C (LIST E)))))

WARNING:  Note that F12 contains the free variable D which will be chosen by
instantiating the hypothesis (ALTERNATING-COLORS (APPEND C (LIST D))).


This formula simplifies, opening up the function OPPOSITE-COLOR, to the
following two new conjectures:

Case 2. (IMPLIES (AND (ALTERNATING-COLORS (APPEND C (LIST D)))
                      (NOT (NUMBERP D))
                      (NOT (NUMBERP E)))
                 (ALTERNATING-COLORS (APPEND C (LIST E)))).

  Call the above conjecture *1.

Case 1. (IMPLIES (AND (ALTERNATING-COLORS (APPEND C (LIST D)))
                      (NUMBERP D)
                      (NUMBERP E))
                 (ALTERNATING-COLORS (APPEND C (LIST E)))),

  which we would usually push and work on later by induction.  But if we must
  use induction to prove the input conjecture, we prefer to induct on the
  original formulation of the problem.  Thus we will disregard all that we
  have previously done, give the name *1 to the original input, and work on it.


     So now let us consider:

(IMPLIES (AND (ALTERNATING-COLORS (APPEND C (LIST D)))
              (NOT (OPPOSITE-COLOR D E)))
         (ALTERNATING-COLORS (APPEND C (LIST E)))),

which we named *1 above.  We will appeal to induction.  Two inductions are
suggested by terms in the conjecture.  However, they merge into one likely
candidate induction.  We will induct according to the following scheme:
      (AND (IMPLIES (AND (LISTP C) (p (CDR C) E D))
                    (p C E D))
           (IMPLIES (NOT (LISTP C)) (p C E D))).
Linear arithmetic and the lemma CDR-LESSP inform us that the measure (COUNT C)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  The above induction scheme leads to the following three new
conjectures:

Case 3. (IMPLIES (AND (LISTP C)
                      (NOT (ALTERNATING-COLORS (APPEND (CDR C) (LIST D))))
                      (ALTERNATING-COLORS (APPEND C (LIST D)))
                      (NOT (OPPOSITE-COLOR D E)))
                 (ALTERNATING-COLORS (APPEND C (LIST E)))).

  This simplifies, rewriting with CAR-APPEND, CAR-CONS, and CDR-CONS, and
  unfolding APPEND, OPPOSITE-COLOR, and ALTERNATING-COLORS, to:

        T.

Case 2. (IMPLIES (AND (LISTP C)
                      (ALTERNATING-COLORS (APPEND (CDR C) (LIST E)))
                      (ALTERNATING-COLORS (APPEND C (LIST D)))
                      (NOT (OPPOSITE-COLOR D E)))
                 (ALTERNATING-COLORS (APPEND C (LIST E)))),

  which simplifies, appealing to the lemmas CAR-APPEND, CAR-CONS, and CDR-CONS,
  and unfolding the functions APPEND, OPPOSITE-COLOR, and ALTERNATING-COLORS,
  to:

        T.

Case 1. (IMPLIES (AND (NOT (LISTP C))
                      (ALTERNATING-COLORS (APPEND C (LIST D)))
                      (NOT (OPPOSITE-COLOR D E)))
                 (ALTERNATING-COLORS (APPEND C (LIST E)))),

  which simplifies, applying CDR-CONS, and opening up APPEND, LISTP,
  ALTERNATING-COLORS, and OPPOSITE-COLOR, to:

        T.


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


[ 0.0 0.0 0.0 ]

F12


(PROVE-LEMMA F6
             (REWRITE)
             (IMPLIES (AND (LISTP L)
                           (EVEN-LENGTH L)
                           (ALTERNATING-COLORS L))
                      (ALTERNATING-COLORS (APPEND (CDR L) (LIST (CAR L))))))

This simplifies, rewriting with CDR-CONS, and expanding the functions
OPPOSITE-COLOR, ALTERNATING-COLORS, APPEND, and LISTP, to two new conjectures:

Case 2. (IMPLIES (AND (LISTP L)
                      (EVEN-LENGTH L)
                      (NUMBERP (CAR L))
                      (NOT (NUMBERP (CADR L)))
                      (ALTERNATING-COLORS (CDR L)))
                 (ALTERNATING-COLORS (APPEND (CDR L) (LIST (CAR L))))).

  Applying the lemma CAR-CDR-ELIM, replace L by (CONS X Z) to eliminate
  (CAR L) and (CDR L) and Z by (CONS V W) to eliminate (CAR Z) and (CDR Z).
  We thus obtain the following two new goals:

  Case 2.2.
          (IMPLIES (AND (NOT (LISTP Z))
                        (EVEN-LENGTH (CONS X Z))
                        (NUMBERP X)
                        (NOT (NUMBERP (CAR Z)))
                        (ALTERNATING-COLORS Z))
                   (ALTERNATING-COLORS (APPEND Z (LIST X)))).

    However this further simplifies, rewriting with CDR-CONS, and opening up
    the definition of EVEN-LENGTH, to:

          T.

  Case 2.1.
          (IMPLIES (AND (EVEN-LENGTH (CONS X (CONS V W)))
                        (NUMBERP X)
                        (NOT (NUMBERP V))
                        (ALTERNATING-COLORS (CONS V W)))
                   (ALTERNATING-COLORS (APPEND (CONS V W) (LIST X)))).

    But this further simplifies, rewriting with the lemmas CDR-CONS, CAR-CONS,
    and CAR-APPEND, and unfolding the functions EVEN-LENGTH, OPPOSITE-COLOR,
    ALTERNATING-COLORS, APPEND, and LISTP, to the conjecture:

          (IMPLIES (AND (EVEN-LENGTH W)
                        (NUMBERP X)
                        (NOT (NUMBERP V))
                        (NUMBERP (CAR W))
                        (ALTERNATING-COLORS W))
                   (ALTERNATING-COLORS (APPEND W (LIST X)))),

    which we would usually push and work on later by induction.  But if we
    must use induction to prove the input conjecture, we prefer to induct on
    the original formulation of the problem.  Thus we will disregard all that
    we have previously done, give the name *1 to the original input, and work
    on it.


     So now let us consider:

(IMPLIES (AND (LISTP L)
              (EVEN-LENGTH L)
              (ALTERNATING-COLORS L))
         (ALTERNATING-COLORS (APPEND (CDR L) (LIST (CAR L))))).

We gave this the name *1 above.  Perhaps we can prove it by induction.  The
recursive terms in the conjecture suggest two inductions, both of which are
unflawed.  Since both of these are equally likely, we will choose arbitrarily.
We will induct according to the following scheme:
      (AND (IMPLIES (NLISTP L) (p L))
           (IMPLIES (AND (NOT (NLISTP L))
                         (NLISTP (CDR L)))
                    (p L))
           (IMPLIES (AND (NOT (NLISTP L))
                         (NOT (NLISTP (CDR L)))
                         (p (CDDR L)))
                    (p L))).
Linear arithmetic, the lemmas CDR-LESSEQP and CDR-LESSP, and the definition of
NLISTP inform us that the measure (COUNT L) decreases according to the
well-founded relation LESSP in each induction step of the scheme.  The above
induction scheme leads to the following six new conjectures:

Case 6. (IMPLIES (AND (NLISTP L)
                      (LISTP L)
                      (EVEN-LENGTH L)
                      (ALTERNATING-COLORS L))
                 (ALTERNATING-COLORS (APPEND (CDR L) (LIST (CAR L))))).

  This simplifies, opening up the function NLISTP, to:

        T.

Case 5. (IMPLIES (AND (NOT (NLISTP L))
                      (NLISTP (CDR L))
                      (LISTP L)
                      (EVEN-LENGTH L)
                      (ALTERNATING-COLORS L))
                 (ALTERNATING-COLORS (APPEND (CDR L) (LIST (CAR L))))).

  This simplifies, expanding NLISTP and EVEN-LENGTH, to:

        T.

Case 4. (IMPLIES (AND (NOT (NLISTP L))
                      (NOT (NLISTP (CDR L)))
                      (NOT (LISTP (CDDR L)))
                      (LISTP L)
                      (EVEN-LENGTH L)
                      (ALTERNATING-COLORS L))
                 (ALTERNATING-COLORS (APPEND (CDR L) (LIST (CAR L))))).

  This simplifies, rewriting with the lemmas CAR-CONS and CDR-CONS, and
  expanding the definitions of NLISTP, EVEN-LENGTH, OPPOSITE-COLOR,
  ALTERNATING-COLORS, APPEND, and LISTP, to:

        T.

Case 3. (IMPLIES (AND (NOT (NLISTP L))
                      (NOT (NLISTP (CDR L)))
                      (NOT (EVEN-LENGTH (CDDR L)))
                      (LISTP L)
                      (EVEN-LENGTH L)
                      (ALTERNATING-COLORS L))
                 (ALTERNATING-COLORS (APPEND (CDR L) (LIST (CAR L))))).

  This simplifies, opening up the definitions of NLISTP and EVEN-LENGTH, to:

        T.

Case 2. (IMPLIES (AND (NOT (NLISTP L))
                      (NOT (NLISTP (CDR L)))
                      (NOT (ALTERNATING-COLORS (CDDR L)))
                      (LISTP L)
                      (EVEN-LENGTH L)
                      (ALTERNATING-COLORS L))
                 (ALTERNATING-COLORS (APPEND (CDR L) (LIST (CAR L))))).

  This simplifies, applying CAR-CONS and CDR-CONS, and expanding the
  definitions of NLISTP, EVEN-LENGTH, OPPOSITE-COLOR, ALTERNATING-COLORS,
  APPEND, and LISTP, to:

        T.

Case 1. (IMPLIES (AND (NOT (NLISTP L))
                      (NOT (NLISTP (CDR L)))
                      (ALTERNATING-COLORS (APPEND (CDDDR L) (LIST (CADDR L))))
                      (LISTP L)
                      (EVEN-LENGTH L)
                      (ALTERNATING-COLORS L))
                 (ALTERNATING-COLORS (APPEND (CDR L) (LIST (CAR L))))),

  which simplifies, applying CAR-CONS and CDR-CONS, and opening up the
  definitions of NLISTP, EVEN-LENGTH, OPPOSITE-COLOR, ALTERNATING-COLORS,
  APPEND, and LISTP, to the following 16 new formulas:

  Case 1.16.
          (IMPLIES
                  (AND (LISTP (CDR L))
                       (ALTERNATING-COLORS (APPEND (CDDDR L) (LIST (CADDR L))))
                       (LISTP L)
                       (EVEN-LENGTH (CDDR L))
                       (NUMBERP (CAR L))
                       (NOT (NUMBERP (CADR L)))
                       (NUMBERP (CADDR L))
                       (NOT (LISTP (CDDDR L)))
                       (NOT (LISTP (CDDR L))))
                  (NUMBERP (CAR (LIST (CAR L))))).

    This again simplifies, rewriting with CDR-NLISTP, CAR-NLISTP, and CAR-CONS,
    and opening up the functions CONS, APPEND, ALTERNATING-COLORS, NUMBERP,
    and LISTP, to:

          T.

  Case 1.15.
          (IMPLIES
                  (AND (LISTP (CDR L))
                       (ALTERNATING-COLORS (APPEND (CDDDR L) (LIST (CADDR L))))
                       (LISTP L)
                       (EVEN-LENGTH (CDDR L))
                       (NUMBERP (CAR L))
                       (NOT (NUMBERP (CADR L)))
                       (NUMBERP (CADDR L))
                       (NOT (LISTP (CDDDR L)))
                       (LISTP (CDDR L)))
                  (NUMBERP (CAR (LIST (CADDR L) (CAR L))))).

    However this again simplifies, applying the lemmas CDR-CONS and CAR-CONS,
    and unfolding the functions APPEND, LISTP, and ALTERNATING-COLORS, to:

          T.

  Case 1.14.
          (IMPLIES
                  (AND (LISTP (CDR L))
                       (ALTERNATING-COLORS (APPEND (CDDDR L) (LIST (CADDR L))))
                       (LISTP L)
                       (EVEN-LENGTH (CDDR L))
                       (NUMBERP (CAR L))
                       (NOT (NUMBERP (CADR L)))
                       (NUMBERP (CADDR L))
                       (NOT (LISTP (CDDDR L)))
                       (NOT (LISTP (CDDR L))))
                  (ALTERNATING-COLORS (LIST (CAR L)))),

    which again simplifies, applying the lemmas CDR-NLISTP, CAR-NLISTP, and
    CDR-CONS, and unfolding the definitions of CONS, APPEND,
    ALTERNATING-COLORS, NUMBERP, and LISTP, to:

          T.

  Case 1.13.
          (IMPLIES
                  (AND (LISTP (CDR L))
                       (ALTERNATING-COLORS (APPEND (CDDDR L) (LIST (CADDR L))))
                       (LISTP L)
                       (EVEN-LENGTH (CDDR L))
                       (NUMBERP (CAR L))
                       (NOT (NUMBERP (CADR L)))
                       (NUMBERP (CADDR L))
                       (NOT (LISTP (CDDDR L)))
                       (LISTP (CDDR L)))
                  (ALTERNATING-COLORS (LIST (CADDR L) (CAR L)))),

    which again simplifies, appealing to the lemmas CDR-CONS and CAR-CONS, and
    opening up the definitions of APPEND, LISTP, ALTERNATING-COLORS, and
    OPPOSITE-COLOR, to:

          (IMPLIES (AND (LISTP (CDR L))
                        (LISTP L)
                        (EVEN-LENGTH (CDDR L))
                        (NUMBERP (CAR L))
                        (NOT (NUMBERP (CADR L)))
                        (NUMBERP (CADDR L))
                        (NOT (LISTP (CDDDR L))))
                   (NOT (LISTP (CDDR L)))).

    This further simplifies, opening up the function EVEN-LENGTH, to:

          T.

  Case 1.12.
          (IMPLIES
                  (AND (LISTP (CDR L))
                       (ALTERNATING-COLORS (APPEND (CDDDR L) (LIST (CADDR L))))
                       (LISTP L)
                       (EVEN-LENGTH (CDDR L))
                       (NOT (NUMBERP (CAR L)))
                       (NUMBERP (CADR L))
                       (NOT (NUMBERP (CADDR L)))
                       (NOT (LISTP (CDDDR L)))
                       (NOT (LISTP (CDDR L))))
                  (NOT (NUMBERP (CAR (LIST (CAR L)))))),

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

          T.

  Case 1.11.
          (IMPLIES
                  (AND (LISTP (CDR L))
                       (ALTERNATING-COLORS (APPEND (CDDDR L) (LIST (CADDR L))))
                       (LISTP L)
                       (EVEN-LENGTH (CDDR L))
                       (NOT (NUMBERP (CAR L)))
                       (NUMBERP (CADR L))
                       (NOT (NUMBERP (CADDR L)))
                       (NOT (LISTP (CDDDR L)))
                       (LISTP (CDDR L)))
                  (NOT (NUMBERP (CAR (LIST (CADDR L) (CAR L)))))).

    This again simplifies, applying the lemmas CDR-CONS and CAR-CONS, and
    opening up the definitions of APPEND, LISTP, and ALTERNATING-COLORS, to:

          T.

  Case 1.10.
          (IMPLIES
                  (AND (LISTP (CDR L))
                       (ALTERNATING-COLORS (APPEND (CDDDR L) (LIST (CADDR L))))
                       (LISTP L)
                       (EVEN-LENGTH (CDDR L))
                       (NOT (NUMBERP (CAR L)))
                       (NUMBERP (CADR L))
                       (NOT (NUMBERP (CADDR L)))
                       (NOT (LISTP (CDDDR L)))
                       (NOT (LISTP (CDDR L))))
                  (ALTERNATING-COLORS (LIST (CAR L)))),

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

          T.

  Case 1.9.
          (IMPLIES
                  (AND (LISTP (CDR L))
                       (ALTERNATING-COLORS (APPEND (CDDDR L) (LIST (CADDR L))))
                       (LISTP L)
                       (EVEN-LENGTH (CDDR L))
                       (NOT (NUMBERP (CAR L)))
                       (NUMBERP (CADR L))
                       (NOT (NUMBERP (CADDR L)))
                       (NOT (LISTP (CDDDR L)))
                       (LISTP (CDDR L)))
                  (ALTERNATING-COLORS (LIST (CADDR L) (CAR L)))).

    But this again simplifies, appealing to the lemmas CDR-CONS and CAR-CONS,
    and unfolding the functions APPEND, LISTP, ALTERNATING-COLORS, and
    OPPOSITE-COLOR, to the goal:

          (IMPLIES (AND (LISTP (CDR L))
                        (LISTP L)
                        (EVEN-LENGTH (CDDR L))
                        (NOT (NUMBERP (CAR L)))
                        (NUMBERP (CADR L))
                        (NOT (NUMBERP (CADDR L)))
                        (NOT (LISTP (CDDDR L))))
                   (NOT (LISTP (CDDR L)))).

    This further simplifies, opening up the definition of EVEN-LENGTH, to:

          T.

  Case 1.8.
          (IMPLIES
                  (AND (LISTP (CDR L))
                       (ALTERNATING-COLORS (APPEND (CDDDR L) (LIST (CADDR L))))
                       (LISTP L)
                       (EVEN-LENGTH (CDDR L))
                       (NUMBERP (CAR L))
                       (NOT (NUMBERP (CADR L)))
                       (NUMBERP (CADDR L))
                       (NOT (NUMBERP (CADDDR L)))
                       (ALTERNATING-COLORS (CDDDR L))
                       (NOT (LISTP (CDDR L))))
                  (NUMBERP (CAR (LIST (CAR L))))),

    which again simplifies, applying CDR-NLISTP and CAR-NLISTP, and expanding
    the functions CONS, APPEND, ALTERNATING-COLORS, NUMBERP, and CAR, to:

          T.

  Case 1.7.
          (IMPLIES
                  (AND (LISTP (CDR L))
                       (ALTERNATING-COLORS (APPEND (CDDDR L) (LIST (CADDR L))))
                       (LISTP L)
                       (EVEN-LENGTH (CDDR L))
                       (NUMBERP (CAR L))
                       (NOT (NUMBERP (CADR L)))
                       (NUMBERP (CADDR L))
                       (NOT (NUMBERP (CADDDR L)))
                       (ALTERNATING-COLORS (CDDDR L))
                       (LISTP (CDDR L)))
                  (NUMBERP (CAR (CONS (CADDR L)
                                      (APPEND (CDDDR L) (LIST (CAR L))))))).

    This again simplifies, applying CAR-CONS, to:

          T.

  Case 1.6.
          (IMPLIES
                  (AND (LISTP (CDR L))
                       (ALTERNATING-COLORS (APPEND (CDDDR L) (LIST (CADDR L))))
                       (LISTP L)
                       (EVEN-LENGTH (CDDR L))
                       (NUMBERP (CAR L))
                       (NOT (NUMBERP (CADR L)))
                       (NUMBERP (CADDR L))
                       (NOT (NUMBERP (CADDDR L)))
                       (ALTERNATING-COLORS (CDDDR L))
                       (NOT (LISTP (CDDR L))))
                  (ALTERNATING-COLORS (LIST (CAR L)))).

    This again simplifies, rewriting with CDR-NLISTP and CAR-NLISTP, and
    expanding CONS, APPEND, ALTERNATING-COLORS, NUMBERP, and CAR, to:

          T.

  Case 1.5.
          (IMPLIES
                (AND (LISTP (CDR L))
                     (ALTERNATING-COLORS (APPEND (CDDDR L) (LIST (CADDR L))))
                     (LISTP L)
                     (EVEN-LENGTH (CDDR L))
                     (NUMBERP (CAR L))
                     (NOT (NUMBERP (CADR L)))
                     (NUMBERP (CADDR L))
                     (NOT (NUMBERP (CADDDR L)))
                     (ALTERNATING-COLORS (CDDDR L))
                     (LISTP (CDDR L)))
                (ALTERNATING-COLORS (CONS (CADDR L)
                                          (APPEND (CDDDR L) (LIST (CAR L)))))).

    This again simplifies, rewriting with F12, CAR-APPEND, CAR-CONS, and
    CDR-CONS, and unfolding OPPOSITE-COLOR and ALTERNATING-COLORS, to:

          (IMPLIES
                  (AND (LISTP (CDR L))
                       (ALTERNATING-COLORS (APPEND (CDDDR L) (LIST (CADDR L))))
                       (LISTP L)
                       (EVEN-LENGTH (CDDR L))
                       (NUMBERP (CAR L))
                       (NOT (NUMBERP (CADR L)))
                       (NUMBERP (CADDR L))
                       (NOT (NUMBERP (CADDDR L)))
                       (ALTERNATING-COLORS (CDDDR L))
                       (LISTP (CDDR L)))
                  (LISTP (CDDDR L))),

    which again simplifies, applying the lemmas CDR-CONS and CAR-NLISTP, and
    unfolding the functions APPEND, LISTP, ALTERNATING-COLORS, and NUMBERP, to:

          T.

  Case 1.4.
          (IMPLIES
                  (AND (LISTP (CDR L))
                       (ALTERNATING-COLORS (APPEND (CDDDR L) (LIST (CADDR L))))
                       (LISTP L)
                       (EVEN-LENGTH (CDDR L))
                       (NOT (NUMBERP (CAR L)))
                       (NUMBERP (CADR L))
                       (NOT (NUMBERP (CADDR L)))
                       (NUMBERP (CADDDR L))
                       (ALTERNATING-COLORS (CDDDR L))
                       (NOT (LISTP (CDDR L))))
                  (NOT (NUMBERP (CAR (LIST (CAR L)))))),

    which again simplifies, rewriting with CDR-NLISTP and CAR-NLISTP, and
    expanding the functions CONS, APPEND, ALTERNATING-COLORS, and NUMBERP, to:

          T.

  Case 1.3.
          (IMPLIES
                  (AND (LISTP (CDR L))
                       (ALTERNATING-COLORS (APPEND (CDDDR L) (LIST (CADDR L))))
                       (LISTP L)
                       (EVEN-LENGTH (CDDR L))
                       (NOT (NUMBERP (CAR L)))
                       (NUMBERP (CADR L))
                       (NOT (NUMBERP (CADDR L)))
                       (NUMBERP (CADDDR L))
                       (ALTERNATING-COLORS (CDDDR L))
                       (LISTP (CDDR L)))
                  (NOT (NUMBERP (CAR (CONS (CADDR L)
                                           (APPEND (CDDDR L)
                                                   (LIST (CAR L)))))))).

    But this again simplifies, applying CAR-CONS, to:

          T.

  Case 1.2.
          (IMPLIES
                  (AND (LISTP (CDR L))
                       (ALTERNATING-COLORS (APPEND (CDDDR L) (LIST (CADDR L))))
                       (LISTP L)
                       (EVEN-LENGTH (CDDR L))
                       (NOT (NUMBERP (CAR L)))
                       (NUMBERP (CADR L))
                       (NOT (NUMBERP (CADDR L)))
                       (NUMBERP (CADDDR L))
                       (ALTERNATING-COLORS (CDDDR L))
                       (NOT (LISTP (CDDR L))))
                  (ALTERNATING-COLORS (LIST (CAR L)))).

    This again simplifies, rewriting with CDR-NLISTP and CAR-NLISTP, and
    opening up the definitions of CONS, APPEND, ALTERNATING-COLORS, and
    NUMBERP, to:

          T.

  Case 1.1.
          (IMPLIES
                (AND (LISTP (CDR L))
                     (ALTERNATING-COLORS (APPEND (CDDDR L) (LIST (CADDR L))))
                     (LISTP L)
                     (EVEN-LENGTH (CDDR L))
                     (NOT (NUMBERP (CAR L)))
                     (NUMBERP (CADR L))
                     (NOT (NUMBERP (CADDR L)))
                     (NUMBERP (CADDDR L))
                     (ALTERNATING-COLORS (CDDDR L))
                     (LISTP (CDDR L)))
                (ALTERNATING-COLORS (CONS (CADDR L)
                                          (APPEND (CDDDR L) (LIST (CAR L)))))).

    But this again simplifies, appealing to the lemmas F12, CAR-APPEND,
    CAR-CONS, and CDR-CONS, and opening up the definitions of OPPOSITE-COLOR
    and ALTERNATING-COLORS, to the conjecture:

          (IMPLIES
                  (AND (LISTP (CDR L))
                       (ALTERNATING-COLORS (APPEND (CDDDR L) (LIST (CADDR L))))
                       (LISTP L)
                       (EVEN-LENGTH (CDDR L))
                       (NOT (NUMBERP (CAR L)))
                       (NUMBERP (CADR L))
                       (NOT (NUMBERP (CADDR L)))
                       (NUMBERP (CADDDR L))
                       (ALTERNATING-COLORS (CDDDR L))
                       (LISTP (CDDR L)))
                  (LISTP (CDDDR L))).

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

          (IMPLIES (AND (LISTP (CDR L))
                        (LISTP L)
                        (EVEN-LENGTH (CDDR L))
                        (NOT (NUMBERP (CAR L)))
                        (NUMBERP (CADR L))
                        (NOT (NUMBERP (CADDR L)))
                        (LISTP (CDDR L)))
                   (LISTP (CDDDR L))),

    which further simplifies, expanding EVEN-LENGTH, to:

          T.


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


[ 0.0 0.1 0.1 ]

F6


(PROVE-LEMMA G19
             (REWRITE)
             (IMPLIES (AND (ALTERNATING-COLORS C)
                           (NUMBERP (CAR C))
                           (EVEN-LENGTH C)
                           (NUMBERP V))
                      (ALTERNATING-COLORS (APPEND C (LIST V))))
             ((INDUCT (PAIRED-COLORS C))))

This conjecture can be simplified, using the abbreviations NLISTP, IMPLIES,
NOT, OR, and AND, to two new conjectures:

Case 2. (IMPLIES (AND (OR (NLISTP C) (NLISTP (CDR C)))
                      (ALTERNATING-COLORS C)
                      (NUMBERP (CAR C))
                      (EVEN-LENGTH C)
                      (NUMBERP V))
                 (ALTERNATING-COLORS (APPEND C (LIST V)))),

  which simplifies, appealing to the lemmas CAR-NLISTP and CDR-CONS, and
  opening up NLISTP, OR, ALTERNATING-COLORS, NUMBERP, EVEN-LENGTH, APPEND, and
  LISTP, to:

        T.

Case 1. (IMPLIES (AND (LISTP C)
                      (LISTP (CDR C))
                      (IMPLIES (AND (ALTERNATING-COLORS (CDDR C))
                                    (NUMBERP (CADDR C))
                                    (EVEN-LENGTH (CDDR C))
                                    (NUMBERP V))
                               (ALTERNATING-COLORS (APPEND (CDDR C) (LIST V))))
                      (ALTERNATING-COLORS C)
                      (NUMBERP (CAR C))
                      (EVEN-LENGTH C)
                      (NUMBERP V))
                 (ALTERNATING-COLORS (APPEND C (LIST V)))),

  which simplifies, appealing to the lemmas CAR-CONS, CDR-CONS, F12, and
  CAR-APPEND, and unfolding AND, IMPLIES, OPPOSITE-COLOR, ALTERNATING-COLORS,
  EVEN-LENGTH, APPEND, and LISTP, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

G19


(PROVE-LEMMA G20
             (REWRITE)
             (IMPLIES (AND (ALTERNATING-COLORS C)
                           (NOT (NUMBERP (CAR C)))
                           (EVEN-LENGTH C)
                           (NOT (NUMBERP V)))
                      (ALTERNATING-COLORS (APPEND C (LIST V))))
             ((INDUCT (PAIRED-COLORS C))))

This conjecture can be simplified, using the abbreviations NLISTP, IMPLIES,
NOT, OR, and AND, to two new goals:

Case 2. (IMPLIES (AND (OR (NLISTP C) (NLISTP (CDR C)))
                      (ALTERNATING-COLORS C)
                      (NOT (NUMBERP (CAR C)))
                      (EVEN-LENGTH C)
                      (NOT (NUMBERP V)))
                 (ALTERNATING-COLORS (APPEND C (LIST V)))),

  which simplifies, rewriting with CAR-NLISTP and CDR-CONS, and expanding the
  functions NLISTP, OR, ALTERNATING-COLORS, NUMBERP, EVEN-LENGTH, APPEND, and
  LISTP, to:

        T.

Case 1. (IMPLIES (AND (LISTP C)
                      (LISTP (CDR C))
                      (IMPLIES (AND (ALTERNATING-COLORS (CDDR C))
                                    (NOT (NUMBERP (CADDR C)))
                                    (EVEN-LENGTH (CDDR C))
                                    (NOT (NUMBERP V)))
                               (ALTERNATING-COLORS (APPEND (CDDR C) (LIST V))))
                      (ALTERNATING-COLORS C)
                      (NOT (NUMBERP (CAR C)))
                      (EVEN-LENGTH C)
                      (NOT (NUMBERP V)))
                 (ALTERNATING-COLORS (APPEND C (LIST V)))).

  This simplifies, rewriting with CAR-CONS, CDR-CONS, F12, and CAR-APPEND, and
  expanding the functions NOT, AND, IMPLIES, OPPOSITE-COLOR,
  ALTERNATING-COLORS, EVEN-LENGTH, APPEND, and LISTP, to:

        T.

Q.E.D.


[ 0.0 0.0 0.0 ]

G20


(PROVE-LEMMA FAP
             (REWRITE)
             (IMPLIES (AND (SHUFFLEP X Y Z)
                           (ALTERNATING-COLORS X)
                           (ALTERNATING-COLORS Y)
                           (EVEN-LENGTH X)
                           (EVEN-LENGTH Y)
                           (NOT (OPPOSITE-COLOR (CAR X) (CAR Y))))
                      (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR Z)))))
             ((USE (TRICK)
                   (MAIN (Z (APPEND (CDR Z) (LIST (CAR Z))))
                         (X X)
                         (Y (APPEND (CDR Y) (LIST (CAR Y)))))
                   (MAIN (Z (APPEND (CDR Z) (LIST (CAR Z))))
                         (X (APPEND (CDR X) (LIST (CAR X))))
                         (Y Y)))))

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


This simplifies, rewriting with CDR-NLISTP, CAR-NLISTP, CAR-APPEND, CAR-CONS,
F6, AL->PP, CDR-APPEND, and CDR-CONS, and expanding the definitions of PLISTP,
SHUFFLEP, AND, OR, IMPLIES, CONS, APPEND, OPPOSITE-COLOR, ALTERNATING-COLORS,
LISTP, CAR, NUMBERP, EVEN-LENGTH, CDR, and PAIRED-COLORS, to 81 new
conjectures:

Case 81.(IMPLIES
                (AND (LISTP Z)
                     (NOT (EQUAL (CAR X) (CAR Z)))
                     (NOT (SHUFFLEP X (CDR Y) (CDR Z)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (NOT (LISTP X))
                     (EQUAL X NIL)
                     (EQUAL Y Z)
                     (PLISTP (CDR Y))
                     (NUMBERP (CAR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Y) (LIST (CAR Y))))),

  which again simplifies, rewriting with CDR-CONS, and unfolding CAR, EQUAL,
  LISTP, SHUFFLEP, APPEND, and ALTERNATING-COLORS, to:

        T.

Case 80.(IMPLIES
                (AND (LISTP Z)
                     (NOT (EQUAL (CAR X) (CAR Z)))
                     (NOT (SHUFFLEP X (CDR Y) (CDR Z)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                                    Y
                                    (APPEND (CDR Z) (LIST (CAR Z)))))
                     (NOT (LISTP X))
                     (EQUAL X NIL)
                     (EQUAL Y Z)
                     (PLISTP (CDR Y))
                     (NUMBERP (CAR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Y) (LIST (CAR Y))))).

  But this again simplifies, applying CDR-CONS, and opening up the definitions
  of CAR, EQUAL, LISTP, SHUFFLEP, APPEND, and ALTERNATING-COLORS, to:

        T.

Case 79.(IMPLIES
                (AND (LISTP Z)
                     (NOT (EQUAL (CAR X) (CAR Z)))
                     (NOT (SHUFFLEP X (CDR Y) (CDR Z)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (LISTP (CDR X))
                     (NUMBERP (CADR X))
                     (NUMBERP (CAR Y))
                     (NOT (LISTP X))
                     (EQUAL X NIL)
                     (EQUAL Y Z)
                     (PLISTP (CDR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Y) (LIST (CAR Y))))).

  This again simplifies, applying the lemma CDR-CONS, and unfolding the
  definitions of CAR, EQUAL, LISTP, SHUFFLEP, APPEND, and ALTERNATING-COLORS,
  to:

        T.

Case 78.(IMPLIES
                (AND (LISTP Z)
                     (NOT (EQUAL (CAR X) (CAR Z)))
                     (NOT (SHUFFLEP X (CDR Y) (CDR Z)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (LISTP (CDR X)))
                     (NUMBERP (CAR X))
                     (NUMBERP (CAR Y))
                     (NOT (LISTP X))
                     (EQUAL X NIL)
                     (EQUAL Y Z)
                     (PLISTP (CDR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Y) (LIST (CAR Y))))),

  which again simplifies, rewriting with the lemma CDR-CONS, and unfolding the
  definitions of CAR, EQUAL, LISTP, SHUFFLEP, APPEND, and ALTERNATING-COLORS,
  to:

        T.

Case 77.(IMPLIES
                (AND (LISTP Z)
                     (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                     (NOT (SHUFFLEP X (CDR Y) (CDR Z)))
                     (NOT (OPPOSITE-COLOR (CAR X) (CADR Y)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP X)
                     (NOT (LISTP Y))
                     (EQUAL Y NIL)
                     (EQUAL X Z)
                     (PLISTP (CDR X))
                     (NUMBERP (CAR X))
                     (NOT (NUMBERP (CADR X)))
                     (ALTERNATING-COLORS (CDR X))
                     (EVEN-LENGTH X))
                (PAIRED-COLORS (APPEND (CDR X) (LIST (CAR X))))),

  which again simplifies, applying CDR-CONS, and unfolding EQUAL, LISTP,
  SHUFFLEP, CDR, CAR, NUMBERP, OPPOSITE-COLOR, APPEND, and ALTERNATING-COLORS,
  to:

        T.

Case 76.(IMPLIES
                (AND (LISTP Z)
                     (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                     (NOT (SHUFFLEP X (CDR Y) (CDR Z)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (NOT (LISTP X))
                     (EQUAL X NIL)
                     (EQUAL Y Z)
                     (PLISTP (CDR Y))
                     (NUMBERP (CAR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Y) (LIST (CAR Y))))).

  But this again simplifies, rewriting with CDR-CONS, and opening up CDR,
  EQUAL, LISTP, SHUFFLEP, APPEND, and ALTERNATING-COLORS, to:

        T.

Case 75.(IMPLIES
                (AND (LISTP Z)
                     (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                     (NOT (SHUFFLEP X (CDR Y) (CDR Z)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP X)
                     (NOT (LISTP Y))
                     (EQUAL Y NIL)
                     (EQUAL X Z)
                     (PLISTP (CDR X))
                     (NUMBERP (CAR X))
                     (NOT (NUMBERP (CADR X)))
                     (ALTERNATING-COLORS (CDR X))
                     (EVEN-LENGTH X))
                (PAIRED-COLORS (APPEND (CDR X) (LIST (CAR X))))).

  This again simplifies, opening up EQUAL, LISTP, SHUFFLEP, CDR, CAR, CONS,
  APPEND, and ALTERNATING-COLORS, to:

        T.

Case 74.(IMPLIES
                (AND (LISTP Z)
                     (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                     (NOT (SHUFFLEP X (CDR Y) (CDR Z)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                                    Y
                                    (APPEND (CDR Z) (LIST (CAR Z)))))
                     (NOT (LISTP X))
                     (EQUAL X NIL)
                     (EQUAL Y Z)
                     (PLISTP (CDR Y))
                     (NUMBERP (CAR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Y) (LIST (CAR Y))))),

  which again simplifies, applying CDR-CONS, and unfolding the functions CDR,
  EQUAL, LISTP, SHUFFLEP, APPEND, and ALTERNATING-COLORS, to:

        T.

Case 73.(IMPLIES
                (AND (LISTP Z)
                     (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                     (NOT (SHUFFLEP X (CDR Y) (CDR Z)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (LISTP (CDR X))
                     (NUMBERP (CADR X))
                     (NUMBERP (CAR Y))
                     (NOT (LISTP X))
                     (EQUAL X NIL)
                     (EQUAL Y Z)
                     (PLISTP (CDR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Y) (LIST (CAR Y))))).

  This again simplifies, rewriting with CDR-CONS, and opening up CDR, EQUAL,
  LISTP, SHUFFLEP, APPEND, and ALTERNATING-COLORS, to:

        T.

Case 72.(IMPLIES
                (AND (LISTP Z)
                     (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                     (NOT (SHUFFLEP X (CDR Y) (CDR Z)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (LISTP (CDR X)))
                     (NUMBERP (CAR X))
                     (NUMBERP (CAR Y))
                     (NOT (LISTP X))
                     (EQUAL X NIL)
                     (EQUAL Y Z)
                     (PLISTP (CDR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Y) (LIST (CAR Y))))).

  But this again simplifies, applying CDR-CONS, and opening up the definitions
  of CDR, EQUAL, LISTP, SHUFFLEP, APPEND, and ALTERNATING-COLORS, to:

        T.

Case 71.(IMPLIES
                (AND (LISTP Z)
                     (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                     (NOT (SHUFFLEP X (CDR Y) (CDR Z)))
                     (NOT (SHUFFLEP X
                                    (APPEND (CDR Y) (LIST (CAR Y)))
                                    (APPEND (CDR Z) (LIST (CAR Z)))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP X)
                     (NOT (LISTP Y))
                     (EQUAL Y NIL)
                     (EQUAL X Z)
                     (PLISTP (CDR X))
                     (NUMBERP (CAR X))
                     (NOT (NUMBERP (CADR X)))
                     (ALTERNATING-COLORS (CDR X))
                     (EVEN-LENGTH X))
                (PAIRED-COLORS (APPEND (CDR X) (LIST (CAR X))))).

  However this again simplifies, applying the lemmas CDR-CONS and CAR-CONS,
  and unfolding EQUAL, LISTP, SHUFFLEP, CDR, CAR, CONS, APPEND, and
  ALTERNATING-COLORS, to:

        T.

Case 70.(IMPLIES
                (AND (LISTP Z)
                     (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                     (NOT (SHUFFLEP X (CDR Y) (CDR Z)))
                     (NOT (LISTP (CDR Y)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP X)
                     (NOT (LISTP Y))
                     (EQUAL Y NIL)
                     (EQUAL X Z)
                     (PLISTP (CDR X))
                     (NUMBERP (CAR X))
                     (NOT (NUMBERP (CADR X)))
                     (ALTERNATING-COLORS (CDR X))
                     (EVEN-LENGTH X))
                (PAIRED-COLORS (APPEND (CDR X) (LIST (CAR X))))),

  which again simplifies, applying CDR-CONS, and expanding the functions EQUAL,
  LISTP, SHUFFLEP, CDR, APPEND, and ALTERNATING-COLORS, to:

        T.

Case 69.(IMPLIES
                (AND (LISTP Z)
                     (EQUAL (CAR X) (CAR Z))
                     (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                     (NOT (EQUAL (CAR Y) (CAR X)))
                     (NOT (OPPOSITE-COLOR (CAR X) (CADR Y)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP X)
                     (NOT (LISTP Y))
                     (EQUAL Y NIL)
                     (EQUAL X Z)
                     (PLISTP (CDR X))
                     (NUMBERP (CAR X))
                     (NOT (NUMBERP (CADR X)))
                     (ALTERNATING-COLORS (CDR X))
                     (EVEN-LENGTH X))
                (PAIRED-COLORS (APPEND (CDR X) (LIST (CAR X))))).

  However this again simplifies, rewriting with CDR-CONS, and opening up the
  definitions of EQUAL, LISTP, SHUFFLEP, CAR, CDR, NUMBERP, OPPOSITE-COLOR,
  APPEND, and ALTERNATING-COLORS, to:

        T.

Case 68.(IMPLIES
                (AND (LISTP Z)
                     (EQUAL (CAR X) (CAR Z))
                     (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                     (NOT (EQUAL (CAR Y) (CAR X)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))
                     (NOT (LISTP X))
                     (EQUAL X NIL)
                     (EQUAL Y Z)
                     (PLISTP (CDR Y))
                     (NUMBERP (CAR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Y) (LIST (CAR Y))))).

  This again simplifies, clearly, to:

        T.

Case 67.(IMPLIES
                (AND (LISTP Z)
                     (EQUAL (CAR X) (CAR Z))
                     (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                     (NOT (EQUAL (CAR Y) (CAR X)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (NOT (LISTP X))
                     (EQUAL X NIL)
                     (EQUAL Y Z)
                     (PLISTP (CDR Y))
                     (NUMBERP (CAR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Y) (LIST (CAR Y))))).

  This again simplifies, trivially, to:

        T.

Case 66.(IMPLIES
                (AND (LISTP Z)
                     (EQUAL (CAR X) (CAR Z))
                     (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                     (NOT (EQUAL (CAR Y) (CAR X)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP X)
                     (NOT (LISTP Y))
                     (EQUAL Y NIL)
                     (EQUAL X Z)
                     (PLISTP (CDR X))
                     (NUMBERP (CAR X))
                     (NOT (NUMBERP (CADR X)))
                     (ALTERNATING-COLORS (CDR X))
                     (EVEN-LENGTH X))
                (PAIRED-COLORS (APPEND (CDR X) (LIST (CAR X))))).

  But this again simplifies, unfolding the definitions of EQUAL, LISTP,
  SHUFFLEP, CAR, CDR, CONS, APPEND, and ALTERNATING-COLORS, to:

        T.

Case 65.(IMPLIES
                (AND (LISTP Z)
                     (EQUAL (CAR X) (CAR Z))
                     (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                     (NOT (EQUAL (CAR Y) (CAR X)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                                    Y
                                    (APPEND (CDR Z) (LIST (CAR X)))))
                     (NOT (LISTP X))
                     (EQUAL X NIL)
                     (EQUAL Y Z)
                     (PLISTP (CDR Y))
                     (NUMBERP (CAR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Y) (LIST (CAR Y))))),

  which again simplifies, clearly, to:

        T.

Case 64.(IMPLIES
                (AND (LISTP Z)
                     (EQUAL (CAR X) (CAR Z))
                     (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                     (NOT (EQUAL (CAR Y) (CAR X)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (LISTP (CDR X))
                     (NUMBERP (CADR X))
                     (NUMBERP (CAR Y))
                     (NOT (LISTP X))
                     (EQUAL X NIL)
                     (EQUAL Y Z)
                     (PLISTP (CDR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Y) (LIST (CAR Y))))).

  This again simplifies, clearly, to:

        T.

Case 63.(IMPLIES
                (AND (LISTP Z)
                     (EQUAL (CAR X) (CAR Z))
                     (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                     (NOT (EQUAL (CAR Y) (CAR X)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (LISTP (CDR X)))
                     (NUMBERP (CAR X))
                     (NUMBERP (CAR Y))
                     (NOT (LISTP X))
                     (EQUAL X NIL)
                     (EQUAL Y Z)
                     (PLISTP (CDR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Y) (LIST (CAR Y))))).

  This again simplifies, trivially, to:

        T.

Case 62.(IMPLIES
                (AND (LISTP Z)
                     (EQUAL (CAR X) (CAR Z))
                     (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                     (NOT (EQUAL (CAR Y) (CAR X)))
                     (NOT (SHUFFLEP X
                                    (APPEND (CDR Y) (LIST (CAR Y)))
                                    (APPEND (CDR Z) (LIST (CAR X)))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP X)
                     (NOT (LISTP Y))
                     (EQUAL Y NIL)
                     (EQUAL X Z)
                     (PLISTP (CDR X))
                     (NUMBERP (CAR X))
                     (NOT (NUMBERP (CADR X)))
                     (ALTERNATING-COLORS (CDR X))
                     (EVEN-LENGTH X))
                (PAIRED-COLORS (APPEND (CDR X) (LIST (CAR X))))).

  This again simplifies, rewriting with CDR-CONS and CAR-CONS, and expanding
  the definitions of EQUAL, LISTP, SHUFFLEP, CAR, CDR, CONS, APPEND, and
  ALTERNATING-COLORS, to:

        T.

Case 61.(IMPLIES
                (AND (LISTP Z)
                     (EQUAL (CAR X) (CAR Z))
                     (NOT (SHUFFLEP (CDR X) Y (CDR Z)))
                     (NOT (EQUAL (CAR Y) (CAR X)))
                     (NOT (LISTP (CDR Y)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP X)
                     (NOT (LISTP Y))
                     (EQUAL Y NIL)
                     (EQUAL X Z)
                     (PLISTP (CDR X))
                     (NUMBERP (CAR X))
                     (NOT (NUMBERP (CADR X)))
                     (ALTERNATING-COLORS (CDR X))
                     (EVEN-LENGTH X))
                (PAIRED-COLORS (APPEND (CDR X) (LIST (CAR X))))).

  This again simplifies, rewriting with CDR-CONS, and unfolding the
  definitions of EQUAL, LISTP, SHUFFLEP, CAR, CDR, APPEND, and
  ALTERNATING-COLORS, to:

        T.

Case 60.(IMPLIES
                (AND (LISTP Z)
                     (NOT (EQUAL (CAR X) (CAR Z)))
                     (NOT (EQUAL (CAR Y) (CAR Z)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (NOT (LISTP X))
                     (EQUAL X NIL)
                     (EQUAL Y Z)
                     (PLISTP (CDR Y))
                     (NUMBERP (CAR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Y) (LIST (CAR Y))))).

  This again simplifies, clearly, to:

        T.

Case 59.(IMPLIES
                (AND (LISTP Z)
                     (NOT (EQUAL (CAR X) (CAR Z)))
                     (NOT (EQUAL (CAR Y) (CAR Z)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                                    Y
                                    (APPEND (CDR Z) (LIST (CAR Z)))))
                     (NOT (LISTP X))
                     (EQUAL X NIL)
                     (EQUAL Y Z)
                     (PLISTP (CDR Y))
                     (NUMBERP (CAR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Y) (LIST (CAR Y))))).

  This again simplifies, trivially, to:

        T.

Case 58.(IMPLIES
                (AND (LISTP Z)
                     (NOT (EQUAL (CAR X) (CAR Z)))
                     (NOT (EQUAL (CAR Y) (CAR Z)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (LISTP (CDR X))
                     (NUMBERP (CADR X))
                     (NUMBERP (CAR Y))
                     (NOT (LISTP X))
                     (EQUAL X NIL)
                     (EQUAL Y Z)
                     (PLISTP (CDR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Y) (LIST (CAR Y))))).

  This again simplifies, obviously, to:

        T.

Case 57.(IMPLIES
                (AND (LISTP Z)
                     (NOT (EQUAL (CAR X) (CAR Z)))
                     (NOT (EQUAL (CAR Y) (CAR Z)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (LISTP (CDR X)))
                     (NUMBERP (CAR X))
                     (NUMBERP (CAR Y))
                     (NOT (LISTP X))
                     (EQUAL X NIL)
                     (EQUAL Y Z)
                     (PLISTP (CDR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Y) (LIST (CAR Y))))).

  This again simplifies, trivially, to:

        T.

Case 56.(IMPLIES
                (AND (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                               Y
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (OPPOSITE-COLOR (CAR X) (CADR Y)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (NOT (LISTP Y))
                     (EQUAL Y NIL)
                     (EQUAL X Z)
                     (PLISTP (CDR X))
                     (NUMBERP (CAR X))
                     (NOT (NUMBERP (CADR X)))
                     (ALTERNATING-COLORS (CDR X))
                     (EVEN-LENGTH X))
                (PAIRED-COLORS (APPEND (CDR X) (LIST (CAR X))))).

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

        T.

Case 55.(IMPLIES
                (AND (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                               Y
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (OPPOSITE-COLOR (CAR X) (CADR Y)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (EQUAL (CAR X) (CAR Z))
                     (SHUFFLEP (CDR X) Y (CDR Z))
                     (NUMBERP (CAR X))
                     (NOT (NUMBERP (CADR X)))
                     (ALTERNATING-COLORS (CDR X))
                     (NUMBERP (CAR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))).

  This again simplifies, appealing to the lemmas CDR-CONS and F5, and
  expanding the definitions of PLISTP and OPPOSITE-COLOR, to:

        T.

Case 54.(IMPLIES
                (AND (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                               Y
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (OPPOSITE-COLOR (CAR X) (CADR Y)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (EQUAL (CAR X) (CAR Z))
                     (SHUFFLEP (CDR X) Y (CDR Z))
                     (NOT (NUMBERP (CAR X)))
                     (NUMBERP (CADR X))
                     (ALTERNATING-COLORS (CDR X))
                     (NOT (NUMBERP (CAR Y)))
                     (NUMBERP (CADR Y))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))),

  which again simplifies, rewriting with CDR-CONS and F5, and expanding the
  definitions of PLISTP and OPPOSITE-COLOR, to:

        T.

Case 53.(IMPLIES
                (AND (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                               Y
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (OPPOSITE-COLOR (CAR X) (CADR Y)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (EQUAL (CAR X) (CAR Z))
                     (EQUAL (CAR Y) (CAR X))
                     (SHUFFLEP X (CDR Y) (CDR Z))
                     (NUMBERP (CAR X))
                     (NOT (NUMBERP (CADR X)))
                     (ALTERNATING-COLORS (CDR X))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))).

  This again simplifies, opening up the definition of OPPOSITE-COLOR, to:

        T.

Case 52.(IMPLIES
                (AND (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                               Y
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (OPPOSITE-COLOR (CAR X) (CADR Y)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (EQUAL (CAR X) (CAR Z))
                     (EQUAL (CAR Y) (CAR X))
                     (SHUFFLEP X (CDR Y) (CDR Z))
                     (NOT (NUMBERP (CAR X)))
                     (NUMBERP (CADR X))
                     (ALTERNATING-COLORS (CDR X))
                     (NUMBERP (CADR Y))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))),

  which again simplifies, unfolding the definition of OPPOSITE-COLOR, to:

        T.

Case 51.(IMPLIES
                (AND (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                               Y
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (OPPOSITE-COLOR (CAR X) (CADR Y)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (NOT (EQUAL (CAR X) (CAR Z)))
                     (EQUAL (CAR Y) (CAR Z))
                     (SHUFFLEP X (CDR Y) (CDR Z))
                     (NUMBERP (CAR X))
                     (NOT (NUMBERP (CADR X)))
                     (ALTERNATING-COLORS (CDR X))
                     (NUMBERP (CAR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR Y))))),

  which again simplifies, unfolding the definition of OPPOSITE-COLOR, to:

        T.

Case 50.(IMPLIES
                (AND (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                               Y
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (OPPOSITE-COLOR (CAR X) (CADR Y)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (NOT (EQUAL (CAR X) (CAR Z)))
                     (EQUAL (CAR Y) (CAR Z))
                     (SHUFFLEP X (CDR Y) (CDR Z))
                     (NOT (NUMBERP (CAR X)))
                     (NUMBERP (CADR X))
                     (ALTERNATING-COLORS (CDR X))
                     (NOT (NUMBERP (CAR Y)))
                     (NUMBERP (CADR Y))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR Y))))),

  which again simplifies, expanding the function OPPOSITE-COLOR, to:

        T.

Case 49.(IMPLIES
                (AND (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                               Y
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (NOT (LISTP Y))
                     (EQUAL Y NIL)
                     (EQUAL X Z)
                     (PLISTP (CDR X))
                     (NUMBERP (CAR X))
                     (NOT (NUMBERP (CADR X)))
                     (ALTERNATING-COLORS (CDR X))
                     (EVEN-LENGTH X))
                (PAIRED-COLORS (APPEND (CDR X) (LIST (CAR X))))),

  which again simplifies, unfolding the definitions of EQUAL, LISTP, SHUFFLEP,
  CDR, CAR, CONS, APPEND, and ALTERNATING-COLORS, to:

        T.

Case 48.(IMPLIES
                (AND (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                               Y
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (EQUAL (CAR X) (CAR Z))
                     (SHUFFLEP (CDR X) Y (CDR Z))
                     (NUMBERP (CAR X))
                     (NOT (NUMBERP (CADR X)))
                     (ALTERNATING-COLORS (CDR X))
                     (NUMBERP (CAR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))),

  which again simplifies, rewriting with CDR-CONS, F5, and F6, and unfolding
  the definitions of PLISTP, ALTERNATING-COLORS, and OPPOSITE-COLOR, to:

        T.

Case 47.(IMPLIES
                (AND (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                               Y
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (EQUAL (CAR X) (CAR Z))
                     (SHUFFLEP (CDR X) Y (CDR Z))
                     (NOT (NUMBERP (CAR X)))
                     (NUMBERP (CADR X))
                     (ALTERNATING-COLORS (CDR X))
                     (NOT (NUMBERP (CAR Y)))
                     (NUMBERP (CADR Y))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))).

  This again simplifies, rewriting with CDR-CONS, F5, and F6, and expanding
  the definitions of PLISTP, ALTERNATING-COLORS, and OPPOSITE-COLOR, to:

        T.

Case 46.(IMPLIES
                (AND (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                               Y
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (EQUAL (CAR X) (CAR Z))
                     (EQUAL (CAR Y) (CAR X))
                     (SHUFFLEP X (CDR Y) (CDR Z))
                     (NUMBERP (CAR X))
                     (NOT (NUMBERP (CADR X)))
                     (ALTERNATING-COLORS (CDR X))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))).

  However this again simplifies, rewriting with the lemma F6, and unfolding
  ALTERNATING-COLORS and OPPOSITE-COLOR, to:

        T.

Case 45.(IMPLIES
                (AND (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                               Y
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (EQUAL (CAR X) (CAR Z))
                     (EQUAL (CAR Y) (CAR X))
                     (SHUFFLEP X (CDR Y) (CDR Z))
                     (NOT (NUMBERP (CAR X)))
                     (NUMBERP (CADR X))
                     (ALTERNATING-COLORS (CDR X))
                     (NUMBERP (CADR Y))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))),

  which again simplifies, rewriting with F6, and opening up the functions
  ALTERNATING-COLORS and OPPOSITE-COLOR, to:

        T.

Case 44.(IMPLIES
                (AND (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                               Y
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (NOT (EQUAL (CAR X) (CAR Z)))
                     (EQUAL (CAR Y) (CAR Z))
                     (SHUFFLEP X (CDR Y) (CDR Z))
                     (NUMBERP (CAR X))
                     (NOT (NUMBERP (CADR X)))
                     (ALTERNATING-COLORS (CDR X))
                     (NUMBERP (CAR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR Y))))).

  But this again simplifies, rewriting with F6, and expanding the functions
  ALTERNATING-COLORS and OPPOSITE-COLOR, to:

        T.

Case 43.(IMPLIES
                (AND (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                               Y
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (NOT (EQUAL (CAR X) (CAR Z)))
                     (EQUAL (CAR Y) (CAR Z))
                     (SHUFFLEP X (CDR Y) (CDR Z))
                     (NOT (NUMBERP (CAR X)))
                     (NUMBERP (CADR X))
                     (ALTERNATING-COLORS (CDR X))
                     (NOT (NUMBERP (CAR Y)))
                     (NUMBERP (CADR Y))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR Y))))).

  But this again simplifies, applying the lemma F6, and expanding the
  functions ALTERNATING-COLORS and OPPOSITE-COLOR, to:

        T.

Case 42.(IMPLIES
                (AND (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                               Y
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (NOT (LISTP X))
                     (EQUAL X NIL)
                     (EQUAL Y Z)
                     (PLISTP (CDR Y))
                     (NUMBERP (CAR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Y) (LIST (CAR Y))))),

  which again simplifies, appealing to the lemma F6, and unfolding CDR, CAR,
  CONS, APPEND, ALTERNATING-COLORS, and OPPOSITE-COLOR, to:

        T.

Case 41.(IMPLIES
                (AND (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                               Y
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (LISTP (CDR X))
                     (NUMBERP (CADR X))
                     (NUMBERP (CAR Y))
                     (LISTP Z)
                     (NOT (LISTP X))
                     (EQUAL X NIL)
                     (EQUAL Y Z)
                     (PLISTP (CDR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Y) (LIST (CAR Y))))),

  which again simplifies, rewriting with the lemma F6, and expanding the
  functions CDR, CAR, CONS, APPEND, ALTERNATING-COLORS, and OPPOSITE-COLOR, to:

        T.

Case 40.(IMPLIES
                (AND (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                               Y
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (LISTP (CDR X)))
                     (NUMBERP (CAR X))
                     (NUMBERP (CAR Y))
                     (LISTP Z)
                     (NOT (LISTP X))
                     (EQUAL X NIL)
                     (EQUAL Y Z)
                     (PLISTP (CDR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Y) (LIST (CAR Y))))),

  which again simplifies, applying the lemma F6, and opening up the
  definitions of CDR, CAR, CONS, APPEND, ALTERNATING-COLORS, and
  OPPOSITE-COLOR, to:

        T.

Case 39.(IMPLIES
                (AND (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                               Y
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (SHUFFLEP X
                                    (APPEND (CDR Y) (LIST (CAR Y)))
                                    (APPEND (CDR Z) (LIST (CAR Z)))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (NOT (LISTP Y))
                     (EQUAL Y NIL)
                     (EQUAL X Z)
                     (PLISTP (CDR X))
                     (NUMBERP (CAR X))
                     (NOT (NUMBERP (CADR X)))
                     (ALTERNATING-COLORS (CDR X))
                     (EVEN-LENGTH X))
                (PAIRED-COLORS (APPEND (CDR X) (LIST (CAR X))))),

  which again simplifies, rewriting with F6, and opening up the functions
  EQUAL, LISTP, SHUFFLEP, CDR, CAR, CONS, APPEND, ALTERNATING-COLORS, and
  OPPOSITE-COLOR, to:

        T.

Case 38.(IMPLIES
                (AND (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                               Y
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (SHUFFLEP X
                                    (APPEND (CDR Y) (LIST (CAR Y)))
                                    (APPEND (CDR Z) (LIST (CAR Z)))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (EQUAL (CAR X) (CAR Z))
                     (SHUFFLEP (CDR X) Y (CDR Z))
                     (NUMBERP (CAR X))
                     (NOT (NUMBERP (CADR X)))
                     (ALTERNATING-COLORS (CDR X))
                     (NUMBERP (CAR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))).

  But this again simplifies, rewriting with CDR-CONS, F5, and F6, and opening
  up the functions PLISTP, ALTERNATING-COLORS, and OPPOSITE-COLOR, to:

        T.

Case 37.(IMPLIES
                (AND (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                               Y
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (SHUFFLEP X
                                    (APPEND (CDR Y) (LIST (CAR Y)))
                                    (APPEND (CDR Z) (LIST (CAR Z)))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (EQUAL (CAR X) (CAR Z))
                     (SHUFFLEP (CDR X) Y (CDR Z))
                     (NOT (NUMBERP (CAR X)))
                     (NUMBERP (CADR X))
                     (ALTERNATING-COLORS (CDR X))
                     (NOT (NUMBERP (CAR Y)))
                     (NUMBERP (CADR Y))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))).

  But this again simplifies, applying CDR-CONS, F5, and F6, and opening up the
  functions PLISTP, ALTERNATING-COLORS, and OPPOSITE-COLOR, to:

        T.

Case 36.(IMPLIES
                (AND (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                               Y
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (SHUFFLEP X
                                    (APPEND (CDR Y) (LIST (CAR Y)))
                                    (APPEND (CDR Z) (LIST (CAR Z)))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (EQUAL (CAR X) (CAR Z))
                     (EQUAL (CAR Y) (CAR X))
                     (SHUFFLEP X (CDR Y) (CDR Z))
                     (NUMBERP (CAR X))
                     (NOT (NUMBERP (CADR X)))
                     (ALTERNATING-COLORS (CDR X))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))).

  But this again simplifies, applying CDR-CONS and F4, and expanding the
  function PLISTP, to:

        T.

Case 35.(IMPLIES
                (AND (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                               Y
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (SHUFFLEP X
                                    (APPEND (CDR Y) (LIST (CAR Y)))
                                    (APPEND (CDR Z) (LIST (CAR Z)))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (EQUAL (CAR X) (CAR Z))
                     (EQUAL (CAR Y) (CAR X))
                     (SHUFFLEP X (CDR Y) (CDR Z))
                     (NOT (NUMBERP (CAR X)))
                     (NUMBERP (CADR X))
                     (ALTERNATING-COLORS (CDR X))
                     (NUMBERP (CADR Y))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))).

  This again simplifies, applying CDR-CONS and F4, and unfolding the
  definition of PLISTP, to:

        T.

Case 34.(IMPLIES
                (AND (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                               Y
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (SHUFFLEP X
                                    (APPEND (CDR Y) (LIST (CAR Y)))
                                    (APPEND (CDR Z) (LIST (CAR Z)))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (NOT (EQUAL (CAR X) (CAR Z)))
                     (EQUAL (CAR Y) (CAR Z))
                     (SHUFFLEP X (CDR Y) (CDR Z))
                     (NUMBERP (CAR X))
                     (NOT (NUMBERP (CADR X)))
                     (ALTERNATING-COLORS (CDR X))
                     (NUMBERP (CAR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR Y))))).

  However this again simplifies, rewriting with CDR-CONS and F4, and expanding
  the definition of PLISTP, to:

        T.

Case 33.(IMPLIES
                (AND (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                               Y
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (SHUFFLEP X
                                    (APPEND (CDR Y) (LIST (CAR Y)))
                                    (APPEND (CDR Z) (LIST (CAR Z)))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (NOT (EQUAL (CAR X) (CAR Z)))
                     (EQUAL (CAR Y) (CAR Z))
                     (SHUFFLEP X (CDR Y) (CDR Z))
                     (NOT (NUMBERP (CAR X)))
                     (NUMBERP (CADR X))
                     (ALTERNATING-COLORS (CDR X))
                     (NOT (NUMBERP (CAR Y)))
                     (NUMBERP (CADR Y))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR Y))))).

  However this again simplifies, rewriting with CDR-CONS and F4, and expanding
  the function PLISTP, to:

        T.

Case 32.(IMPLIES
                (AND (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                               Y
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (LISTP (CDR Y)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (NOT (LISTP Y))
                     (EQUAL Y NIL)
                     (EQUAL X Z)
                     (PLISTP (CDR X))
                     (NUMBERP (CAR X))
                     (NOT (NUMBERP (CADR X)))
                     (ALTERNATING-COLORS (CDR X))
                     (EVEN-LENGTH X))
                (PAIRED-COLORS (APPEND (CDR X) (LIST (CAR X))))).

  But this again simplifies, rewriting with F6, and opening up the definitions
  of EQUAL, LISTP, SHUFFLEP, CDR, ALTERNATING-COLORS, and OPPOSITE-COLOR, to:

        T.

Case 31.(IMPLIES
                (AND (SHUFFLEP X
                               (APPEND (CDR Y) (LIST (CAR Y)))
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (OPPOSITE-COLOR (CAR X) (CADR Y)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (NOT (LISTP Y))
                     (EQUAL Y NIL)
                     (EQUAL X Z)
                     (PLISTP (CDR X))
                     (NUMBERP (CAR X))
                     (NOT (NUMBERP (CADR X)))
                     (ALTERNATING-COLORS (CDR X))
                     (EVEN-LENGTH X))
                (PAIRED-COLORS (APPEND (CDR X) (LIST (CAR X))))).

  However this again simplifies, appealing to the lemma F6, and opening up the
  definitions of CDR, CAR, CONS, APPEND, NUMBERP, OPPOSITE-COLOR, and
  ALTERNATING-COLORS, to:

        T.

Case 30.(IMPLIES
                (AND (SHUFFLEP X
                               (APPEND (CDR Y) (LIST (CAR Y)))
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (OPPOSITE-COLOR (CAR X) (CADR Y)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (EQUAL (CAR X) (CAR Z))
                     (SHUFFLEP (CDR X) Y (CDR Z))
                     (NUMBERP (CAR X))
                     (NOT (NUMBERP (CADR X)))
                     (ALTERNATING-COLORS (CDR X))
                     (NUMBERP (CAR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))),

  which again simplifies, expanding OPPOSITE-COLOR, to:

        T.

Case 29.(IMPLIES
                (AND (SHUFFLEP X
                               (APPEND (CDR Y) (LIST (CAR Y)))
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (OPPOSITE-COLOR (CAR X) (CADR Y)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (EQUAL (CAR X) (CAR Z))
                     (SHUFFLEP (CDR X) Y (CDR Z))
                     (NOT (NUMBERP (CAR X)))
                     (NUMBERP (CADR X))
                     (ALTERNATING-COLORS (CDR X))
                     (NOT (NUMBERP (CAR Y)))
                     (NUMBERP (CADR Y))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))),

  which again simplifies, expanding the definition of OPPOSITE-COLOR, to:

        T.

Case 28.(IMPLIES
                (AND (SHUFFLEP X
                               (APPEND (CDR Y) (LIST (CAR Y)))
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (OPPOSITE-COLOR (CAR X) (CADR Y)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (EQUAL (CAR X) (CAR Z))
                     (EQUAL (CAR Y) (CAR X))
                     (SHUFFLEP X (CDR Y) (CDR Z))
                     (NUMBERP (CAR X))
                     (NOT (NUMBERP (CADR X)))
                     (ALTERNATING-COLORS (CDR X))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))),

  which again simplifies, appealing to the lemmas CDR-CONS and F4, and opening
  up the definitions of PLISTP and OPPOSITE-COLOR, to:

        T.

Case 27.(IMPLIES
                (AND (SHUFFLEP X
                               (APPEND (CDR Y) (LIST (CAR Y)))
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (OPPOSITE-COLOR (CAR X) (CADR Y)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (EQUAL (CAR X) (CAR Z))
                     (EQUAL (CAR Y) (CAR X))
                     (SHUFFLEP X (CDR Y) (CDR Z))
                     (NOT (NUMBERP (CAR X)))
                     (NUMBERP (CADR X))
                     (ALTERNATING-COLORS (CDR X))
                     (NUMBERP (CADR Y))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))),

  which again simplifies, applying CDR-CONS and F4, and unfolding PLISTP and
  OPPOSITE-COLOR, to:

        T.

Case 26.(IMPLIES
                (AND (SHUFFLEP X
                               (APPEND (CDR Y) (LIST (CAR Y)))
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (OPPOSITE-COLOR (CAR X) (CADR Y)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (NOT (EQUAL (CAR X) (CAR Z)))
                     (EQUAL (CAR Y) (CAR Z))
                     (SHUFFLEP X (CDR Y) (CDR Z))
                     (NUMBERP (CAR X))
                     (NOT (NUMBERP (CADR X)))
                     (ALTERNATING-COLORS (CDR X))
                     (NUMBERP (CAR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR Y))))).

  However this again simplifies, applying CDR-CONS and F4, and unfolding the
  definitions of PLISTP and OPPOSITE-COLOR, to:

        T.

Case 25.(IMPLIES
                (AND (SHUFFLEP X
                               (APPEND (CDR Y) (LIST (CAR Y)))
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (OPPOSITE-COLOR (CAR X) (CADR Y)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (NOT (EQUAL (CAR X) (CAR Z)))
                     (EQUAL (CAR Y) (CAR Z))
                     (SHUFFLEP X (CDR Y) (CDR Z))
                     (NOT (NUMBERP (CAR X)))
                     (NUMBERP (CADR X))
                     (ALTERNATING-COLORS (CDR X))
                     (NOT (NUMBERP (CAR Y)))
                     (NUMBERP (CADR Y))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR Y))))).

  This again simplifies, applying the lemmas CDR-CONS and F4, and opening up
  the functions PLISTP and OPPOSITE-COLOR, to:

        T.

Case 24.(IMPLIES (AND (SHUFFLEP X
                                (APPEND (CDR Y) (LIST (CAR Y)))
                                (APPEND (CDR Z) (LIST (CAR Z))))
                      (NOT (OPPOSITE-COLOR (CAR X) (CADR Y)))
                      (NOT (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                                     Y
                                     (APPEND (CDR Z) (LIST (CAR Z)))))
                      (LISTP Z)
                      (LISTP X)
                      (LISTP Y)
                      (EQUAL (CAR X) (CAR Z))
                      (SHUFFLEP (CDR X) Y (CDR Z))
                      (NUMBERP (CAR X))
                      (NOT (NUMBERP (CADR X)))
                      (ALTERNATING-COLORS (CDR X))
                      (NUMBERP (CAR Y))
                      (NOT (NUMBERP (CADR Y)))
                      (ALTERNATING-COLORS (CDR Y))
                      (EVEN-LENGTH X)
                      (EVEN-LENGTH Y))
                 (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))),

  which again simplifies, expanding the function OPPOSITE-COLOR, to:

        T.

Case 23.(IMPLIES (AND (SHUFFLEP X
                                (APPEND (CDR Y) (LIST (CAR Y)))
                                (APPEND (CDR Z) (LIST (CAR Z))))
                      (NOT (OPPOSITE-COLOR (CAR X) (CADR Y)))
                      (NOT (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                                     Y
                                     (APPEND (CDR Z) (LIST (CAR Z)))))
                      (LISTP Z)
                      (LISTP X)
                      (LISTP Y)
                      (EQUAL (CAR X) (CAR Z))
                      (SHUFFLEP (CDR X) Y (CDR Z))
                      (NOT (NUMBERP (CAR X)))
                      (NUMBERP (CADR X))
                      (ALTERNATING-COLORS (CDR X))
                      (NOT (NUMBERP (CAR Y)))
                      (NUMBERP (CADR Y))
                      (ALTERNATING-COLORS (CDR Y))
                      (EVEN-LENGTH X)
                      (EVEN-LENGTH Y))
                 (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))),

  which again simplifies, unfolding the definition of OPPOSITE-COLOR, to:

        T.

Case 22.(IMPLIES (AND (SHUFFLEP X
                                (APPEND (CDR Y) (LIST (CAR Y)))
                                (APPEND (CDR Z) (LIST (CAR Z))))
                      (NOT (OPPOSITE-COLOR (CAR X) (CADR Y)))
                      (NOT (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                                     Y
                                     (APPEND (CDR Z) (LIST (CAR Z)))))
                      (LISTP Z)
                      (LISTP X)
                      (LISTP Y)
                      (EQUAL (CAR X) (CAR Z))
                      (EQUAL (CAR Y) (CAR X))
                      (SHUFFLEP X (CDR Y) (CDR Z))
                      (NUMBERP (CAR X))
                      (NOT (NUMBERP (CADR X)))
                      (ALTERNATING-COLORS (CDR X))
                      (NOT (NUMBERP (CADR Y)))
                      (ALTERNATING-COLORS (CDR Y))
                      (EVEN-LENGTH X)
                      (EVEN-LENGTH Y))
                 (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))),

  which again simplifies, applying CDR-CONS and F4, and unfolding the
  definitions of PLISTP and OPPOSITE-COLOR, to:

        T.

Case 21.(IMPLIES (AND (SHUFFLEP X
                                (APPEND (CDR Y) (LIST (CAR Y)))
                                (APPEND (CDR Z) (LIST (CAR Z))))
                      (NOT (OPPOSITE-COLOR (CAR X) (CADR Y)))
                      (NOT (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                                     Y
                                     (APPEND (CDR Z) (LIST (CAR Z)))))
                      (LISTP Z)
                      (LISTP X)
                      (LISTP Y)
                      (EQUAL (CAR X) (CAR Z))
                      (EQUAL (CAR Y) (CAR X))
                      (SHUFFLEP X (CDR Y) (CDR Z))
                      (NOT (NUMBERP (CAR X)))
                      (NUMBERP (CADR X))
                      (ALTERNATING-COLORS (CDR X))
                      (NUMBERP (CADR Y))
                      (ALTERNATING-COLORS (CDR Y))
                      (EVEN-LENGTH X)
                      (EVEN-LENGTH Y))
                 (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))).

  This again simplifies, appealing to the lemmas CDR-CONS and F4, and
  expanding PLISTP and OPPOSITE-COLOR, to:

        T.

Case 20.(IMPLIES (AND (SHUFFLEP X
                                (APPEND (CDR Y) (LIST (CAR Y)))
                                (APPEND (CDR Z) (LIST (CAR Z))))
                      (NOT (OPPOSITE-COLOR (CAR X) (CADR Y)))
                      (NOT (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                                     Y
                                     (APPEND (CDR Z) (LIST (CAR Z)))))
                      (LISTP Z)
                      (LISTP X)
                      (LISTP Y)
                      (NOT (EQUAL (CAR X) (CAR Z)))
                      (EQUAL (CAR Y) (CAR Z))
                      (SHUFFLEP X (CDR Y) (CDR Z))
                      (NUMBERP (CAR X))
                      (NOT (NUMBERP (CADR X)))
                      (ALTERNATING-COLORS (CDR X))
                      (NUMBERP (CAR Y))
                      (NOT (NUMBERP (CADR Y)))
                      (ALTERNATING-COLORS (CDR Y))
                      (EVEN-LENGTH X)
                      (EVEN-LENGTH Y))
                 (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR Y))))),

  which again simplifies, appealing to the lemmas CDR-CONS and F4, and opening
  up PLISTP and OPPOSITE-COLOR, to:

        T.

Case 19.(IMPLIES (AND (SHUFFLEP X
                                (APPEND (CDR Y) (LIST (CAR Y)))
                                (APPEND (CDR Z) (LIST (CAR Z))))
                      (NOT (OPPOSITE-COLOR (CAR X) (CADR Y)))
                      (NOT (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                                     Y
                                     (APPEND (CDR Z) (LIST (CAR Z)))))
                      (LISTP Z)
                      (LISTP X)
                      (LISTP Y)
                      (NOT (EQUAL (CAR X) (CAR Z)))
                      (EQUAL (CAR Y) (CAR Z))
                      (SHUFFLEP X (CDR Y) (CDR Z))
                      (NOT (NUMBERP (CAR X)))
                      (NUMBERP (CADR X))
                      (ALTERNATING-COLORS (CDR X))
                      (NOT (NUMBERP (CAR Y)))
                      (NUMBERP (CADR Y))
                      (ALTERNATING-COLORS (CDR Y))
                      (EVEN-LENGTH X)
                      (EVEN-LENGTH Y))
                 (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR Y))))),

  which again simplifies, applying the lemmas CDR-CONS and F4, and opening up
  PLISTP and OPPOSITE-COLOR, to:

        T.

Case 18.(IMPLIES
                (AND (SHUFFLEP X
                               (APPEND (CDR Y) (LIST (CAR Y)))
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (NOT (LISTP Y))
                     (EQUAL Y NIL)
                     (EQUAL X Z)
                     (PLISTP (CDR X))
                     (NUMBERP (CAR X))
                     (NOT (NUMBERP (CADR X)))
                     (ALTERNATING-COLORS (CDR X))
                     (EVEN-LENGTH X))
                (PAIRED-COLORS (APPEND (CDR X) (LIST (CAR X))))),

  which again simplifies, expanding CDR, CAR, CONS, APPEND, and
  ALTERNATING-COLORS, to:

        T.

Case 17.(IMPLIES
                (AND (SHUFFLEP X
                               (APPEND (CDR Y) (LIST (CAR Y)))
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (EQUAL (CAR X) (CAR Z))
                     (SHUFFLEP (CDR X) Y (CDR Z))
                     (NUMBERP (CAR X))
                     (NOT (NUMBERP (CADR X)))
                     (ALTERNATING-COLORS (CDR X))
                     (NUMBERP (CAR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))),

  which again simplifies, rewriting with F6, and expanding the functions
  ALTERNATING-COLORS and OPPOSITE-COLOR, to:

        T.

Case 16.(IMPLIES
                (AND (SHUFFLEP X
                               (APPEND (CDR Y) (LIST (CAR Y)))
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (EQUAL (CAR X) (CAR Z))
                     (SHUFFLEP (CDR X) Y (CDR Z))
                     (NOT (NUMBERP (CAR X)))
                     (NUMBERP (CADR X))
                     (ALTERNATING-COLORS (CDR X))
                     (NOT (NUMBERP (CAR Y)))
                     (NUMBERP (CADR Y))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))).

  However this again simplifies, appealing to the lemma F6, and unfolding
  ALTERNATING-COLORS and OPPOSITE-COLOR, to:

        T.

Case 15.(IMPLIES
                (AND (SHUFFLEP X
                               (APPEND (CDR Y) (LIST (CAR Y)))
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (EQUAL (CAR X) (CAR Z))
                     (EQUAL (CAR Y) (CAR X))
                     (SHUFFLEP X (CDR Y) (CDR Z))
                     (NUMBERP (CAR X))
                     (NOT (NUMBERP (CADR X)))
                     (ALTERNATING-COLORS (CDR X))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))),

  which again simplifies, rewriting with CDR-CONS, F4, and F6, and unfolding
  the definitions of PLISTP, ALTERNATING-COLORS, and OPPOSITE-COLOR, to:

        T.

Case 14.(IMPLIES
                (AND (SHUFFLEP X
                               (APPEND (CDR Y) (LIST (CAR Y)))
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (EQUAL (CAR X) (CAR Z))
                     (EQUAL (CAR Y) (CAR X))
                     (SHUFFLEP X (CDR Y) (CDR Z))
                     (NOT (NUMBERP (CAR X)))
                     (NUMBERP (CADR X))
                     (ALTERNATING-COLORS (CDR X))
                     (NUMBERP (CADR Y))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))).

  However this again simplifies, applying the lemmas CDR-CONS, F4, and F6, and
  opening up PLISTP, ALTERNATING-COLORS, and OPPOSITE-COLOR, to:

        T.

Case 13.(IMPLIES
                (AND (SHUFFLEP X
                               (APPEND (CDR Y) (LIST (CAR Y)))
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (NOT (EQUAL (CAR X) (CAR Z)))
                     (EQUAL (CAR Y) (CAR Z))
                     (SHUFFLEP X (CDR Y) (CDR Z))
                     (NUMBERP (CAR X))
                     (NOT (NUMBERP (CADR X)))
                     (ALTERNATING-COLORS (CDR X))
                     (NUMBERP (CAR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR Y))))),

  which again simplifies, rewriting with the lemmas CDR-CONS, F4, and F6, and
  opening up PLISTP, ALTERNATING-COLORS, and OPPOSITE-COLOR, to:

        T.

Case 12.(IMPLIES
                (AND (SHUFFLEP X
                               (APPEND (CDR Y) (LIST (CAR Y)))
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (NOT (EQUAL (CAR X) (CAR Z)))
                     (EQUAL (CAR Y) (CAR Z))
                     (SHUFFLEP X (CDR Y) (CDR Z))
                     (NOT (NUMBERP (CAR X)))
                     (NUMBERP (CADR X))
                     (ALTERNATING-COLORS (CDR X))
                     (NOT (NUMBERP (CAR Y)))
                     (NUMBERP (CADR Y))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR Y))))),

  which again simplifies, rewriting with CDR-CONS, F4, and F6, and expanding
  the functions PLISTP, ALTERNATING-COLORS, and OPPOSITE-COLOR, to:

        T.

Case 11.(IMPLIES
                (AND (SHUFFLEP X
                               (APPEND (CDR Y) (LIST (CAR Y)))
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (NOT (LISTP X))
                     (EQUAL X NIL)
                     (EQUAL Y Z)
                     (PLISTP (CDR Y))
                     (NUMBERP (CAR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Y) (LIST (CAR Y))))).

  This again simplifies, rewriting with F6, and unfolding EQUAL, LISTP,
  SHUFFLEP, ALTERNATING-COLORS, and OPPOSITE-COLOR, to:

        T.

Case 10.(IMPLIES
                (AND (SHUFFLEP X
                               (APPEND (CDR Y) (LIST (CAR Y)))
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                                    Y
                                    (APPEND (CDR Z) (LIST (CAR Z)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (EQUAL (CAR X) (CAR Z))
                     (SHUFFLEP (CDR X) Y (CDR Z))
                     (NUMBERP (CAR X))
                     (NOT (NUMBERP (CADR X)))
                     (ALTERNATING-COLORS (CDR X))
                     (NUMBERP (CAR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))).

  This again simplifies, rewriting with F6, and unfolding the definitions of
  ALTERNATING-COLORS and OPPOSITE-COLOR, to:

        T.

Case 9. (IMPLIES
                (AND (SHUFFLEP X
                               (APPEND (CDR Y) (LIST (CAR Y)))
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                                    Y
                                    (APPEND (CDR Z) (LIST (CAR Z)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (EQUAL (CAR X) (CAR Z))
                     (SHUFFLEP (CDR X) Y (CDR Z))
                     (NOT (NUMBERP (CAR X)))
                     (NUMBERP (CADR X))
                     (ALTERNATING-COLORS (CDR X))
                     (NOT (NUMBERP (CAR Y)))
                     (NUMBERP (CADR Y))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))).

  This again simplifies, applying F6, and opening up the functions
  ALTERNATING-COLORS and OPPOSITE-COLOR, to:

        T.

Case 8. (IMPLIES
                (AND (SHUFFLEP X
                               (APPEND (CDR Y) (LIST (CAR Y)))
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                                    Y
                                    (APPEND (CDR Z) (LIST (CAR Z)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (EQUAL (CAR X) (CAR Z))
                     (EQUAL (CAR Y) (CAR X))
                     (SHUFFLEP X (CDR Y) (CDR Z))
                     (NUMBERP (CAR X))
                     (NOT (NUMBERP (CADR X)))
                     (ALTERNATING-COLORS (CDR X))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))).

  However this again simplifies, applying CDR-CONS and F4, and unfolding
  PLISTP, to:

        (IMPLIES
                (AND (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR X)))))
                     (NOT (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                                    Y
                                    (APPEND (CDR Z) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (EQUAL (CAR X) (CAR Z))
                     (EQUAL (CAR Y) (CAR X))
                     (SHUFFLEP X (CDR Y) (CDR Z))
                     (NUMBERP (CAR X))
                     (NOT (NUMBERP (CADR X)))
                     (ALTERNATING-COLORS (CDR X))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))).

  Applying the lemma CAR-CDR-ELIM, replace Y by (CONS W V) to eliminate
  (CDR Y) and (CAR Y) and V by (CONS D C) to eliminate (CAR V) and (CDR V).
  We would thus like to prove the following two new goals:

  Case 8.2.
          (IMPLIES (AND (NOT (LISTP V))
                        (NOT (ALTERNATING-COLORS (APPEND V (LIST (CAR X)))))
                        (NOT (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                                       (CONS W V)
                                       (APPEND (CDR Z) (LIST (CAR X)))))
                        (LISTP Z)
                        (LISTP X)
                        (EQUAL (CAR X) (CAR Z))
                        (EQUAL W (CAR X))
                        (SHUFFLEP X V (CDR Z))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (ALTERNATING-COLORS (CDR X))
                        (NOT (NUMBERP (CAR V)))
                        (ALTERNATING-COLORS V)
                        (EVEN-LENGTH X)
                        (EVEN-LENGTH (CONS W V)))
                   (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))).

    But this further simplifies, rewriting with the lemma CDR-CONS, and
    opening up the definitions of APPEND, LISTP, and ALTERNATING-COLORS, to:

          T.

  Case 8.1.
          (IMPLIES
             (AND (NOT (ALTERNATING-COLORS (APPEND (CONS D C) (LIST (CAR X)))))
                  (NOT (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                                 (CONS W (CONS D C))
                                 (APPEND (CDR Z) (LIST (CAR X)))))
                  (LISTP Z)
                  (LISTP X)
                  (EQUAL (CAR X) (CAR Z))
                  (EQUAL W (CAR X))
                  (SHUFFLEP X (CONS D C) (CDR Z))
                  (NUMBERP (CAR X))
                  (NOT (NUMBERP (CADR X)))
                  (ALTERNATING-COLORS (CDR X))
                  (NOT (NUMBERP D))
                  (ALTERNATING-COLORS (CONS D C))
                  (EVEN-LENGTH X)
                  (EVEN-LENGTH (CONS W (CONS D C))))
             (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))),

    which further simplifies, rewriting with CDR-CONS, CAR-CONS, and
    CAR-APPEND, and opening up the definitions of APPEND, OPPOSITE-COLOR,
    ALTERNATING-COLORS, and EVEN-LENGTH, to the following two new formulas:

    Case 8.1.2.
            (IMPLIES (AND (NOT (ALTERNATING-COLORS (APPEND C (LIST (CAR X)))))
                          (NOT (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                                         (CONS (CAR X) (CONS D C))
                                         (APPEND (CDR Z) (LIST (CAR X)))))
                          (LISTP Z)
                          (LISTP X)
                          (EQUAL (CAR X) (CAR Z))
                          (SHUFFLEP X (CONS D C) (CDR Z))
                          (NUMBERP (CAR X))
                          (NOT (NUMBERP (CADR X)))
                          (ALTERNATING-COLORS (CDR X))
                          (NOT (NUMBERP D))
                          (NOT (LISTP C))
                          (EVEN-LENGTH X))
                     (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))).

      But this again simplifies, rewriting with the lemma CDR-CONS, and
      opening up APPEND, LISTP, and ALTERNATING-COLORS, to:

            T.

    Case 8.1.1.
            (IMPLIES (AND (NOT (ALTERNATING-COLORS (APPEND C (LIST (CAR X)))))
                          (NOT (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                                         (CONS (CAR X) (CONS D C))
                                         (APPEND (CDR Z) (LIST (CAR X)))))
                          (LISTP Z)
                          (LISTP X)
                          (EQUAL (CAR X) (CAR Z))
                          (SHUFFLEP X (CONS D C) (CDR Z))
                          (NUMBERP (CAR X))
                          (NOT (NUMBERP (CADR X)))
                          (ALTERNATING-COLORS (CDR X))
                          (NOT (NUMBERP D))
                          (NUMBERP (CAR C))
                          (ALTERNATING-COLORS C)
                          (EVEN-LENGTH X)
                          (EVEN-LENGTH C))
                     (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))),

      which again simplifies, applying G19, to:

            T.

Case 7. (IMPLIES
                (AND (SHUFFLEP X
                               (APPEND (CDR Y) (LIST (CAR Y)))
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                                    Y
                                    (APPEND (CDR Z) (LIST (CAR Z)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (EQUAL (CAR X) (CAR Z))
                     (EQUAL (CAR Y) (CAR X))
                     (SHUFFLEP X (CDR Y) (CDR Z))
                     (NOT (NUMBERP (CAR X)))
                     (NUMBERP (CADR X))
                     (ALTERNATING-COLORS (CDR X))
                     (NUMBERP (CADR Y))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))).

  However this again simplifies, applying CDR-CONS and F4, and expanding the
  definition of PLISTP, to:

        (IMPLIES
                (AND (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR X)))))
                     (NOT (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                                    Y
                                    (APPEND (CDR Z) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (EQUAL (CAR X) (CAR Z))
                     (EQUAL (CAR Y) (CAR X))
                     (SHUFFLEP X (CDR Y) (CDR Z))
                     (NOT (NUMBERP (CAR X)))
                     (NUMBERP (CADR X))
                     (ALTERNATING-COLORS (CDR X))
                     (NUMBERP (CADR Y))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))).

  Applying the lemma CAR-CDR-ELIM, replace Y by (CONS W V) to eliminate
  (CDR Y) and (CAR Y) and V by (CONS D C) to eliminate (CAR V) and (CDR V).
  We would thus like to prove the following two new conjectures:

  Case 7.2.
          (IMPLIES (AND (NOT (LISTP V))
                        (NOT (ALTERNATING-COLORS (APPEND V (LIST (CAR X)))))
                        (NOT (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                                       (CONS W V)
                                       (APPEND (CDR Z) (LIST (CAR X)))))
                        (LISTP Z)
                        (LISTP X)
                        (EQUAL (CAR X) (CAR Z))
                        (EQUAL W (CAR X))
                        (SHUFFLEP X V (CDR Z))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (ALTERNATING-COLORS (CDR X))
                        (NUMBERP (CAR V))
                        (ALTERNATING-COLORS V)
                        (EVEN-LENGTH X)
                        (EVEN-LENGTH (CONS W V)))
                   (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))).

    This further simplifies, appealing to the lemma CDR-CONS, and opening up
    the definitions of APPEND, LISTP, and ALTERNATING-COLORS, to:

          T.

  Case 7.1.
          (IMPLIES
             (AND (NOT (ALTERNATING-COLORS (APPEND (CONS D C) (LIST (CAR X)))))
                  (NOT (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                                 (CONS W (CONS D C))
                                 (APPEND (CDR Z) (LIST (CAR X)))))
                  (LISTP Z)
                  (LISTP X)
                  (EQUAL (CAR X) (CAR Z))
                  (EQUAL W (CAR X))
                  (SHUFFLEP X (CONS D C) (CDR Z))
                  (NOT (NUMBERP (CAR X)))
                  (NUMBERP (CADR X))
                  (ALTERNATING-COLORS (CDR X))
                  (NUMBERP D)
                  (ALTERNATING-COLORS (CONS D C))
                  (EVEN-LENGTH X)
                  (EVEN-LENGTH (CONS W (CONS D C))))
             (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))),

    which further simplifies, applying CDR-CONS, CAR-CONS, and CAR-APPEND, and
    expanding the functions APPEND, OPPOSITE-COLOR, ALTERNATING-COLORS, and
    EVEN-LENGTH, to the following two new formulas:

    Case 7.1.2.
            (IMPLIES (AND (NOT (ALTERNATING-COLORS (APPEND C (LIST (CAR X)))))
                          (NOT (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                                         (CONS (CAR X) (CONS D C))
                                         (APPEND (CDR Z) (LIST (CAR X)))))
                          (LISTP Z)
                          (LISTP X)
                          (EQUAL (CAR X) (CAR Z))
                          (SHUFFLEP X (CONS D C) (CDR Z))
                          (NOT (NUMBERP (CAR X)))
                          (NUMBERP (CADR X))
                          (ALTERNATING-COLORS (CDR X))
                          (NUMBERP D)
                          (NOT (LISTP C))
                          (EVEN-LENGTH X))
                     (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))).

      But this again simplifies, applying CDR-CONS, and expanding APPEND,
      LISTP, and ALTERNATING-COLORS, to:

            T.

    Case 7.1.1.
            (IMPLIES (AND (NOT (ALTERNATING-COLORS (APPEND C (LIST (CAR X)))))
                          (NOT (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                                         (CONS (CAR X) (CONS D C))
                                         (APPEND (CDR Z) (LIST (CAR X)))))
                          (LISTP Z)
                          (LISTP X)
                          (EQUAL (CAR X) (CAR Z))
                          (SHUFFLEP X (CONS D C) (CDR Z))
                          (NOT (NUMBERP (CAR X)))
                          (NUMBERP (CADR X))
                          (ALTERNATING-COLORS (CDR X))
                          (NUMBERP D)
                          (NOT (NUMBERP (CAR C)))
                          (ALTERNATING-COLORS C)
                          (EVEN-LENGTH X)
                          (EVEN-LENGTH C))
                     (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR X))))).

      However this again simplifies, rewriting with G20, to:

            T.

Case 6. (IMPLIES
                (AND (SHUFFLEP X
                               (APPEND (CDR Y) (LIST (CAR Y)))
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                                    Y
                                    (APPEND (CDR Z) (LIST (CAR Z)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (NOT (EQUAL (CAR X) (CAR Z)))
                     (EQUAL (CAR Y) (CAR Z))
                     (SHUFFLEP X (CDR Y) (CDR Z))
                     (NUMBERP (CAR X))
                     (NOT (NUMBERP (CADR X)))
                     (ALTERNATING-COLORS (CDR X))
                     (NUMBERP (CAR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR Y))))).

  However this again simplifies, rewriting with CDR-CONS, F4, and F6, and
  unfolding the definitions of PLISTP, ALTERNATING-COLORS, and OPPOSITE-COLOR,
  to:

        T.

Case 5. (IMPLIES
                (AND (SHUFFLEP X
                               (APPEND (CDR Y) (LIST (CAR Y)))
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                                    Y
                                    (APPEND (CDR Z) (LIST (CAR Z)))))
                     (LISTP Z)
                     (LISTP X)
                     (LISTP Y)
                     (NOT (EQUAL (CAR X) (CAR Z)))
                     (EQUAL (CAR Y) (CAR Z))
                     (SHUFFLEP X (CDR Y) (CDR Z))
                     (NOT (NUMBERP (CAR X)))
                     (NUMBERP (CADR X))
                     (ALTERNATING-COLORS (CDR X))
                     (NOT (NUMBERP (CAR Y)))
                     (NUMBERP (CADR Y))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH X)
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR Y))))).

  But this again simplifies, rewriting with CDR-CONS, F4, and F6, and
  unfolding the definitions of PLISTP, ALTERNATING-COLORS, and OPPOSITE-COLOR,
  to:

        T.

Case 4. (IMPLIES
                (AND (SHUFFLEP X
                               (APPEND (CDR Y) (LIST (CAR Y)))
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (SHUFFLEP (APPEND (CDR X) (LIST (CAR X)))
                                    Y
                                    (APPEND (CDR Z) (LIST (CAR Z)))))
                     (LISTP Z)
                     (NOT (LISTP X))
                     (EQUAL X NIL)
                     (EQUAL Y Z)
                     (PLISTP (CDR Y))
                     (NUMBERP (CAR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Y) (LIST (CAR Y))))).

  This again simplifies, rewriting with F6, and unfolding the functions EQUAL,
  LISTP, SHUFFLEP, ALTERNATING-COLORS, and OPPOSITE-COLOR, to:

        T.

Case 3. (IMPLIES
                (AND (SHUFFLEP X
                               (APPEND (CDR Y) (LIST (CAR Y)))
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (LISTP (CDR X))
                     (NUMBERP (CADR X))
                     (NUMBERP (CAR Y))
                     (LISTP Z)
                     (NOT (LISTP X))
                     (EQUAL X NIL)
                     (EQUAL Y Z)
                     (PLISTP (CDR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Y) (LIST (CAR Y))))).

  However this again simplifies, applying F6, and unfolding the functions
  EQUAL, LISTP, SHUFFLEP, ALTERNATING-COLORS, and OPPOSITE-COLOR, to:

        T.

Case 2. (IMPLIES
                (AND (SHUFFLEP X
                               (APPEND (CDR Y) (LIST (CAR Y)))
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR Y) (LIST (CAR Y)))))
                     (NOT (LISTP (CDR X)))
                     (NUMBERP (CAR X))
                     (NUMBERP (CAR Y))
                     (LISTP Z)
                     (NOT (LISTP X))
                     (EQUAL X NIL)
                     (EQUAL Y Z)
                     (PLISTP (CDR Y))
                     (NOT (NUMBERP (CADR Y)))
                     (ALTERNATING-COLORS (CDR Y))
                     (EVEN-LENGTH Y))
                (PAIRED-COLORS (APPEND (CDR Y) (LIST (CAR Y))))).

  This again simplifies, rewriting with F6, and expanding the definitions of
  EQUAL, LISTP, SHUFFLEP, ALTERNATING-COLORS, and OPPOSITE-COLOR, to:

        T.

Case 1. (IMPLIES
                (AND (SHUFFLEP X
                               (APPEND (CDR Y) (LIST (CAR Y)))
                               (APPEND (CDR Z) (LIST (CAR Z))))
                     (NOT (LISTP (CDR Y)))
                     (NOT (ALTERNATING-COLORS (APPEND (CDR X) (LIST (CAR X)))))
                     (LISTP Z)
                     (LISTP X)
                     (NOT (LISTP Y))
                     (EQUAL Y NIL)
                     (EQUAL X Z)
                     (PLISTP (CDR X))
                     (NUMBERP (CAR X))
                     (NOT (NUMBERP (CADR X)))
                     (ALTERNATING-COLORS (CDR X))
                     (EVEN-LENGTH X))
                (PAIRED-COLORS (APPEND (CDR X) (LIST (CAR X))))).

  But this again simplifies, rewriting with F6, and expanding the functions
  CDR, CAR, CONS, APPEND, LISTP, ALTERNATING-COLORS, and OPPOSITE-COLOR, to:

        T.

Q.E.D.


[ 0.0 4.8 0.3 ]

FAP


(PROVE-LEMMA AL2
             (REWRITE)
             (IMPLIES (AND (ALTERNATING-COLORS (APPEND X Y))
                           (EVEN-LENGTH (APPEND X Y))
                           (NOT (OPPOSITE-COLOR (CAR X) (CAR Y))))
                      (AND (EVEN-LENGTH X) (EVEN-LENGTH Y)))
             ((INDUCT (PAIRED-COLORS X))))

WARNING:  Note that AL2 contains the free variable Y which will be chosen by
instantiating the hypothesis (ALTERNATING-COLORS (APPEND X Y)).


WARNING:  Note that AL2 contains the free variable X which will be chosen by
instantiating the hypothesis (ALTERNATING-COLORS (APPEND X Y)).


WARNING:  Note that the proposed lemma AL2 is to be stored as zero type
prescription rules, zero compound recognizer rules, zero linear rules, and two
replacement rules.


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

Case 2. (IMPLIES (AND (OR (NLISTP X) (NLISTP (CDR X)))
                      (ALTERNATING-COLORS (APPEND X Y))
                      (EVEN-LENGTH (APPEND X Y))
                      (NOT (OPPOSITE-COLOR (CAR X) (CAR Y))))
                 (AND (EVEN-LENGTH X)
                      (EVEN-LENGTH Y))).

  This simplifies, applying the lemmas CAR-NLISTP and CDR-CONS, and unfolding
  the definitions of NLISTP, OR, APPEND, NUMBERP, OPPOSITE-COLOR, EVEN-LENGTH,
  and AND, to the following two new conjectures:

  Case 2.2.
          (IMPLIES (AND (NOT (LISTP (CDR X)))
                        (LISTP X)
                        (ALTERNATING-COLORS (CONS (CAR X) Y))
                        (LISTP Y)
                        (EVEN-LENGTH (CDR Y))
                        (NOT (NUMBERP (CAR X))))
                   (NUMBERP (CAR Y))).

    However this again simplifies, rewriting with CAR-CONS and CDR-CONS, and
    expanding the functions OPPOSITE-COLOR and ALTERNATING-COLORS, to:

          T.

  Case 2.1.
          (IMPLIES (AND (NOT (LISTP (CDR X)))
                        (LISTP X)
                        (ALTERNATING-COLORS (CONS (CAR X) Y))
                        (LISTP Y)
                        (EVEN-LENGTH (CDR Y))
                        (NUMBERP (CAR X)))
                   (NOT (NUMBERP (CAR Y)))).

    But this again simplifies, rewriting with CAR-CONS and CDR-CONS, and
    opening up OPPOSITE-COLOR and ALTERNATING-COLORS, to:

          T.

Case 1. (IMPLIES (AND (LISTP X)
                      (LISTP (CDR X))
                      (IMPLIES (AND (ALTERNATING-COLORS (APPEND (CDDR X) Y))
                                    (EVEN-LENGTH (APPEND (CDDR X) Y))
                                    (NOT (OPPOSITE-COLOR (CADDR X) (CAR Y))))
                               (AND (EVEN-LENGTH (CDDR X))
                                    (EVEN-LENGTH Y)))
                      (ALTERNATING-COLORS (APPEND X Y))
                      (EVEN-LENGTH (APPEND X Y))
                      (NOT (OPPOSITE-COLOR (CAR X) (CAR Y))))
                 (AND (EVEN-LENGTH X)
                      (EVEN-LENGTH Y))).

  This simplifies, rewriting with CAR-CONS, CDR-CONS, and CAR-APPEND, and
  expanding the definitions of OPPOSITE-COLOR, NOT, AND, IMPLIES, APPEND,
  ALTERNATING-COLORS, and EVEN-LENGTH, to eight new conjectures:

  Case 1.8.
          (IMPLIES (AND (LISTP X)
                        (LISTP (CDR X))
                        (NUMBERP (CADDR X))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (APPEND (CDDR X) Y))))
                   (EVEN-LENGTH (CDDR X))).

    Applying the lemma CAR-CDR-ELIM, replace X by (CONS V Z) to eliminate
    (CDR X) and (CAR X), Z by (CONS D W) to eliminate (CDR Z) and (CAR Z), and
    W by (CONS Z C) to eliminate (CAR W) and (CDR W).  We would thus like to
    prove the following two new goals:

    Case 1.8.2.
            (IMPLIES (AND (NOT (LISTP W))
                          (NUMBERP (CAR W))
                          (NOT (NUMBERP (CAR Y)))
                          (NOT (NUMBERP V))
                          (NUMBERP D)
                          (NOT (LISTP (APPEND W Y))))
                     (EVEN-LENGTH W)).

      This further simplifies, applying CAR-NLISTP, and expanding NUMBERP,
      APPEND, and EVEN-LENGTH, to:

            T.

    Case 1.8.1.
            (IMPLIES (AND (NUMBERP Z)
                          (NOT (NUMBERP (CAR Y)))
                          (NOT (NUMBERP V))
                          (NUMBERP D)
                          (NOT (LISTP (APPEND (CONS Z C) Y))))
                     (EVEN-LENGTH (CONS Z C))).

      However this further simplifies, applying the lemmas CDR-CONS and
      CAR-CONS, and unfolding the definition of APPEND, to:

            T.

  Case 1.7.
          (IMPLIES (AND (LISTP X)
                        (LISTP (CDR X))
                        (NUMBERP (CADDR X))
                        (NOT (NUMBERP (CAR Y)))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (APPEND (CDDR X) Y))))
                   (EVEN-LENGTH Y)).

    Applying the lemma CAR-CDR-ELIM, replace X by (CONS V Z) to eliminate
    (CDR X) and (CAR X), Z by (CONS D W) to eliminate (CDR Z) and (CAR Z), and
    W by (CONS Z C) to eliminate (CAR W) and (CDR W).  We would thus like to
    prove the following two new goals:

    Case 1.7.2.
            (IMPLIES (AND (NOT (LISTP W))
                          (NUMBERP (CAR W))
                          (NOT (NUMBERP (CAR Y)))
                          (NOT (NUMBERP V))
                          (NUMBERP D)
                          (NOT (LISTP (APPEND W Y))))
                     (EVEN-LENGTH Y)).

      This further simplifies, rewriting with CAR-NLISTP, and opening up the
      functions NUMBERP, APPEND, and EVEN-LENGTH, to:

            T.

    Case 1.7.1.
            (IMPLIES (AND (NUMBERP Z)
                          (NOT (NUMBERP (CAR Y)))
                          (NOT (NUMBERP V))
                          (NUMBERP D)
                          (NOT (LISTP (APPEND (CONS Z C) Y))))
                     (EVEN-LENGTH Y)).

      But this further simplifies, rewriting with CDR-CONS and CAR-CONS, and
      opening up the definition of APPEND, to:

            T.

  Case 1.6.
          (IMPLIES (AND (LISTP X)
                        (LISTP (CDR X))
                        (NOT (NUMBERP (CADDR X)))
                        (NUMBERP (CAR Y))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (APPEND (CDDR X) Y))))
                   (EVEN-LENGTH (CDDR X))).

    Appealing to the lemma CAR-CDR-ELIM, we now replace X by (CONS V Z) to
    eliminate (CDR X) and (CAR X), Z by (CONS D W) to eliminate (CDR Z) and
    (CAR Z), and W by (CONS Z C) to eliminate (CAR W) and (CDR W).  We must
    thus prove two new conjectures:

    Case 1.6.2.
            (IMPLIES (AND (NOT (LISTP W))
                          (NOT (NUMBERP (CAR W)))
                          (NUMBERP (CAR Y))
                          (NUMBERP V)
                          (NOT (NUMBERP D))
                          (NOT (LISTP (APPEND W Y))))
                     (EVEN-LENGTH W)),

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

            T.

    Case 1.6.1.
            (IMPLIES (AND (NOT (NUMBERP Z))
                          (NUMBERP (CAR Y))
                          (NUMBERP V)
                          (NOT (NUMBERP D))
                          (NOT (LISTP (APPEND (CONS Z C) Y))))
                     (EVEN-LENGTH (CONS Z C))).

      This further simplifies, applying the lemmas CDR-CONS and CAR-CONS, and
      unfolding APPEND, to:

            T.

  Case 1.5.
          (IMPLIES (AND (LISTP X)
                        (LISTP (CDR X))
                        (NOT (NUMBERP (CADDR X)))
                        (NUMBERP (CAR Y))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (APPEND (CDDR X) Y))))
                   (EVEN-LENGTH Y)).

    Applying the lemma CAR-CDR-ELIM, replace X by (CONS V Z) to eliminate
    (CDR X) and (CAR X), Z by (CONS D W) to eliminate (CDR Z) and (CAR Z), and
    W by (CONS Z C) to eliminate (CAR W) and (CDR W).  This produces the
    following two new formulas:

    Case 1.5.2.
            (IMPLIES (AND (NOT (LISTP W))
                          (NOT (NUMBERP (CAR W)))
                          (NUMBERP (CAR Y))
                          (NUMBERP V)
                          (NOT (NUMBERP D))
                          (NOT (LISTP (APPEND W Y))))
                     (EVEN-LENGTH Y)).

      This further simplifies, applying CAR-NLISTP, and opening up NUMBERP, to:

            T.

    Case 1.5.1.
            (IMPLIES (AND (NOT (NUMBERP Z))
                          (NUMBERP (CAR Y))
                          (NUMBERP V)
                          (NOT (NUMBERP D))
                          (NOT (LISTP (APPEND (CONS Z C) Y))))
                     (EVEN-LENGTH Y)).

      This further simplifies, applying CDR-CONS and CAR-CONS, and opening up
      APPEND, to:

            T.

  Case 1.4.
          (IMPLIES (AND (LISTP X)
                        (LISTP (CDR X))
                        (NOT (ALTERNATING-COLORS (APPEND (CDDR X) Y)))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (APPEND (CDDR X) Y)))
                        (NUMBERP (CAR Y)))
                   (EVEN-LENGTH (CDDR X))).

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

          T.

  Case 1.3.
          (IMPLIES (AND (LISTP X)
                        (LISTP (CDR X))
                        (NOT (ALTERNATING-COLORS (APPEND (CDDR X) Y)))
                        (NUMBERP (CAR X))
                        (NOT (NUMBERP (CADR X)))
                        (NOT (LISTP (APPEND (CDDR X) Y)))
                        (NUMBERP (CAR Y)))
                   (EVEN-LENGTH Y)),

    which again simplifies, unfolding ALTERNATING-COLORS, to:

          T.

  Case 1.2.
          (IMPLIES (AND (LISTP X)
                        (LISTP (CDR X))
                        (NOT (ALTERNATING-COLORS (APPEND (CDDR X) Y)))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (APPEND (CDDR X) Y)))
                        (NOT (NUMBERP (CAR Y))))
                   (EVEN-LENGTH (CDDR X))),

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

          T.

  Case 1.1.
          (IMPLIES (AND (LISTP X)
                        (LISTP (CDR X))
                        (NOT (ALTERNATING-COLORS (APPEND (CDDR X) Y)))
                        (NOT (NUMBERP (CAR X)))
                        (NUMBERP (CADR X))
                        (NOT (LISTP (APPEND (CDDR X) Y)))
                        (NOT (NUMBERP (CAR Y))))
                   (EVEN-LENGTH Y)),

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

          T.

Q.E.D.


[ 0.0 0.1 0.1 ]

AL2


(PROVE-LEMMA G16
             (REWRITE)
             (IMPLIES (NOT (ALTERNATING-COLORS X))
                      (NOT (ALTERNATING-COLORS (APPEND X Y)))))


     Give the conjecture the name *1.


     We will try to 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 Y))
           (IMPLIES (AND (NOT (OR (NLISTP X) (NLISTP (CDR X))))
                         (p (CDR X) Y))
                    (p X Y))).
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 induction step of the scheme.  The
above induction scheme generates three new goals:

Case 3. (IMPLIES (AND (OR (NLISTP X) (NLISTP (CDR X)))
                      (NOT (ALTERNATING-COLORS X)))
                 (NOT (ALTERNATING-COLORS (APPEND X Y)))),

  which simplifies, expanding NLISTP, OR, and ALTERNATING-COLORS, to:

        T.

Case 2. (IMPLIES (AND (NOT (OR (NLISTP X) (NLISTP (CDR X))))
                      (ALTERNATING-COLORS (CDR X))
                      (NOT (ALTERNATING-COLORS X)))
                 (NOT (ALTERNATING-COLORS (APPEND X Y)))),

  which simplifies, appealing to the lemmas CAR-APPEND, CAR-CONS, and CDR-CONS,
  and unfolding the definitions of NLISTP, OR, ALTERNATING-COLORS,
  OPPOSITE-COLOR, and APPEND, to two new conjectures:

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

    Applying the lemma CAR-CDR-ELIM, replace X by (CONS V Z) to eliminate
    (CDR X) and (CAR X) and Z by (CONS W D) to eliminate (CAR Z) and (CDR Z).
    We thus obtain:

          (IMPLIES (AND (ALTERNATING-COLORS (CONS W D))
                        (NOT (NUMBERP V))
                        (NOT (NUMBERP W)))
                   (LISTP (APPEND (CONS W D) Y))),

    which further simplifies, appealing to the lemmas CAR-CONS and CDR-CONS,
    and opening up the functions OPPOSITE-COLOR, ALTERNATING-COLORS, and
    APPEND, to:

          T.

  Case 2.1.
          (IMPLIES (AND (LISTP X)
                        (LISTP (CDR X))
                        (ALTERNATING-COLORS (CDR X))
                        (NUMBERP (CAR X))
                        (NUMBERP (CADR X)))
                   (LISTP (APPEND (CDR X) Y))).

    Applying the lemma CAR-CDR-ELIM, replace X by (CONS V Z) to eliminate
    (CDR X) and (CAR X) and Z by (CONS W D) to eliminate (CAR Z) and (CDR Z).
    We would thus like to prove:

          (IMPLIES (AND (ALTERNATING-COLORS (CONS W D))
                        (NUMBERP V)
                        (NUMBERP W))
                   (LISTP (APPEND (CONS W D) Y))),

    which further simplifies, rewriting with CAR-CONS and CDR-CONS, and
    unfolding the definitions of OPPOSITE-COLOR, ALTERNATING-COLORS, and
    APPEND, to:

          T.

Case 1. (IMPLIES (AND (NOT (OR (NLISTP X) (NLISTP (CDR X))))
                      (NOT (ALTERNATING-COLORS (APPEND (CDR X) Y)))
                      (NOT (ALTERNATING-COLORS X)))
                 (NOT (ALTERNATING-COLORS (APPEND X Y)))).

  This simplifies, appealing to the lemmas CAR-APPEND, CAR-CONS, and CDR-CONS,
  and expanding the functions NLISTP, OR, ALTERNATING-COLORS, OPPOSITE-COLOR,
  and APPEND, to the following three new formulas:

  Case 1.3.
          (IMPLIES (AND (LISTP X)
                        (LISTP (CDR X))
                        (NOT (ALTERNATING-COLORS (APPEND (CDR X) Y)))
                        (NUMBERP (CAR X))
                        (NUMBERP (CADR X)))
                   (LISTP (APPEND (CDR X) Y))).

    However this again simplifies, opening up the definition of
    ALTERNATING-COLORS, to:

          T.

  Case 1.2.
          (IMPLIES (AND (LISTP X)
                        (LISTP (CDR X))
                        (NOT (ALTERNATING-COLORS (APPEND (CDR X) Y)))
                        (NOT (NUMBERP (CAR X)))
                        (NOT (NUMBERP (CADR X))))
                   (LISTP (APPEND (CDR X) Y))),

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

          T.

  Case 1.1.
          (IMPLIES (AND (LISTP X)
                        (LISTP (CDR X))
                        (NOT (ALTERNATING-COLORS (APPEND (CDR X) Y)))
                        (NOT (ALTERNATING-COLORS (CDR X))))
                   (LISTP (APPEND (CDR X) Y))),

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

          T.


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


[ 0.0 0.0 0.0 ]

G16


(PROVE-LEMMA G17
             (REWRITE)
             (IMPLIES (NOT (ALTERNATING-COLORS Y))
                      (NOT (ALTERNATING-COLORS (APPEND X Y)))))


     Give the conjecture the name *1.


     We will try to prove it by induction.  There are two plausible inductions.
However, only one is unflawed.  We will induct according to the following
scheme:
      (AND (IMPLIES (AND (LISTP X) (p (CDR X) Y))
                    (p X Y))
           (IMPLIES (NOT (LISTP X)) (p X Y))).
Linear arithmetic and the lemma CDR-LESSP inform us that the measure (COUNT X)
decreases according to the well-founded relation LESSP in each induction step
of the scheme.  The above induction scheme generates two new goals:

Case 2. (IMPLIES (AND (LISTP X)
                      (NOT (ALTERNATING-COLORS (APPEND (CDR X) Y)))
                      (NOT (ALTERNATING-COLORS Y)))
                 (NOT (ALTERNATING-COLORS (APPEND X Y)))),

  which simplifies, applying CAR-APPEND, CAR-CONS, and CDR-CONS, and unfolding
  the functions APPEND, OPPOSITE-COLOR, and ALTERNATING-COLORS, to:

        (IMPLIES (AND (LISTP X)
                      (NOT (ALTERNATING-COLORS (APPEND (CDR X) Y)))
                      (NOT (ALTERNATING-COLORS Y)))
                 (LISTP (APPEND (CDR X) Y))),

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

        T.

Case 1. (IMPLIES (AND (NOT (LISTP X))
                      (NOT (ALTERNATING-COLORS Y)))
                 (NOT (ALTERNATING-COLORS (APPEND X Y)))),

  which simplifies, unfolding the definition of APPEND, to:

        T.


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


[ 0.0 0.0 0.0 ]

G17


(PROVE-LEMMA ALL NIL
             (IMPLIES (AND (ALTERNATING-COLORS (APPEND X Y))
                           (EVEN-LENGTH (APPEND X Y))
                           (SHUFFLEP X Y Z)
                           (LISTP X)
                           (LISTP Y))
                      (IF (OPPOSITE-COLOR (CAR X) (CAR Y))
                          (PAIRED-COLORS Z)
                          (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR Z))))))
             ((USE (FAP) (MAIN))))

This conjecture simplifies, applying G16 and G17, and opening up the
definitions of OPPOSITE-COLOR, NOT, AND, and IMPLIES, to eight new conjectures:

Case 8. (IMPLIES (AND (NOT (EVEN-LENGTH X))
                      (NUMBERP (CAR X))
                      (NUMBERP (CAR Y))
                      (ALTERNATING-COLORS (APPEND X Y))
                      (EVEN-LENGTH (APPEND X Y))
                      (SHUFFLEP X Y Z)
                      (LISTP X)
                      (LISTP Y))
                 (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR Z))))),

  which again simplifies, rewriting with AL2, and unfolding OPPOSITE-COLOR, to:

        T.

Case 7. (IMPLIES (AND (NOT (EVEN-LENGTH X))
                      (NOT (NUMBERP (CAR X)))
                      (NOT (NUMBERP (CAR Y)))
                      (ALTERNATING-COLORS (APPEND X Y))
                      (EVEN-LENGTH (APPEND X Y))
                      (SHUFFLEP X Y Z)
                      (LISTP X)
                      (LISTP Y))
                 (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR Z))))).

  This again simplifies, applying AL2, and opening up the function
  OPPOSITE-COLOR, to:

        T.

Case 6. (IMPLIES (AND (NOT (EVEN-LENGTH X))
                      (PAIRED-COLORS Z)
                      (ALTERNATING-COLORS (APPEND X Y))
                      (EVEN-LENGTH (APPEND X Y))
                      (SHUFFLEP X Y Z)
                      (LISTP X)
                      (LISTP Y)
                      (NUMBERP (CAR X))
                      (NUMBERP (CAR Y)))
                 (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR Z))))).

  However this again simplifies, applying the lemma AL2, and opening up the
  function OPPOSITE-COLOR, to:

        T.

Case 5. (IMPLIES (AND (NOT (EVEN-LENGTH X))
                      (PAIRED-COLORS Z)
                      (ALTERNATING-COLORS (APPEND X Y))
                      (EVEN-LENGTH (APPEND X Y))
                      (SHUFFLEP X Y Z)
                      (LISTP X)
                      (LISTP Y)
                      (NOT (NUMBERP (CAR X)))
                      (NOT (NUMBERP (CAR Y))))
                 (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR Z))))),

  which again simplifies, applying AL2, and expanding OPPOSITE-COLOR, to:

        T.

Case 4. (IMPLIES (AND (NOT (EVEN-LENGTH Y))
                      (NUMBERP (CAR X))
                      (NUMBERP (CAR Y))
                      (ALTERNATING-COLORS (APPEND X Y))
                      (EVEN-LENGTH (APPEND X Y))
                      (SHUFFLEP X Y Z)
                      (LISTP X)
                      (LISTP Y))
                 (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR Z))))).

  This again simplifies, rewriting with AL2, and unfolding OPPOSITE-COLOR, to:

        T.

Case 3. (IMPLIES (AND (NOT (EVEN-LENGTH Y))
                      (NOT (NUMBERP (CAR X)))
                      (NOT (NUMBERP (CAR Y)))
                      (ALTERNATING-COLORS (APPEND X Y))
                      (EVEN-LENGTH (APPEND X Y))
                      (SHUFFLEP X Y Z)
                      (LISTP X)
                      (LISTP Y))
                 (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR Z))))).

  This again simplifies, applying the lemma AL2, and expanding the function
  OPPOSITE-COLOR, to:

        T.

Case 2. (IMPLIES (AND (NOT (EVEN-LENGTH Y))
                      (PAIRED-COLORS Z)
                      (ALTERNATING-COLORS (APPEND X Y))
                      (EVEN-LENGTH (APPEND X Y))
                      (SHUFFLEP X Y Z)
                      (LISTP X)
                      (LISTP Y)
                      (NUMBERP (CAR X))
                      (NUMBERP (CAR Y)))
                 (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR Z))))),

  which again simplifies, applying AL2, and opening up the definition of
  OPPOSITE-COLOR, to:

        T.

Case 1. (IMPLIES (AND (NOT (EVEN-LENGTH Y))
                      (PAIRED-COLORS Z)
                      (ALTERNATING-COLORS (APPEND X Y))
                      (EVEN-LENGTH (APPEND X Y))
                      (SHUFFLEP X Y Z)
                      (LISTP X)
                      (LISTP Y)
                      (NOT (NUMBERP (CAR X)))
                      (NOT (NUMBERP (CAR Y))))
                 (PAIRED-COLORS (APPEND (CDR Z) (LIST (CAR Z))))).

  However this again simplifies, applying the lemma AL2, and opening up
  OPPOSITE-COLOR, to:

        T.

Q.E.D.


[ 0.0 0.1 0.0 ]

ALL