
(/VERSIONCHECK 2) 

(DEFUN |PATTERN;coerce;R$;1| (|r| $) (|PATTERN;mkPat| 'T (CONS 0 |r|) 0 $)) 

(DEFUN |PATTERN;mkPat| (|c| |p| |l| $) (VECTOR |c| |p| |l| NIL (QREFELT $ 17))) 

(DEFUN |PATTERN;hasTopPredicate?;$B;3| (|x| $)
  (COND ((NULL (QVELT |x| 3)) 'NIL) ('T 'T))) 

(DEFUN |PATTERN;topPredicate;$R;4| (|x| $) (CONS (QVELT |x| 3) (QVELT |x| 4))) 

(DEFUN |PATTERN;setTopPredicate;$LA$;5| (|x| |l| |f| $)
  (SEQ (QSETVELT |x| 3 |l|) (QSETVELT |x| 4 |f|) (EXIT |x|))) 

(PUT '|PATTERN;constant?;$B;6| '|SPADreplace| '(XLAM (|p|) (QVELT |p| 0))) 

(DEFUN |PATTERN;constant?;$B;6| (|p| $) (QVELT |p| 0)) 

(PUT '|PATTERN;depth;$Nni;7| '|SPADreplace| '(XLAM (|p|) (QVELT |p| 2))) 

(DEFUN |PATTERN;depth;$Nni;7| (|p| $) (QVELT |p| 2)) 

(DEFUN |PATTERN;inR?;$B;8| (|p| $) (QEQCAR (QVELT |p| 1) 0)) 

(DEFUN |PATTERN;symbol?;$B;9| (|p| $) (QEQCAR (QVELT |p| 1) 4)) 

(DEFUN |PATTERN;isPlus;$U;10| (|p| $) (|PATTERN;isTaggedOp| |p| 1 $)) 

(DEFUN |PATTERN;isTimes;$U;11| (|p| $)
  (|PATTERN;isTaggedOp| |p| (SPADCALL 2 (QREFELT $ 33)) $)) 

(DEFUN |PATTERN;isList;$U;12| (|p| $)
  (|PATTERN;isTaggedOp| |p| (SPADCALL 3 (QREFELT $ 33)) $)) 

(DEFUN |PATTERN;isExpt;$U;13| (|p| $)
  (PROG (#1=#:G1940)
    (RETURN
     (COND
      ((QEQCAR (QVELT |p| 1) 2)
       (CONS 0
             (PROG2
                 (LETT #1# (QVELT |p| 1) |PATTERN;isExpt;$U;13|)
                 (QCDR #1#)
               (|check-union| (QEQCAR #1# 2)
                              (|Record| (|:| |val| $)
                                        (|:| |exponent|
                                             (|NonNegativeInteger|)))
                              #1#))))
      ('T (CONS 1 "failed")))))) 

(DEFUN |PATTERN;isQuotient;$U;14| (|p| $)
  (PROG (#1=#:G1959)
    (RETURN
     (COND
      ((QEQCAR (QVELT |p| 1) 3)
       (CONS 0
             (PROG2
                 (LETT #1# (QVELT |p| 1) |PATTERN;isQuotient;$U;14|)
                 (QCDR #1#)
               (|check-union| (QEQCAR #1# 3)
                              (|Record| (|:| |num| $) (|:| |den| $)) #1#))))
      ('T (CONS 1 "failed")))))) 

(DEFUN |PATTERN;hasPredicate?;$B;15| (|p| $)
  (COND ((NULL (SPADCALL |p| (QREFELT $ 43))) 'NIL) ('T 'T))) 

(DEFUN |PATTERN;quoted?;$B;16| (|p| $)
  (PROG (#1=#:G1977)
    (RETURN
     (COND
      ((SPADCALL |p| (QREFELT $ 29))
       (ZEROP
        (QVELT
         (PROG2
             (LETT #1# (QVELT |p| 1) |PATTERN;quoted?;$B;16|)
             (QCDR #1#)
           (|check-union| (QEQCAR #1# 4)
                          (|Record| (|:| |tag| (|SingleInteger|))
                                    (|:| |val| (|Symbol|))
                                    (|:| |pred| (|List| (|Any|)))
                                    (|:| |bad| (|List| (|Any|))))
                          #1#))
         0)))
      ('T 'NIL))))) 

(DEFUN |PATTERN;generic?;$B;17| (|p| $)
  (PROG (#1=#:G1988)
    (RETURN
     (COND
      ((SPADCALL |p| (QREFELT $ 29))
       (|PATTERN;bitSet?|
        (QVELT
         (PROG2
             (LETT #1# (QVELT |p| 1) |PATTERN;generic?;$B;17|)
             (QCDR #1#)
           (|check-union| (QEQCAR #1# 4)
                          (|Record| (|:| |tag| (|SingleInteger|))
                                    (|:| |val| (|Symbol|))
                                    (|:| |pred| (|List| (|Any|)))
                                    (|:| |bad| (|List| (|Any|))))
                          #1#))
         0)
        1 $))
      ('T 'NIL))))) 

(DEFUN |PATTERN;multiple?;$B;18| (|p| $)
  (PROG (#1=#:G1999)
    (RETURN
     (COND
      ((SPADCALL |p| (QREFELT $ 29))
       (|PATTERN;bitSet?|
        (QVELT
         (PROG2
             (LETT #1# (QVELT |p| 1) |PATTERN;multiple?;$B;18|)
             (QCDR #1#)
           (|check-union| (QEQCAR #1# 4)
                          (|Record| (|:| |tag| (|SingleInteger|))
                                    (|:| |val| (|Symbol|))
                                    (|:| |pred| (|List| (|Any|)))
                                    (|:| |bad| (|List| (|Any|))))
                          #1#))
         0)
        (SPADCALL 2 (QREFELT $ 33)) $))
      ('T 'NIL))))) 

(DEFUN |PATTERN;optional?;$B;19| (|p| $)
  (PROG (#1=#:G2010)
    (RETURN
     (COND
      ((SPADCALL |p| (QREFELT $ 29))
       (|PATTERN;bitSet?|
        (QVELT
         (PROG2
             (LETT #1# (QVELT |p| 1) |PATTERN;optional?;$B;19|)
             (QCDR #1#)
           (|check-union| (QEQCAR #1# 4)
                          (|Record| (|:| |tag| (|SingleInteger|))
                                    (|:| |val| (|Symbol|))
                                    (|:| |pred| (|List| (|Any|)))
                                    (|:| |bad| (|List| (|Any|))))
                          #1#))
         0)
        (SPADCALL 4 (QREFELT $ 33)) $))
      ('T 'NIL))))) 

(DEFUN |PATTERN;bitSet?| (|a| |b| $)
  (COND ((EQL (LOGAND |a| |b|) 0) 'NIL) ('T 'T))) 

(DEFUN |PATTERN;coerce;$Of;21| (|p| $) (|PATTERN;PAT2O| (QVELT |p| 1) $)) 

(DEFUN |PATTERN;^;3$;22| (|p1| |p2| $)
  (|PATTERN;taggedElt| (SPADCALL 6 (QREFELT $ 33)) (LIST |p1| |p2|) $)) 

(DEFUN |PATTERN;LPAT2O| (|f| |l| $)
  (PROG (#1=#:G2031 |x| #2=#:G2030)
    (RETURN
     (SEQ
      (SPADCALL |f|
                (PROGN
                 (LETT #2# NIL . #3=(|PATTERN;LPAT2O|))
                 (SEQ (LETT |x| NIL . #3#) (LETT #1# |l| . #3#) G190
                      (COND
                       ((OR (ATOM #1#) (PROGN (LETT |x| (CAR #1#) . #3#) NIL))
                        (GO G191)))
                      (SEQ
                       (EXIT
                        (LETT #2# (CONS (SPADCALL |x| (QREFELT $ 50)) #2#)
                              . #3#)))
                      (LETT #1# (CDR #1#) . #3#) (GO G190) G191
                      (EXIT (NREVERSE0 #2#))))
                (QREFELT $ 54)))))) 

(DEFUN |PATTERN;retract;$R;24| (|p| $)
  (PROG (#1=#:G2036)
    (RETURN
     (COND
      ((SPADCALL |p| (QREFELT $ 28))
       (PROG2
           (LETT #1# (QVELT |p| 1) |PATTERN;retract;$R;24|)
           (QCDR #1#)
         (|check-union| (QEQCAR #1# 0) (QREFELT $ 6) #1#)))
      ('T (|error| "Not retractable")))))) 

(DEFUN |PATTERN;convert;L$;25| (|l| $)
  (|PATTERN;taggedElt| (SPADCALL 3 (QREFELT $ 33)) |l| $)) 

(DEFUN |PATTERN;retractIfCan;$U;26| (|p| $)
  (PROG (#1=#:G2051)
    (RETURN
     (COND
      ((SPADCALL |p| (QREFELT $ 28))
       (CONS 0
             (PROG2
                 (LETT #1# (QVELT |p| 1) |PATTERN;retractIfCan;$U;26|)
                 (QCDR #1#)
               (|check-union| (QEQCAR #1# 0) (QREFELT $ 6) #1#))))
      ('T (CONS 1 "failed")))))) 

(DEFUN |PATTERN;withPredicates;$L$;27| (|p| |l| $)
  (SPADCALL (SPADCALL |p| (QREFELT $ 60)) |l| (QREFELT $ 61))) 

(DEFUN |PATTERN;coerce;S$;28| (|sy| $)
  (SPADCALL |sy| 'NIL 'NIL 'NIL (QREFELT $ 63))) 

(DEFUN |PATTERN;copy;2$;29| (|p| $)
  (VECTOR (SPADCALL |p| (QREFELT $ 25)) (|PATTERN;patcopy| (QVELT |p| 1) $)
          (QVELT |p| 2) (QVELT |p| 3) (QVELT |p| 4))) 

(DEFUN |PATTERN;optpair;LU;30| (|l| $)
  (PROG (|a| |b|)
    (RETURN
     (SEQ
      (COND
       ((SPADCALL (SPADCALL (SPADCALL |l| (QREFELT $ 66)) (QREFELT $ 66))
                  (QREFELT $ 67))
        (SEQ
         (LETT |b| (SPADCALL (SPADCALL |l| (QREFELT $ 66)) (QREFELT $ 68))
               . #1=(|PATTERN;optpair;LU;30|))
         (EXIT
          (COND
           ((SPADCALL (LETT |a| (SPADCALL |l| (QREFELT $ 68)) . #1#)
                      (QREFELT $ 48))
            (CONS 0 |l|))
           ((SPADCALL |b| (QREFELT $ 48))
            (CONS 0 (SPADCALL |l| (QREFELT $ 69))))
           (#2='T (CONS 1 "failed"))))))
       (#2# (CONS 1 "failed"))))))) 

(DEFUN |PATTERN;incmax| (|l| $)
  (PROG (#1=#:G2084 |p| #2=#:G2083)
    (RETURN
     (SEQ
      (+ 1
         (SPADCALL (ELT $ 72)
                   (PROGN
                    (LETT #2# NIL . #3=(|PATTERN;incmax|))
                    (SEQ (LETT |p| NIL . #3#) (LETT #1# |l| . #3#) G190
                         (COND
                          ((OR (ATOM #1#)
                               (PROGN (LETT |p| (CAR #1#) . #3#) NIL))
                           (GO G191)))
                         (SEQ (EXIT (LETT #2# (CONS (QVELT |p| 2) #2#) . #3#)))
                         (LETT #1# (CDR #1#) . #3#) (GO G190) G191
                         (EXIT (NREVERSE0 #2#))))
                   0 (QREFELT $ 75))))))) 

(DEFUN |PATTERN;=;2$B;32| (|p1| |p2| $)
  (COND
   ((|BooleanEquality| (QVELT |p1| 0) (QVELT |p2| 0))
    (COND
     ((EQL (QVELT |p1| 2) (QVELT |p2| 2))
      (COND
       ((SPADCALL (QVELT |p1| 3) (QVELT |p2| 3) (QREFELT $ 76))
        (COND
         ((EQ (QVELT |p1| 4) (QVELT |p2| 4))
          (|PATTERN;pateq?| (QVELT |p1| 1) (QVELT |p2| 1) $))
         (#1='T 'NIL)))
       (#1# 'NIL)))
     (#1# 'NIL)))
   (#1# 'NIL))) 

(DEFUN |PATTERN;isPower;$U;33| (|p| $)
  (PROG (|u|)
    (RETURN
     (SEQ
      (LETT |u| (|PATTERN;isTaggedOp| |p| (SPADCALL 6 (QREFELT $ 33)) $)
            |PATTERN;isPower;$U;33|)
      (EXIT
       (COND ((QEQCAR |u| 1) (CONS 1 "failed"))
             ('T
              (CONS 0
                    (CONS (SPADCALL (QCDR |u|) (QREFELT $ 68))
                          (SPADCALL (QCDR |u|) (QREFELT $ 78))))))))))) 

(DEFUN |PATTERN;taggedElt| (|n| |l| $)
  (|PATTERN;mkPat| (SPADCALL (ELT $ 25) |l| (QREFELT $ 83))
   (CONS 1 (VECTOR |n| (QREFELT $ 12) |l|)) (|PATTERN;incmax| |l| $) $)) 

(DEFUN |PATTERN;elt;BoL$;35| (|o| |l| $)
  (SEQ
   (COND
    ((SPADCALL |o| '|%power| (QREFELT $ 84))
     (COND
      ((EQL (SPADCALL |l| (QREFELT $ 85)) 2)
       (EXIT
        (SPADCALL (SPADCALL |l| (QREFELT $ 68)) (SPADCALL |l| (QREFELT $ 86))
                  (QREFELT $ 51)))))))
   (EXIT
    (|PATTERN;mkPat| (SPADCALL (ELT $ 25) |l| (QREFELT $ 83))
     (CONS 1 (VECTOR 0 |o| |l|)) (|PATTERN;incmax| |l| $) $)))) 

(DEFUN |PATTERN;isOp;$U;36| (|p| $)
  (PROG (#1=#:G2149)
    (RETURN
     (SEQ
      (COND
       ((QEQCAR (QVELT |p| 1) 1)
        (COND
         ((ZEROP
           (QVELT
            (PROG2
                (LETT #1# (QVELT |p| 1) . #2=(|PATTERN;isOp;$U;36|))
                (QCDR #1#)
              (|check-union| (QEQCAR #1# 1)
                             (|Record| (|:| |tag| (|SingleInteger|))
                                       (|:| |op| (|BasicOperator|))
                                       (|:| |arg| (|List| $)))
                             #1#))
            0))
          (EXIT
           (CONS 0
                 (CONS
                  (QVELT
                   (PROG2
                       (LETT #1# (QVELT |p| 1) . #2#)
                       (QCDR #1#)
                     (|check-union| (QEQCAR #1# 1)
                                    (|Record| (|:| |tag| (|SingleInteger|))
                                              (|:| |op| (|BasicOperator|))
                                              (|:| |arg| (|List| $)))
                                    #1#))
                   1)
                  (QVELT
                   (PROG2
                       (LETT #1# (QVELT |p| 1) . #2#)
                       (QCDR #1#)
                     (|check-union| (QEQCAR #1# 1)
                                    (|Record| (|:| |tag| (|SingleInteger|))
                                              (|:| |op| (|BasicOperator|))
                                              (|:| |arg| (|List| $)))
                                    #1#))
                   2))))))))
      (EXIT (CONS 1 "failed")))))) 

(DEFUN |PATTERN;isTaggedOp| (|p| |t| $)
  (PROG (#1=#:G2169)
    (RETURN
     (SEQ
      (COND
       ((QEQCAR (QVELT |p| 1) 1)
        (COND
         ((EQL
           (QVELT
            (PROG2
                (LETT #1# (QVELT |p| 1) . #2=(|PATTERN;isTaggedOp|))
                (QCDR #1#)
              (|check-union| (QEQCAR #1# 1)
                             (|Record| (|:| |tag| (|SingleInteger|))
                                       (|:| |op| (|BasicOperator|))
                                       (|:| |arg| (|List| $)))
                             #1#))
            0)
           |t|)
          (EXIT
           (CONS 0
                 (QVELT
                  (PROG2
                      (LETT #1# (QVELT |p| 1) . #2#)
                      (QCDR #1#)
                    (|check-union| (QEQCAR #1# 1)
                                   (|Record| (|:| |tag| (|SingleInteger|))
                                             (|:| |op| (|BasicOperator|))
                                             (|:| |arg| (|List| $)))
                                   #1#))
                  2)))))))
      (EXIT (CONS 1 "failed")))))) 

(DEFUN |PATTERN;One;$;38| ($) (SPADCALL (|spadConstant| $ 92) (QREFELT $ 18))) 

(DEFUN |PATTERN;One;$;39| ($)
  (|PATTERN;taggedElt| (SPADCALL 5 (QREFELT $ 33)) (SPADCALL (QREFELT $ 93)) $)) 

(DEFUN |PATTERN;Zero;$;40| ($) (SPADCALL (|spadConstant| $ 94) (QREFELT $ 18))) 

(DEFUN |PATTERN;Zero;$;41| ($)
  (|PATTERN;taggedElt| (SPADCALL 4 (QREFELT $ 33)) (SPADCALL (QREFELT $ 93)) $)) 

(DEFUN |PATTERN;^;$Nni$;42| (|p| |n| $)
  (SEQ
   (COND
    ((SPADCALL |p| (|spadConstant| $ 87) (QREFELT $ 77))
     (COND ((< 0 |n|) (EXIT (|spadConstant| $ 87))))))
   (COND
    ((OR (SPADCALL |p| (|spadConstant| $ 71) (QREFELT $ 77)) (ZEROP |n|))
     (EXIT (|spadConstant| $ 71))))
   (EXIT
    (COND ((EQL |n| 1) |p|)
          ('T
           (|PATTERN;mkPat| (SPADCALL |p| (QREFELT $ 25))
            (CONS 2 (CONS |p| |n|)) (+ 1 (QVELT |p| 2)) $)))))) 

(DEFUN |PATTERN;/;3$;43| (|p1| |p2| $)
  (COND ((SPADCALL |p2| (|spadConstant| $ 71) (QREFELT $ 77)) |p1|)
        (#1='T
         (|PATTERN;mkPat|
          (COND ((SPADCALL |p1| (QREFELT $ 25)) (SPADCALL |p2| (QREFELT $ 25)))
                (#1# 'NIL))
          (CONS 3 (CONS |p1| |p2|)) (+ 1 (MAX (QVELT |p1| 2) (QVELT |p2| 2)))
          $)))) 

(DEFUN |PATTERN;+;3$;44| (|p1| |p2| $)
  (PROG (#1=#:G2208 |u2| |u1|)
    (RETURN
     (COND ((SPADCALL |p1| (|spadConstant| $ 87) (QREFELT $ 77)) |p2|)
           ((SPADCALL |p2| (|spadConstant| $ 87) (QREFELT $ 77)) |p1|)
           (#2='T
            (COND
             ((QEQCAR
               (LETT |u1| (SPADCALL |p1| (QREFELT $ 31))
                     . #3=(|PATTERN;+;3$;44|))
               0)
              (COND
               ((QEQCAR (LETT |u2| (SPADCALL |p2| (QREFELT $ 31)) . #3#) 0)
                (|PATTERN;taggedElt| 1
                 (SPADCALL
                  (PROG2
                      (LETT #1# |u1| . #3#)
                      (QCDR #1#)
                    (|check-union| (QEQCAR #1# 0) (|List| $) #1#))
                  (PROG2
                      (LETT #1# |u2| . #3#)
                      (QCDR #1#)
                    (|check-union| (QEQCAR #1# 0) (|List| $) #1#))
                  (QREFELT $ 97))
                 $))
               (#2#
                (|PATTERN;taggedElt| 1
                 (SPADCALL
                  (PROG2
                      (LETT #1# |u1| . #3#)
                      (QCDR #1#)
                    (|check-union| (QEQCAR #1# 0) (|List| $) #1#))
                  |p2| (QREFELT $ 98))
                 $))))
             ((QEQCAR (LETT |u2| (SPADCALL |p2| (QREFELT $ 31)) . #3#) 0)
              (|PATTERN;taggedElt| 1
               (SPADCALL |p1|
                         (PROG2
                             (LETT #1# |u2| . #3#)
                             (QCDR #1#)
                           (|check-union| (QEQCAR #1# 0) (|List| $) #1#))
                         (QREFELT $ 99))
               $))
             (#2# (|PATTERN;taggedElt| 1 (LIST |p1| |p2|) $)))))))) 

(DEFUN |PATTERN;*;3$;45| (|p1| |p2| $)
  (PROG (#1=#:G2224 |u2| |u1|)
    (RETURN
     (COND
      ((OR (SPADCALL |p1| (|spadConstant| $ 87) (QREFELT $ 77))
           (SPADCALL |p2| (|spadConstant| $ 87) (QREFELT $ 77)))
       (|spadConstant| $ 87))
      ('T
       (COND ((SPADCALL |p1| (|spadConstant| $ 71) (QREFELT $ 77)) |p2|)
             ((SPADCALL |p2| (|spadConstant| $ 71) (QREFELT $ 77)) |p1|)
             (#2='T
              (COND
               ((QEQCAR
                 (LETT |u1| (SPADCALL |p1| (QREFELT $ 34))
                       . #3=(|PATTERN;*;3$;45|))
                 0)
                (COND
                 ((QEQCAR (LETT |u2| (SPADCALL |p2| (QREFELT $ 34)) . #3#) 0)
                  (|PATTERN;taggedElt| (SPADCALL 2 (QREFELT $ 33))
                   (SPADCALL
                    (PROG2
                        (LETT #1# |u1| . #3#)
                        (QCDR #1#)
                      (|check-union| (QEQCAR #1# 0) (|List| $) #1#))
                    (PROG2
                        (LETT #1# |u2| . #3#)
                        (QCDR #1#)
                      (|check-union| (QEQCAR #1# 0) (|List| $) #1#))
                    (QREFELT $ 97))
                   $))
                 (#2#
                  (|PATTERN;taggedElt| (SPADCALL 2 (QREFELT $ 33))
                   (SPADCALL
                    (PROG2
                        (LETT #1# |u1| . #3#)
                        (QCDR #1#)
                      (|check-union| (QEQCAR #1# 0) (|List| $) #1#))
                    |p2| (QREFELT $ 98))
                   $))))
               ((QEQCAR (LETT |u2| (SPADCALL |p2| (QREFELT $ 34)) . #3#) 0)
                (|PATTERN;taggedElt| (SPADCALL 2 (QREFELT $ 33))
                 (SPADCALL |p1|
                           (PROG2
                               (LETT #1# |u2| . #3#)
                               (QCDR #1#)
                             (|check-union| (QEQCAR #1# 0) (|List| $) #1#))
                           (QREFELT $ 99))
                 $))
               (#2#
                (|PATTERN;taggedElt| (SPADCALL 2 (QREFELT $ 33))
                 (LIST |p1| |p2|) $)))))))))) 

(DEFUN |PATTERN;isOp;$BoU;46| (|p| |o| $)
  (PROG (#1=#:G2240)
    (RETURN
     (SEQ
      (COND
       ((QEQCAR (QVELT |p| 1) 1)
        (COND
         ((ZEROP
           (QVELT
            (PROG2
                (LETT #1# (QVELT |p| 1) . #2=(|PATTERN;isOp;$BoU;46|))
                (QCDR #1#)
              (|check-union| (QEQCAR #1# 1)
                             (|Record| (|:| |tag| (|SingleInteger|))
                                       (|:| |op| (|BasicOperator|))
                                       (|:| |arg| (|List| $)))
                             #1#))
            0))
          (COND
           ((SPADCALL
             (QVELT
              (PROG2
                  (LETT #1# (QVELT |p| 1) . #2#)
                  (QCDR #1#)
                (|check-union| (QEQCAR #1# 1)
                               (|Record| (|:| |tag| (|SingleInteger|))
                                         (|:| |op| (|BasicOperator|))
                                         (|:| |arg| (|List| $)))
                               #1#))
              1)
             |o| (QREFELT $ 102))
            (EXIT
             (CONS 0
                   (QVELT
                    (PROG2
                        (LETT #1# (QVELT |p| 1) . #2#)
                        (QCDR #1#)
                      (|check-union| (QEQCAR #1# 1)
                                     (|Record| (|:| |tag| (|SingleInteger|))
                                               (|:| |op| (|BasicOperator|))
                                               (|:| |arg| (|List| $)))
                                     #1#))
                    2)))))))))
      (EXIT (CONS 1 "failed")))))) 

(DEFUN |PATTERN;predicates;$L;47| (|p| $)
  (PROG (#1=#:G2258)
    (RETURN
     (COND
      ((SPADCALL |p| (QREFELT $ 29))
       (QVELT
        (PROG2
            (LETT #1# (QVELT |p| 1) |PATTERN;predicates;$L;47|)
            (QCDR #1#)
          (|check-union| (QEQCAR #1# 4)
                         (|Record| (|:| |tag| (|SingleInteger|))
                                   (|:| |val| (|Symbol|))
                                   (|:| |pred| (|List| (|Any|)))
                                   (|:| |bad| (|List| (|Any|))))
                         #1#))
        2))
      ('T NIL))))) 

(DEFUN |PATTERN;setPredicates;$L$;48| (|p| |l| $)
  (PROG (#1=#:G2269)
    (RETURN
     (SEQ
      (COND
       ((SPADCALL |p| (QREFELT $ 46))
        (SEQ
         (QSETVELT
          (PROG2
              (LETT #1# (QVELT |p| 1) |PATTERN;setPredicates;$L$;48|)
              (QCDR #1#)
            (|check-union| (QEQCAR #1# 4)
                           (|Record| (|:| |tag| (|SingleInteger|))
                                     (|:| |val| (|Symbol|))
                                     (|:| |pred| (|List| (|Any|)))
                                     (|:| |bad| (|List| (|Any|))))
                           #1#))
          2 |l|)
         (EXIT |p|)))
       ('T (|error| "Can only attach predicates to generic symbol"))))))) 

(DEFUN |PATTERN;resetBadValues;2$;49| (|p| $)
  (PROG (#1=#:G2281)
    (RETURN
     (SEQ
      (COND
       ((SPADCALL |p| (QREFELT $ 46))
        (SEQ
         (QSETVELT
          (PROG2
              (LETT #1# (QVELT |p| 1) |PATTERN;resetBadValues;2$;49|)
              (QCDR #1#)
            (|check-union| (QEQCAR #1# 4)
                           (|Record| (|:| |tag| (|SingleInteger|))
                                     (|:| |val| (|Symbol|))
                                     (|:| |pred| (|List| (|Any|)))
                                     (|:| |bad| (|List| (|Any|))))
                           #1#))
          3 NIL)
         (EXIT |p|)))
       ('T (|error| "Can only attach bad values to generic symbol"))))))) 

(DEFUN |PATTERN;addBadValue;$A$;50| (|p| |a| $)
  (PROG (#1=#:G2293)
    (RETURN
     (SEQ
      (COND
       ((SPADCALL |p| (QREFELT $ 46))
        (SEQ
         (COND
          ((NULL
            (SPADCALL |a|
                      (QVELT
                       (PROG2
                           (LETT #1# (QVELT |p| 1)
                                 . #2=(|PATTERN;addBadValue;$A$;50|))
                           (QCDR #1#)
                         (|check-union| (QEQCAR #1# 4)
                                        (|Record| (|:| |tag| (|SingleInteger|))
                                                  (|:| |val| (|Symbol|))
                                                  (|:| |pred| (|List| (|Any|)))
                                                  (|:| |bad| (|List| (|Any|))))
                                        #1#))
                       3)
                      (QREFELT $ 105)))
           (QSETVELT
            (PROG2
                (LETT #1# (QVELT |p| 1) . #2#)
                (QCDR #1#)
              (|check-union| (QEQCAR #1# 4)
                             (|Record| (|:| |tag| (|SingleInteger|))
                                       (|:| |val| (|Symbol|))
                                       (|:| |pred| (|List| (|Any|)))
                                       (|:| |bad| (|List| (|Any|))))
                             #1#))
            3
            (CONS |a|
                  (QVELT
                   (PROG2
                       (LETT #1# (QVELT |p| 1) . #2#)
                       (QCDR #1#)
                     (|check-union| (QEQCAR #1# 4)
                                    (|Record| (|:| |tag| (|SingleInteger|))
                                              (|:| |val| (|Symbol|))
                                              (|:| |pred| (|List| (|Any|)))
                                              (|:| |bad| (|List| (|Any|))))
                                    #1#))
                   3)))))
         (EXIT |p|)))
       ('T (|error| "Can only attach bad values to generic symbol"))))))) 

(DEFUN |PATTERN;getBadValues;$L;51| (|p| $)
  (PROG (#1=#:G2306)
    (RETURN
     (COND
      ((SPADCALL |p| (QREFELT $ 46))
       (QVELT
        (PROG2
            (LETT #1# (QVELT |p| 1) |PATTERN;getBadValues;$L;51|)
            (QCDR #1#)
          (|check-union| (QEQCAR #1# 4)
                         (|Record| (|:| |tag| (|SingleInteger|))
                                   (|:| |val| (|Symbol|))
                                   (|:| |pred| (|List| (|Any|)))
                                   (|:| |bad| (|List| (|Any|))))
                         #1#))
        3))
      ('T (|error| "Not a generic symbol")))))) 

(DEFUN |PATTERN;SYM2O| (|p| $)
  (PROG (#1=#:G2315 |i| #2=#:G2314 |sy|)
    (RETURN
     (SEQ
      (LETT |sy| (SPADCALL (QVELT |p| 1) (QREFELT $ 108))
            . #3=(|PATTERN;SYM2O|))
      (EXIT
       (COND ((NULL (QVELT |p| 2)) |sy|)
             ('T
              (SPADCALL
               (SPADCALL " | " |sy|
                         (SPADCALL (ELT $ 109)
                                   (PROGN
                                    (LETT #2# NIL . #3#)
                                    (SEQ (LETT |i| 1 . #3#)
                                         (LETT #1# (LENGTH (QVELT |p| 2))
                                               . #3#)
                                         G190
                                         (COND
                                          ((QSGREATERP |i| #1#) (GO G191)))
                                         (SEQ
                                          (EXIT
                                           (LETT #2#
                                                 (CONS
                                                  (SPADCALL "f"
                                                            (SPADCALL |i|
                                                                      (QREFELT
                                                                       $ 110))
                                                            (QREFELT $ 111))
                                                  #2#)
                                                 . #3#)))
                                         (LETT |i| (QSADD1 |i|) . #3#)
                                         (GO G190) G191
                                         (EXIT (NREVERSE0 #2#))))
                                   (QREFELT $ 54))
                         (QREFELT $ 112))
               (QREFELT $ 113))))))))) 

(DEFUN |PATTERN;variables;$L;53| (|p| $)
  (PROG (#1=#:G2332 #2=#:G2321 |r| #3=#:G2331 #4=#:G2323 #5=#:G2322 |q|)
    (RETURN
     (SEQ
      (COND ((SPADCALL |p| (QREFELT $ 25)) (SPADCALL (QREFELT $ 93)))
            ((SPADCALL |p| (QREFELT $ 46)) (LIST |p|))
            (#6='T
             (SEQ (LETT |q| (QVELT |p| 1) . #7=(|PATTERN;variables;$L;53|))
                  (EXIT
                   (COND ((QEQCAR |q| 0) (SPADCALL (QREFELT $ 93)))
                         ((QEQCAR |q| 2)
                          (SPADCALL
                           (QCAR
                            (PROG2
                                (LETT #5# |q| . #7#)
                                (QCDR #5#)
                              (|check-union| (QEQCAR #5# 2)
                                             (|Record| (|:| |val| $)
                                                       (|:| |exponent|
                                                            (|NonNegativeInteger|)))
                                             #5#)))
                           (QREFELT $ 114)))
                         ((QEQCAR |q| 3)
                          (SPADCALL
                           (SPADCALL
                            (QCAR
                             (PROG2
                                 (LETT #4# |q| . #7#)
                                 (QCDR #4#)
                               (|check-union| (QEQCAR #4# 3)
                                              (|Record| (|:| |num| $)
                                                        (|:| |den| $))
                                              #4#)))
                            (QREFELT $ 114))
                           (SPADCALL
                            (QCDR
                             (PROG2
                                 (LETT #4# |q| . #7#)
                                 (QCDR #4#)
                               (|check-union| (QEQCAR #4# 3)
                                              (|Record| (|:| |num| $)
                                                        (|:| |den| $))
                                              #4#)))
                            (QREFELT $ 114))
                           (QREFELT $ 115)))
                         ((QEQCAR |q| 1)
                          (SPADCALL
                           (PROGN
                            (LETT #3# NIL . #7#)
                            (SEQ (LETT |r| NIL . #7#)
                                 (LETT #1#
                                       (QVELT
                                        (PROG2
                                            (LETT #2# |q| . #7#)
                                            (QCDR #2#)
                                          (|check-union| (QEQCAR #2# 1)
                                                         (|Record|
                                                          (|:| |tag|
                                                               (|SingleInteger|))
                                                          (|:| |op|
                                                               (|BasicOperator|))
                                                          (|:| |arg|
                                                               (|List| $)))
                                                         #2#))
                                        2)
                                       . #7#)
                                 G190
                                 (COND
                                  ((OR (ATOM #1#)
                                       (PROGN (LETT |r| (CAR #1#) . #7#) NIL))
                                   (GO G191)))
                                 (SEQ
                                  (EXIT
                                   (LETT #3#
                                         (CONS (SPADCALL |r| (QREFELT $ 114))
                                               #3#)
                                         . #7#)))
                                 (LETT #1# (CDR #1#) . #7#) (GO G190) G191
                                 (EXIT (NREVERSE0 #3#))))
                           (QREFELT $ 116)))
                         (#6# (SPADCALL (QREFELT $ 93)))))))))))) 

(DEFUN |PATTERN;PAT2O| (|p| $)
  (PROG (#1=#:G2338 |u| |l| #2=#:G2359 |x| #3=#:G2358 #4=#:G2340 #5=#:G2339
         #6=#:G2341)
    (RETURN
     (SEQ
      (COND ((QEQCAR |p| 0) (SPADCALL (CDR |p|) (QREFELT $ 117)))
            ((QEQCAR |p| 4)
             (|PATTERN;SYM2O|
              (PROG2
                  (LETT #6# |p| . #7=(|PATTERN;PAT2O|))
                  (QCDR #6#)
                (|check-union| (QEQCAR #6# 4)
                               (|Record| (|:| |tag| (|SingleInteger|))
                                         (|:| |val| (|Symbol|))
                                         (|:| |pred| (|List| (|Any|)))
                                         (|:| |bad| (|List| (|Any|))))
                               #6#))
              $))
            ((QEQCAR |p| 2)
             (SPADCALL
              (SPADCALL
               (QCAR
                (PROG2
                    (LETT #5# |p| . #7#)
                    (QCDR #5#)
                  (|check-union| (QEQCAR #5# 2)
                                 (|Record| (|:| |val| $)
                                           (|:| |exponent|
                                                (|NonNegativeInteger|)))
                                 #5#)))
               (QREFELT $ 50))
              (SPADCALL
               (QCDR
                (PROG2
                    (LETT #5# |p| . #7#)
                    (QCDR #5#)
                  (|check-union| (QEQCAR #5# 2)
                                 (|Record| (|:| |val| $)
                                           (|:| |exponent|
                                                (|NonNegativeInteger|)))
                                 #5#)))
               (QREFELT $ 110))
              (QREFELT $ 118)))
            ((QEQCAR |p| 3)
             (SPADCALL
              (SPADCALL
               (QCAR
                (PROG2
                    (LETT #4# |p| . #7#)
                    (QCDR #4#)
                  (|check-union| (QEQCAR #4# 3)
                                 (|Record| (|:| |num| $) (|:| |den| $)) #4#)))
               (QREFELT $ 50))
              (SPADCALL
               (QCDR
                (PROG2
                    (LETT #4# |p| . #7#)
                    (QCDR #4#)
                  (|check-union| (QEQCAR #4# 3)
                                 (|Record| (|:| |num| $) (|:| |den| $)) #4#)))
               (QREFELT $ 50))
              (QREFELT $ 119)))
            (#8='T
             (COND
              ((EQL
                (QVELT
                 (PROG2
                     (LETT #1# |p| . #7#)
                     (QCDR #1#)
                   (|check-union| (QEQCAR #1# 1)
                                  (|Record| (|:| |tag| (|SingleInteger|))
                                            (|:| |op| (|BasicOperator|))
                                            (|:| |arg| (|List| $)))
                                  #1#))
                 0)
                1)
               (|PATTERN;LPAT2O| (ELT $ 120)
                (QVELT
                 (PROG2
                     (LETT #1# |p| . #7#)
                     (QCDR #1#)
                   (|check-union| (QEQCAR #1# 1)
                                  (|Record| (|:| |tag| (|SingleInteger|))
                                            (|:| |op| (|BasicOperator|))
                                            (|:| |arg| (|List| $)))
                                  #1#))
                 2)
                $))
              ((EQL
                (QVELT
                 (PROG2
                     (LETT #1# |p| . #7#)
                     (QCDR #1#)
                   (|check-union| (QEQCAR #1# 1)
                                  (|Record| (|:| |tag| (|SingleInteger|))
                                            (|:| |op| (|BasicOperator|))
                                            (|:| |arg| (|List| $)))
                                  #1#))
                 0)
                (SPADCALL 2 (QREFELT $ 33)))
               (|PATTERN;LPAT2O| (ELT $ 121)
                (QVELT
                 (PROG2
                     (LETT #1# |p| . #7#)
                     (QCDR #1#)
                   (|check-union| (QEQCAR #1# 1)
                                  (|Record| (|:| |tag| (|SingleInteger|))
                                            (|:| |op| (|BasicOperator|))
                                            (|:| |arg| (|List| $)))
                                  #1#))
                 2)
                $))
              ((EQL
                (QVELT
                 (PROG2
                     (LETT #1# |p| . #7#)
                     (QCDR #1#)
                   (|check-union| (QEQCAR #1# 1)
                                  (|Record| (|:| |tag| (|SingleInteger|))
                                            (|:| |op| (|BasicOperator|))
                                            (|:| |arg| (|List| $)))
                                  #1#))
                 0)
                (SPADCALL 3 (QREFELT $ 33)))
               (SPADCALL
                (QVELT
                 (PROG2
                     (LETT #1# |p| . #7#)
                     (QCDR #1#)
                   (|check-union| (QEQCAR #1# 1)
                                  (|Record| (|:| |tag| (|SingleInteger|))
                                            (|:| |op| (|BasicOperator|))
                                            (|:| |arg| (|List| $)))
                                  #1#))
                 2)
                (QREFELT $ 122)))
              ((EQL
                (QVELT
                 (PROG2
                     (LETT #1# |p| . #7#)
                     (QCDR #1#)
                   (|check-union| (QEQCAR #1# 1)
                                  (|Record| (|:| |tag| (|SingleInteger|))
                                            (|:| |op| (|BasicOperator|))
                                            (|:| |arg| (|List| $)))
                                  #1#))
                 0)
                (SPADCALL 4 (QREFELT $ 33)))
               (SPADCALL 0 (QREFELT $ 123)))
              ((EQL
                (QVELT
                 (PROG2
                     (LETT #1# |p| . #7#)
                     (QCDR #1#)
                   (|check-union| (QEQCAR #1# 1)
                                  (|Record| (|:| |tag| (|SingleInteger|))
                                            (|:| |op| (|BasicOperator|))
                                            (|:| |arg| (|List| $)))
                                  #1#))
                 0)
                (SPADCALL 5 (QREFELT $ 33)))
               (SPADCALL 1 (QREFELT $ 123)))
              (#8#
               (SEQ
                (LETT |l|
                      (PROGN
                       (LETT #3# NIL . #7#)
                       (SEQ (LETT |x| NIL . #7#)
                            (LETT #2#
                                  (QVELT
                                   (PROG2
                                       (LETT #1# |p| . #7#)
                                       (QCDR #1#)
                                     (|check-union| (QEQCAR #1# 1)
                                                    (|Record|
                                                     (|:| |tag|
                                                          (|SingleInteger|))
                                                     (|:| |op|
                                                          (|BasicOperator|))
                                                     (|:| |arg| (|List| $)))
                                                    #1#))
                                   2)
                                  . #7#)
                            G190
                            (COND
                             ((OR (ATOM #2#)
                                  (PROGN (LETT |x| (CAR #2#) . #7#) NIL))
                              (GO G191)))
                            (SEQ
                             (EXIT
                              (LETT #3#
                                    (CONS (SPADCALL |x| (QREFELT $ 50)) #3#)
                                    . #7#)))
                            (LETT #2# (CDR #2#) . #7#) (GO G190) G191
                            (EXIT (NREVERSE0 #3#))))
                      . #7#)
                (LETT |u|
                      (SPADCALL
                       (QVELT
                        (PROG2
                            (LETT #1# |p| . #7#)
                            (QCDR #1#)
                          (|check-union| (QEQCAR #1# 1)
                                         (|Record|
                                          (|:| |tag| (|SingleInteger|))
                                          (|:| |op| (|BasicOperator|))
                                          (|:| |arg| (|List| $)))
                                         #1#))
                        1)
                       (QREFELT $ 126))
                      . #7#)
                (EXIT
                 (COND
                  ((QEQCAR |u| 1)
                   (SPADCALL
                    (SPADCALL
                     (SPADCALL
                      (QVELT
                       (PROG2
                           (LETT #1# |p| . #7#)
                           (QCDR #1#)
                         (|check-union| (QEQCAR #1# 1)
                                        (|Record| (|:| |tag| (|SingleInteger|))
                                                  (|:| |op| (|BasicOperator|))
                                                  (|:| |arg| (|List| $)))
                                        #1#))
                       1)
                      (QREFELT $ 127))
                     (QREFELT $ 108))
                    |l| (QREFELT $ 128)))
                  (#8# (SPADCALL |l| (QCDR |u|)))))))))))))) 

(DEFUN |PATTERN;patcopy| (|p| $)
  (PROG (#1=#:G2366 #2=#:G2367 #3=#:G2375 #4=#:G2365 |x| #5=#:G2374 #6=#:G2368)
    (RETURN
     (SEQ
      (COND ((QEQCAR |p| 0) (CONS 0 (CDR |p|)))
            ((QEQCAR |p| 4)
             (CONS 4
                   (VECTOR
                    (QVELT
                     (PROG2
                         (LETT #6# |p| . #7=(|PATTERN;patcopy|))
                         (QCDR #6#)
                       (|check-union| (QEQCAR #6# 4)
                                      (|Record| (|:| |tag| (|SingleInteger|))
                                                (|:| |val| (|Symbol|))
                                                (|:| |pred| (|List| (|Any|)))
                                                (|:| |bad| (|List| (|Any|))))
                                      #6#))
                     0)
                    (QVELT
                     (PROG2
                         (LETT #6# |p| . #7#)
                         (QCDR #6#)
                       (|check-union| (QEQCAR #6# 4)
                                      (|Record| (|:| |tag| (|SingleInteger|))
                                                (|:| |val| (|Symbol|))
                                                (|:| |pred| (|List| (|Any|)))
                                                (|:| |bad| (|List| (|Any|))))
                                      #6#))
                     1)
                    (SPADCALL
                     (QVELT
                      (PROG2
                          (LETT #6# |p| . #7#)
                          (QCDR #6#)
                        (|check-union| (QEQCAR #6# 4)
                                       (|Record| (|:| |tag| (|SingleInteger|))
                                                 (|:| |val| (|Symbol|))
                                                 (|:| |pred| (|List| (|Any|)))
                                                 (|:| |bad| (|List| (|Any|))))
                                       #6#))
                      2)
                     (QREFELT $ 129))
                    (SPADCALL
                     (QVELT
                      (PROG2
                          (LETT #6# |p| . #7#)
                          (QCDR #6#)
                        (|check-union| (QEQCAR #6# 4)
                                       (|Record| (|:| |tag| (|SingleInteger|))
                                                 (|:| |val| (|Symbol|))
                                                 (|:| |pred| (|List| (|Any|)))
                                                 (|:| |bad| (|List| (|Any|))))
                                       #6#))
                      3)
                     (QREFELT $ 129)))))
            ((QEQCAR |p| 1)
             (CONS 1
                   (VECTOR
                    (QVELT
                     (PROG2
                         (LETT #4# |p| . #7#)
                         (QCDR #4#)
                       (|check-union| (QEQCAR #4# 1)
                                      (|Record| (|:| |tag| (|SingleInteger|))
                                                (|:| |op| (|BasicOperator|))
                                                (|:| |arg| (|List| $)))
                                      #4#))
                     0)
                    (QVELT
                     (PROG2
                         (LETT #4# |p| . #7#)
                         (QCDR #4#)
                       (|check-union| (QEQCAR #4# 1)
                                      (|Record| (|:| |tag| (|SingleInteger|))
                                                (|:| |op| (|BasicOperator|))
                                                (|:| |arg| (|List| $)))
                                      #4#))
                     1)
                    (PROGN
                     (LETT #5# NIL . #7#)
                     (SEQ (LETT |x| NIL . #7#)
                          (LETT #3#
                                (QVELT
                                 (PROG2
                                     (LETT #4# |p| . #7#)
                                     (QCDR #4#)
                                   (|check-union| (QEQCAR #4# 1)
                                                  (|Record|
                                                   (|:| |tag|
                                                        (|SingleInteger|))
                                                   (|:| |op| (|BasicOperator|))
                                                   (|:| |arg| (|List| $)))
                                                  #4#))
                                 2)
                                . #7#)
                          G190
                          (COND
                           ((OR (ATOM #3#)
                                (PROGN (LETT |x| (CAR #3#) . #7#) NIL))
                            (GO G191)))
                          (SEQ
                           (EXIT
                            (LETT #5# (CONS (SPADCALL |x| (QREFELT $ 60)) #5#)
                                  . #7#)))
                          (LETT #3# (CDR #3#) . #7#) (GO G190) G191
                          (EXIT (NREVERSE0 #5#)))))))
            ((QEQCAR |p| 3)
             (CONS 3
                   (CONS
                    (SPADCALL
                     (QCAR
                      (PROG2
                          (LETT #2# |p| . #7#)
                          (QCDR #2#)
                        (|check-union| (QEQCAR #2# 3)
                                       (|Record| (|:| |num| $) (|:| |den| $))
                                       #2#)))
                     (QREFELT $ 60))
                    (SPADCALL
                     (QCDR
                      (PROG2
                          (LETT #2# |p| . #7#)
                          (QCDR #2#)
                        (|check-union| (QEQCAR #2# 3)
                                       (|Record| (|:| |num| $) (|:| |den| $))
                                       #2#)))
                     (QREFELT $ 60)))))
            ('T
             (CONS 2
                   (CONS
                    (SPADCALL
                     (QCAR
                      (PROG2
                          (LETT #1# |p| . #7#)
                          (QCDR #1#)
                        (|check-union| (QEQCAR #1# 2)
                                       (|Record| (|:| |val| $)
                                                 (|:| |exponent|
                                                      (|NonNegativeInteger|)))
                                       #1#)))
                     (QREFELT $ 60))
                    (QCDR
                     (PROG2
                         (LETT #1# |p| . #7#)
                         (QCDR #1#)
                       (|check-union| (QEQCAR #1# 2)
                                      (|Record| (|:| |val| $)
                                                (|:| |exponent|
                                                     (|NonNegativeInteger|)))
                                      #1#))))))))))) 

(DEFUN |PATTERN;pateq?| (|p1| |p2| $)
  (PROG (#1=#:G2382 #2=#:G2381 #3=#:G2384 #4=#:G2383)
    (RETURN
     (COND
      ((QEQCAR |p1| 0)
       (COND ((QEQCAR |p2| 0) (SPADCALL (CDR |p1|) (CDR |p2|) (QREFELT $ 130)))
             (#5='T 'NIL)))
      ((QEQCAR |p1| 3)
       (COND
        ((QEQCAR |p2| 3)
         (COND
          ((SPADCALL
            (QCAR
             (PROG2
                 (LETT #4# |p1| . #6=(|PATTERN;pateq?|))
                 (QCDR #4#)
               (|check-union| (QEQCAR #4# 3)
                              (|Record| (|:| |num| $) (|:| |den| $)) #4#)))
            (QCAR (CDR |p2|)) (QREFELT $ 77))
           (SPADCALL
            (QCDR
             (PROG2
                 (LETT #4# |p1| . #6#)
                 (QCDR #4#)
               (|check-union| (QEQCAR #4# 3)
                              (|Record| (|:| |num| $) (|:| |den| $)) #4#)))
            (QCDR (CDR |p2|)) (QREFELT $ 77)))
          (#5# 'NIL)))
        (#5# 'NIL)))
      ((QEQCAR |p1| 4)
       (COND
        ((QEQCAR |p2| 4)
         (COND
          ((EQUAL
            (QVELT
             (PROG2
                 (LETT #3# |p1| . #6#)
                 (QCDR #3#)
               (|check-union| (QEQCAR #3# 4)
                              (|Record| (|:| |tag| (|SingleInteger|))
                                        (|:| |val| (|Symbol|))
                                        (|:| |pred| (|List| (|Any|)))
                                        (|:| |bad| (|List| (|Any|))))
                              #3#))
             1)
            (QVELT (CDR |p2|) 1))
           (COND
            ((SPADCALL
              (SPADCALL
               (QVELT
                (PROG2
                    (LETT #3# |p1| . #6#)
                    (QCDR #3#)
                  (|check-union| (QEQCAR #3# 4)
                                 (|Record| (|:| |tag| (|SingleInteger|))
                                           (|:| |val| (|Symbol|))
                                           (|:| |pred| (|List| (|Any|)))
                                           (|:| |bad| (|List| (|Any|))))
                                 #3#))
                2)
               (QREFELT $ 132))
              (SPADCALL (QVELT (CDR |p2|) 2) (QREFELT $ 132)) (QREFELT $ 133))
             (SPADCALL
              (SPADCALL
               (QVELT
                (PROG2
                    (LETT #3# |p1| . #6#)
                    (QCDR #3#)
                  (|check-union| (QEQCAR #3# 4)
                                 (|Record| (|:| |tag| (|SingleInteger|))
                                           (|:| |val| (|Symbol|))
                                           (|:| |pred| (|List| (|Any|)))
                                           (|:| |bad| (|List| (|Any|))))
                                 #3#))
                3)
               (QREFELT $ 132))
              (SPADCALL (QVELT (CDR |p2|) 3) (QREFELT $ 132)) (QREFELT $ 133)))
            (#5# 'NIL)))
          (#5# 'NIL)))
        (#5# 'NIL)))
      ((QEQCAR |p1| 1)
       (COND
        ((QEQCAR |p2| 1)
         (COND
          ((EQL
            (QVELT
             (PROG2
                 (LETT #2# |p1| . #6#)
                 (QCDR #2#)
               (|check-union| (QEQCAR #2# 1)
                              (|Record| (|:| |tag| (|SingleInteger|))
                                        (|:| |op| (|BasicOperator|))
                                        (|:| |arg| (|List| $)))
                              #2#))
             0)
            (QVELT (CDR |p2|) 0))
           (COND
            ((SPADCALL
              (QVELT
               (PROG2
                   (LETT #2# |p1| . #6#)
                   (QCDR #2#)
                 (|check-union| (QEQCAR #2# 1)
                                (|Record| (|:| |tag| (|SingleInteger|))
                                          (|:| |op| (|BasicOperator|))
                                          (|:| |arg| (|List| $)))
                                #2#))
               1)
              (QVELT (CDR |p2|) 1) (QREFELT $ 102))
             (SPADCALL
              (QVELT
               (PROG2
                   (LETT #2# |p1| . #6#)
                   (QCDR #2#)
                 (|check-union| (QEQCAR #2# 1)
                                (|Record| (|:| |tag| (|SingleInteger|))
                                          (|:| |op| (|BasicOperator|))
                                          (|:| |arg| (|List| $)))
                                #2#))
               2)
              (QVELT (CDR |p2|) 2) (QREFELT $ 134)))
            (#5# 'NIL)))
          (#5# 'NIL)))
        (#5# 'NIL)))
      ((QEQCAR |p2| 2)
       (COND
        ((EQL
          (QCDR
           (PROG2
               (LETT #1# |p1| . #6#)
               (QCDR #1#)
             (|check-union| (QEQCAR #1# 2)
                            (|Record| (|:| |val| $)
                                      (|:| |exponent| (|NonNegativeInteger|)))
                            #1#)))
          (QCDR (CDR |p2|)))
         (SPADCALL
          (QCAR
           (PROG2
               (LETT #1# |p1| . #6#)
               (QCDR #1#)
             (|check-union| (QEQCAR #1# 2)
                            (|Record| (|:| |val| $)
                                      (|:| |exponent| (|NonNegativeInteger|)))
                            #1#)))
          (QCAR (CDR |p2|)) (QREFELT $ 77)))
        (#5# 'NIL)))
      (#5# 'NIL))))) 

(DEFUN |PATTERN;retractIfCan;$U;57| (|p| $)
  (PROG (#1=#:G2404)
    (RETURN
     (COND
      ((SPADCALL |p| (QREFELT $ 29))
       (CONS 0
             (QVELT
              (PROG2
                  (LETT #1# (QVELT |p| 1) |PATTERN;retractIfCan;$U;57|)
                  (QCDR #1#)
                (|check-union| (QEQCAR #1# 4)
                               (|Record| (|:| |tag| (|SingleInteger|))
                                         (|:| |val| (|Symbol|))
                                         (|:| |pred| (|List| (|Any|)))
                                         (|:| |bad| (|List| (|Any|))))
                               #1#))
              1)))
      ('T (CONS 1 "failed")))))) 

(DEFUN |PATTERN;mkrsy| (|t| |c?| |o?| |m?| $)
  (PROG (|opt| |mlt|)
    (RETURN
     (SEQ
      (COND (|c?| (VECTOR 0 |t| NIL NIL))
            (#1='T
             (SEQ (LETT |mlt| (COND (|m?| 2) (#1# 0)) . #2=(|PATTERN;mkrsy|))
                  (LETT |opt| (COND (|o?| 4) (#1# 0)) . #2#)
                  (EXIT
                   (VECTOR (LOGIOR (LOGIOR 1 |mlt|) |opt|) |t| NIL NIL))))))))) 

(DEFUN |PATTERN;patternVariable;S3B$;59| (|sy| |c?| |o?| |m?| $)
  (PROG (|rsy|)
    (RETURN
     (SEQ
      (LETT |rsy| (|PATTERN;mkrsy| |sy| |c?| |o?| |m?| $)
            |PATTERN;patternVariable;S3B$;59|)
      (EXIT (|PATTERN;mkPat| (ZEROP (QVELT |rsy| 0)) (CONS 4 |rsy|) 0 $)))))) 

(DEFUN |Pattern| (#1=#:G2424)
  (PROG ()
    (RETURN
     (PROG (#2=#:G2425)
       (RETURN
        (COND
         ((LETT #2#
                (|lassocShiftWithFunction| (LIST (|devaluate| #1#))
                                           (HGET |$ConstructorCache|
                                                 '|Pattern|)
                                           '|domainEqualList|)
                . #3=(|Pattern|))
          (|CDRwithIncrement| #2#))
         ('T
          (UNWIND-PROTECT (PROG1 (|Pattern;| #1#) (LETT #2# T . #3#))
            (COND ((NOT #2#) (HREM |$ConstructorCache| '|Pattern|))))))))))) 

(DEFUN |Pattern;| (|#1|)
  (PROG (|pv$| $ |dv$| DV$1)
    (RETURN
     (PROGN
      (LETT DV$1 (|devaluate| |#1|) . #1=(|Pattern|))
      (LETT |dv$| (LIST '|Pattern| DV$1) . #1#)
      (LETT $ (GETREFV 138) . #1#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#))
      (|haddProp| |$ConstructorCache| '|Pattern| (LIST DV$1) (CONS 1 $))
      (|stuffDomainSlots| $)
      (QSETREFV $ 6 |#1|)
      (QSETREFV $ 7
                (|Record| (|:| |cons?| (|Boolean|))
                          (|:| |pat|
                               (|Union| (|:| |ret| |#1|)
                                        (|:| |ker|
                                             (|Record|
                                              (|:| |tag| (|SingleInteger|))
                                              (|:| |op| (|BasicOperator|))
                                              (|:| |arg| (|List| $))))
                                        (|:| |exp|
                                             (|Record| (|:| |val| $)
                                                       (|:| |exponent|
                                                            (|NonNegativeInteger|))))
                                        (|:| |qot|
                                             (|Record| (|:| |num| $)
                                                       (|:| |den| $)))
                                        (|:| |sym|
                                             (|Record|
                                              (|:| |tag| (|SingleInteger|))
                                              (|:| |val| (|Symbol|))
                                              (|:| |pred| (|List| (|Any|)))
                                              (|:| |bad| (|List| (|Any|)))))))
                          (|:| |lev| (|NonNegativeInteger|))
                          (|:| |topvar| (|List| (|Symbol|)))
                          (|:| |toppred| (|Any|))))
      (QSETREFV $ 12 (SPADCALL (SPADCALL (QREFELT $ 9)) (QREFELT $ 11)))
      (QSETREFV $ 17 (SPADCALL 0 (QREFELT $ 16)))
      (COND
       ((|HasCategory| |#1| '(|Monoid|))
        (QSETREFV $ 71
                  (CONS IDENTITY
                        (FUNCALL (|dispatchFunction| |PATTERN;One;$;38|) $))))
       ('T
        (QSETREFV $ 71
                  (CONS IDENTITY
                        (FUNCALL (|dispatchFunction| |PATTERN;One;$;39|) $)))))
      (COND
       ((|HasCategory| |#1| '(|AbelianMonoid|))
        (QSETREFV $ 87
                  (CONS IDENTITY
                        (FUNCALL (|dispatchFunction| |PATTERN;Zero;$;40|) $))))
       ('T
        (QSETREFV $ 87
                  (CONS IDENTITY
                        (FUNCALL (|dispatchFunction| |PATTERN;Zero;$;41|)
                                 $)))))
      $)))) 

(MAKEPROP '|Pattern| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) '|Rep| (|Symbol|)
              (0 . |new|) (|BasicOperator|) (4 . |operator|) '|dummy| (|Any|)
              (|Integer|) (|AnyFunctions1| 14) (9 . |coerce|) '|nopred|
              |PATTERN;coerce;R$;1| (|Boolean|) |PATTERN;hasTopPredicate?;$B;3|
              (|Record| (|:| |var| 23) (|:| |pred| 13))
              |PATTERN;topPredicate;$R;4| (|List| 8)
              |PATTERN;setTopPredicate;$LA$;5| |PATTERN;constant?;$B;6|
              (|NonNegativeInteger|) |PATTERN;depth;$Nni;7| |PATTERN;inR?;$B;8|
              |PATTERN;symbol?;$B;9| (|Union| 56 '"failed")
              |PATTERN;isPlus;$U;10| (|SingleInteger|) (14 . |coerce|)
              |PATTERN;isTimes;$U;11| |PATTERN;isList;$U;12|
              (|Record| (|:| |val| $) (|:| |exponent| 26))
              (|Union| 36 '"failed") |PATTERN;isExpt;$U;13|
              (|Record| (|:| |num| $) (|:| |den| $)) (|Union| 39 '"failed")
              |PATTERN;isQuotient;$U;14| (|List| 13) |PATTERN;predicates;$L;47|
              |PATTERN;hasPredicate?;$B;15| |PATTERN;quoted?;$B;16|
              |PATTERN;generic?;$B;17| |PATTERN;multiple?;$B;18|
              |PATTERN;optional?;$B;19| (|OutputForm|) |PATTERN;coerce;$Of;21|
              |PATTERN;^;3$;22| (|Mapping| 49 49 49) (|List| 49)
              (19 . |reduce|) |PATTERN;retract;$R;24| (|List| $)
              |PATTERN;convert;L$;25| (|Union| 6 '"failed")
              |PATTERN;retractIfCan;$U;26| |PATTERN;copy;2$;29|
              |PATTERN;setPredicates;$L$;48| |PATTERN;withPredicates;$L$;27|
              |PATTERN;patternVariable;S3B$;59| |PATTERN;coerce;S$;28|
              (|List| $$) (25 . |rest|) (30 . |empty?|) (35 . |first|)
              (40 . |reverse|) |PATTERN;optpair;LU;30| (45 . |One|)
              (49 . |max|) (|Mapping| 26 26 26) (|List| 26) (55 . |reduce|)
              (62 . =) |PATTERN;=;2$B;32| (68 . |second|)
              (|Record| (|:| |val| $) (|:| |exponent| $))
              (|Union| 79 '"failed") |PATTERN;isPower;$U;33| (|Mapping| 19 $$)
              (73 . |every?|) (79 . |is?|) (85 . |#|) (90 . |last|)
              (95 . |Zero|) |PATTERN;elt;BoL$;35|
              (|Record| (|:| |op| 10) (|:| |arg| 56)) (|Union| 89 '"failed")
              |PATTERN;isOp;$U;36| (99 . |One|) (103 . |empty|) (107 . |Zero|)
              |PATTERN;^;$Nni$;42| |PATTERN;/;3$;43| (111 . |concat|)
              (117 . |concat|) (123 . |concat|) |PATTERN;+;3$;44|
              |PATTERN;*;3$;45| (129 . =) |PATTERN;isOp;$BoU;46|
              |PATTERN;resetBadValues;2$;49| (135 . |member?|)
              |PATTERN;addBadValue;$A$;50| |PATTERN;getBadValues;$L;51|
              (141 . |coerce|) (146 . |and|) (152 . |coerce|) (157 . |sub|)
              (163 . |infix|) (170 . |paren|) |PATTERN;variables;$L;53|
              (175 . |concat!|) (181 . |concat|) (186 . |coerce|) (191 . ^)
              (197 . /) (203 . +) (209 . *) (215 . |coerce|) (220 . |coerce|)
              (|Mapping| 49 53) (|Union| 124 '"failed") (225 . |display|)
              (230 . |name|) (235 . |prefix|) (241 . |copy|) (246 . =)
              (|Set| 13) (252 . |brace|) (257 . =) (263 . =)
              (|Union| 8 '"failed") |PATTERN;retractIfCan;$U;57| (|String|))
           '#(~= 269 |withPredicates| 275 |variables| 281 |topPredicate| 286
              |symbol?| 291 |setTopPredicate| 296 |setPredicates| 303
              |retractIfCan| 309 |retract| 319 |resetBadValues| 329 |quoted?|
              334 |predicates| 339 |patternVariable| 344 |optpair| 352
              |optional?| 357 |multiple?| 362 |latex| 367 |isTimes| 372
              |isQuotient| 377 |isPower| 382 |isPlus| 387 |isOp| 392 |isList|
              403 |isExpt| 408 |inR?| 413 |hash| 418 |hasTopPredicate?| 423
              |hasPredicate?| 428 |getBadValues| 433 |generic?| 438 |elt| 443
              |depth| 449 |copy| 454 |convert| 459 |constant?| 464 |coerce| 469
              |addBadValue| 484 ^ 490 |Zero| 502 |One| 506 = 510 / 516 + 522 *
              528)
           'NIL
           (CONS (|makeByteWordVec2| 1 '(0 0 0 0 0))
                 (CONS
                  '#(|SetCategory&| |BasicType&| |RetractableTo&|
                     |RetractableTo&| NIL)
                  (CONS
                   '#((|SetCategory|) (|BasicType|) (|RetractableTo| 8)
                      (|RetractableTo| 6) (|CoercibleTo| 49))
                   (|makeByteWordVec2| 137
                                       '(0 8 0 9 1 10 0 8 11 1 15 13 14 16 1 32
                                         0 14 33 2 53 49 52 0 54 1 65 0 0 66 1
                                         65 19 0 67 1 65 2 0 68 1 65 0 0 69 0 0
                                         0 71 2 26 0 0 0 72 3 74 26 73 0 26 75
                                         2 23 19 0 0 76 1 65 2 0 78 2 65 19 82
                                         0 83 2 10 19 0 8 84 1 65 26 0 85 1 65
                                         2 0 86 0 0 0 87 0 6 0 92 0 65 0 93 0 6
                                         0 94 2 65 0 0 0 97 2 65 0 0 2 98 2 65
                                         0 2 0 99 2 10 19 0 0 102 2 42 19 13 0
                                         105 1 8 49 0 108 2 49 0 0 0 109 1 26
                                         49 0 110 2 49 0 0 0 111 3 49 0 0 0 0
                                         112 1 49 0 0 113 2 65 0 0 0 115 1 65 0
                                         56 116 1 6 49 0 117 2 49 0 0 0 118 2
                                         49 0 0 0 119 2 49 0 0 0 120 2 49 0 0 0
                                         121 1 65 49 0 122 1 14 49 0 123 1 10
                                         125 0 126 1 10 8 0 127 2 49 0 0 56 128
                                         1 42 0 0 129 2 6 19 0 0 130 1 131 0 42
                                         132 2 131 19 0 0 133 2 65 19 0 0 134 2
                                         0 19 0 0 1 2 0 0 0 42 62 1 0 56 0 114
                                         1 0 21 0 22 1 0 19 0 29 3 0 0 0 23 13
                                         24 2 0 0 0 42 61 1 0 135 0 136 1 0 58
                                         0 59 1 0 8 0 1 1 0 6 0 55 1 0 0 0 104
                                         1 0 19 0 45 1 0 42 0 43 4 0 0 8 19 19
                                         19 63 1 0 30 56 70 1 0 19 0 48 1 0 19
                                         0 47 1 0 137 0 1 1 0 30 0 34 1 0 40 0
                                         41 1 0 80 0 81 1 0 30 0 31 1 0 90 0 91
                                         2 0 30 0 10 103 1 0 30 0 35 1 0 37 0
                                         38 1 0 19 0 28 1 0 32 0 1 1 0 19 0 20
                                         1 0 19 0 44 1 0 42 0 107 1 0 19 0 46 2
                                         0 0 10 56 88 1 0 26 0 27 1 0 0 0 60 1
                                         0 0 56 57 1 0 19 0 25 1 0 0 8 64 1 0 0
                                         6 18 1 0 49 0 50 2 0 0 0 13 106 2 0 0
                                         0 0 51 2 0 0 0 26 95 0 0 0 87 0 0 0 71
                                         2 0 19 0 0 77 2 0 0 0 0 96 2 0 0 0 0
                                         100 2 0 0 0 0 101)))))
           '|lookupComplete|)) 
