
(/VERSIONCHECK 2) 

(DEFUN |PMPLCAT;patternMatch;PP2Pmr;1| (|x| |p| |l| $)
  (SPADCALL |x| |p| |l| (ELT $ 14) (QREFELT $ 16))) 

(DEFUN |PMPLCAT;patternMatch;PPPmrMPmr;2| (|x| |p| |l| |vmatch| $)
  (PROG (|r| |v| |lx| #0=#:G1852 |u| #1=#:G1849 |uu| #2=#:G1872 |uur|
             |ep| |ex| #3=#:G1897)
    (RETURN
      (SEQ (COND
             ((SPADCALL |p| (QREFELT $ 19))
              (SPADCALL |p| |x| |l| (QREFELT $ 20)))
             ('T
              (SEQ (LETT |r| (SPADCALL |x| (QREFELT $ 22))
                         . #4=(|PMPLCAT;patternMatch;PPPmrMPmr;2|))
                   (EXIT (COND
                           ((QEQCAR |r| 0)
                            (SPADCALL (QCDR |r|) |p| |l|
                                (QREFELT $ 24)))
                           ('T
                            (SEQ (LETT |v|
                                       (SPADCALL |x| (QREFELT $ 26)) . #4#)
                                 (EXIT (COND
                                         ((QEQCAR |v| 0)
                                          (SPADCALL (QCDR |v|) |p| |l|
                                           |vmatch|))
                                         ((QEQCAR
                                           (LETT |u|
                                            (SPADCALL |p|
                                             (QREFELT $ 28)) . #4#)
                                           0)
                                          (COND
                                            ((QEQCAR
                                              (LETT |lx|
                                               (SPADCALL |x|
                                                (QREFELT $ 29)) . #4#)
                                              0)
                                             (SPADCALL
                                              (PROG2
                                               (LETT #0# |lx| . #4#)
                                               (QCDR #0#)
                                                (|check-union|
                                                 (QEQCAR #0# 0)
                                                 (|List|
                                                  (QREFELT $ 10))
                                                 #0#))
                                              (PROG2
                                               (LETT #1# |u| . #4#)
                                               (QCDR #1#)
                                                (|check-union|
                                                 (QEQCAR #1# 0)
                                                 (|List|
                                                  (|Pattern|
                                                   (QREFELT $ 6)))
                                                 #1#))
                                              (CONS
                                               #'|PMPLCAT;patternMatch;PPPmrMPmr;2!0|
                                               $)
                                              |l|
                                              (CONS
                                               #'|PMPLCAT;patternMatch;PPPmrMPmr;2!1|
                                               (VECTOR $ |vmatch|))
                                              (QREFELT $ 37)))
                                            ((QEQCAR
                                              (LETT |u|
                                               (SPADCALL
                                                (PROG2
                                                 (LETT #1# |u| . #4#)
                                                 (QCDR #1#)
                                                  (|check-union|
                                                   (QEQCAR #1# 0)
                                                   (|List|
                                                    (|Pattern|
                                                     (QREFELT $ 6)))
                                                   #1#))
                                                (QREFELT $ 39)) . #4#)
                                              0)
                                             (COND
                                               ((SPADCALL
                                                 (LETT |l|
                                                  (SPADCALL
                                                   (|SPADfirst|
                                                    (PROG2
                                                     (LETT #1#
                                                      |u| . #4#)
                                                     (QCDR #1#)
                                                      (|check-union|
                                                       (QEQCAR #1# 0)
                                                       (|List|
                                                        (|Pattern|
                                                         (QREFELT $ 6)))
                                                       #1#)))
                                                   (|spadConstant| $
                                                    31)
                                                   |l| (QREFELT $ 20)) . #4#)
                                                 (QREFELT $ 40))
                                                (SPADCALL
                                                 (QREFELT $ 41)))
                                               ('T
                                                (SPADCALL |x|
                                                 (SPADCALL
                                                  (PROG2
                                                   (LETT #1# |u| . #4#)
                                                   (QCDR #1#)
                                                    (|check-union|
                                                     (QEQCAR #1# 0)
                                                     (|List|
                                                      (|Pattern|
                                                       (QREFELT $ 6)))
                                                     #1#))
                                                  (QREFELT $ 42))
                                                 |l| |vmatch|
                                                 (QREFELT $ 16)))))
                                            ('T
                                             (SPADCALL (QREFELT $ 41)))))
                                         ((QEQCAR
                                           (LETT |u|
                                            (SPADCALL |p|
                                             (QREFELT $ 43)) . #4#)
                                           0)
                                          (COND
                                            ((QEQCAR
                                              (LETT |lx|
                                               (SPADCALL |x|
                                                (QREFELT $ 44)) . #4#)
                                              0)
                                             (SPADCALL
                                              (PROG2
                                               (LETT #0# |lx| . #4#)
                                               (QCDR #0#)
                                                (|check-union|
                                                 (QEQCAR #0# 0)
                                                 (|List|
                                                  (QREFELT $ 10))
                                                 #0#))
                                              (PROG2
                                               (LETT #1# |u| . #4#)
                                               (QCDR #1#)
                                                (|check-union|
                                                 (QEQCAR #1# 0)
                                                 (|List|
                                                  (|Pattern|
                                                   (QREFELT $ 6)))
                                                 #1#))
                                              |l|
                                              (CONS
                                               #'|PMPLCAT;patternMatch;PPPmrMPmr;2!2|
                                               (VECTOR $ |vmatch|))
                                              (QREFELT $ 45)))
                                            ((QEQCAR
                                              (LETT |u|
                                               (SPADCALL
                                                (PROG2
                                                 (LETT #1# |u| . #4#)
                                                 (QCDR #1#)
                                                  (|check-union|
                                                   (QEQCAR #1# 0)
                                                   (|List|
                                                    (|Pattern|
                                                     (QREFELT $ 6)))
                                                   #1#))
                                                (QREFELT $ 39)) . #4#)
                                              0)
                                             (COND
                                               ((SPADCALL
                                                 (LETT |l|
                                                  (SPADCALL
                                                   (|SPADfirst|
                                                    (PROG2
                                                     (LETT #1#
                                                      |u| . #4#)
                                                     (QCDR #1#)
                                                      (|check-union|
                                                       (QEQCAR #1# 0)
                                                       (|List|
                                                        (|Pattern|
                                                         (QREFELT $ 6)))
                                                       #1#)))
                                                   (|spadConstant| $
                                                    46)
                                                   |l| (QREFELT $ 20)) . #4#)
                                                 (QREFELT $ 40))
                                                (SPADCALL
                                                 (QREFELT $ 41)))
                                               ('T
                                                (SPADCALL |x|
                                                 (SPADCALL
                                                  (PROG2
                                                   (LETT #1# |u| . #4#)
                                                   (QCDR #1#)
                                                    (|check-union|
                                                     (QEQCAR #1# 0)
                                                     (|List|
                                                      (|Pattern|
                                                       (QREFELT $ 6)))
                                                     #1#))
                                                  (QREFELT $ 42))
                                                 |l| |vmatch|
                                                 (QREFELT $ 16)))))
                                            ('T
                                             (SPADCALL (QREFELT $ 41)))))
                                         ((QEQCAR
                                           (LETT |uu|
                                            (SPADCALL |p|
                                             (QREFELT $ 49)) . #4#)
                                           0)
                                          (SEQ
                                           (LETT |uur|
                                            (PROG2
                                             (LETT #2# |uu| . #4#)
                                             (QCDR #2#)
                                              (|check-union|
                                               (QEQCAR #2# 0)
                                               (|Record|
                                                (|:| |val|
                                                 (|Pattern|
                                                  (QREFELT $ 6)))
                                                (|:| |exponent|
                                                 (|Pattern|
                                                  (QREFELT $ 6))))
                                               #2#)) . #4#)
                                           (LETT |ex|
                                            (SPADCALL |x|
                                             (QREFELT $ 52)) . #4#)
                                           (EXIT
                                            (COND
                                              ((QEQCAR |ex| 0)
                                               (COND
                                                 ((SPADCALL
                                                   (LETT |l|
                                                    (SPADCALL
                                                     (SPADCALL
                                                      (QCDR
                                                       (QCDR |ex|))
                                                      (QREFELT $ 54))
                                                     (QCDR |uur|) |l|
                                                     |vmatch|
                                                     (QREFELT $ 16)) . #4#)
                                                   (QREFELT $ 40))
                                                  (SPADCALL
                                                   (QREFELT $ 41)))
                                                 ('T
                                                  (SPADCALL
                                                   (QCAR (QCDR |ex|))
                                                   (QCAR |uur|) |l|
                                                   |vmatch|))))
                                              ((SPADCALL (QCDR |uur|)
                                                (QREFELT $ 55))
                                               (COND
                                                 ((SPADCALL
                                                   (LETT |l|
                                                    (SPADCALL
                                                     (QCDR |uur|)
                                                     (|spadConstant| $
                                                      46)
                                                     |l|
                                                     (QREFELT $ 20)) . #4#)
                                                   (QREFELT $ 40))
                                                  (SPADCALL
                                                   (QREFELT $ 41)))
                                                 ('T
                                                  (SPADCALL |x|
                                                   (QCAR |uur|) |l|
                                                   |vmatch|
                                                   (QREFELT $ 16)))))
                                              ('T
                                               (SPADCALL
                                                (QREFELT $ 41)))))))
                                         ('T
                                          (SEQ
                                           (EXIT
                                            (SEQ
                                             (SEQ
                                              (LETT |ep|
                                               (SPADCALL |p|
                                                (QREFELT $ 58)) . #4#)
                                              (EXIT
                                               (COND
                                                 ((QEQCAR |ep| 0)
                                                  (SEQ
                                                   (LETT |ex|
                                                    (SPADCALL |x|
                                                     (QREFELT $ 52)) . #4#)
                                                   (EXIT
                                                    (COND
                                                      ((QEQCAR |ex| 0)
                                                       (COND
                                                         ((EQL
                                                           (QCDR
                                                            (QCDR |ex|))
                                                           (QCDR
                                                            (QCDR |ep|)))
                                                          (PROGN
                                                            (LETT #3#
                                                             (SPADCALL
                                                              (QCAR
                                                               (QCDR
                                                                |ex|))
                                                              (QCAR
                                                               (QCDR
                                                                |ep|))
                                                              |l|
                                                              |vmatch|) . #4#)
                                                            (GO #3#))))))))))))
                                             (EXIT
                                              (SPADCALL (QREFELT $ 41)))))
                                           #3# (EXIT #3#)))))))))))))))) 

(DEFUN |PMPLCAT;patternMatch;PPPmrMPmr;2!2| (|#1| |#2| |#3| $$)
  (SPADCALL |#1| |#2| |#3| (QREFELT $$ 1) (QREFELT (QREFELT $$ 0) 16))) 

(DEFUN |PMPLCAT;patternMatch;PPPmrMPmr;2!1| (|#1| |#2| |#3| $$)
  (SPADCALL |#1| |#2| |#3| (QREFELT $$ 1) (QREFELT (QREFELT $$ 0) 16))) 

(DEFUN |PMPLCAT;patternMatch;PPPmrMPmr;2!0| (|#1| $)
  (PROG (#0=#:G1815 #1=#:G1857 #2=#:G1856 #3=#:G1854 #4=#:G1855)
    (RETURN
      (SEQ (PROGN
             (LETT #4# NIL NIL)
             (SEQ (LETT #0# NIL NIL) (LETT #1# |#1| NIL) G190
                  (COND
                    ((OR (ATOM #1#)
                         (PROGN (LETT #0# (CAR #1#) NIL) NIL))
                     (GO G191)))
                  (SEQ (EXIT (PROGN
                               (LETT #2# #0# NIL)
                               (COND
                                 (#4# (LETT #3#
                                       (SPADCALL #3# #2#
                                        (QREFELT $ 30))
                                       NIL))
                                 ('T
                                  (PROGN
                                    (LETT #3# #2# NIL)
                                    (LETT #4# 'T NIL)))))))
                  (LETT #1# (CDR #1#) NIL) (GO G190) G191 (EXIT NIL))
             (COND (#4# #3#) ('T (|spadConstant| $ 31)))))))) 

(DEFUN |PatternMatchPolynomialCategory| (&REST #0=#:G1905)
  (PROG ()
    (RETURN
      (PROG (#1=#:G1906)
        (RETURN
          (COND
            ((LETT #1#
                   (|lassocShiftWithFunction| (|devaluateList| #0#)
                       (HGET |$ConstructorCache|
                             '|PatternMatchPolynomialCategory|)
                       '|domainEqualList|)
                   . #2=(|PatternMatchPolynomialCategory|))
             (|CDRwithIncrement| #1#))
            ('T
             (UNWIND-PROTECT
               (PROG1 (APPLY (|function|
                                 |PatternMatchPolynomialCategory;|)
                             #0#)
                 (LETT #1# T . #2#))
               (COND
                 ((NOT #1#)
                  (HREM |$ConstructorCache|
                        '|PatternMatchPolynomialCategory|))))))))))) 

(DEFUN |PatternMatchPolynomialCategory;| (|#1| |#2| |#3| |#4| |#5|)
  (PROG (DV$1 DV$2 DV$3 DV$4 DV$5 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|)
              . #0=(|PatternMatchPolynomialCategory|))
        (LETT DV$2 (|devaluate| |#2|) . #0#)
        (LETT DV$3 (|devaluate| |#3|) . #0#)
        (LETT DV$4 (|devaluate| |#4|) . #0#)
        (LETT DV$5 (|devaluate| |#5|) . #0#)
        (LETT |dv$|
              (LIST '|PatternMatchPolynomialCategory| DV$1 DV$2 DV$3
                    DV$4 DV$5) . #0#)
        (LETT $ (GETREFV 59) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3
            (LETT |pv$|
                  (|buildPredVector| 0 0
                      (LIST (|HasCategory| |#3|
                                (LIST '|PatternMatchable|
                                      (|devaluate| |#1|))))) . #0#))
        (|haddProp| |$ConstructorCache|
            '|PatternMatchPolynomialCategory|
            (LIST DV$1 DV$2 DV$3 DV$4 DV$5) (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 7 |#2|)
        (QSETREFV $ 8 |#3|)
        (QSETREFV $ 9 |#4|)
        (QSETREFV $ 10 |#5|)
        (COND
          ((|testBitVector| |pv$| 1)
           (QSETREFV $ 17
               (CONS (|dispatchFunction|
                         |PMPLCAT;patternMatch;PP2Pmr;1|)
                     $))))
        $)))) 

(MAKEPROP '|PatternMatchPolynomialCategory| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|local| |#3|) (|local| |#4|) (|local| |#5|)
             (|PatternMatchResult| 6 10) (|Pattern| 6)
             (|PatternMatchPushDown| 6 8 10) (0 . |patternMatch|)
             (|Mapping| 11 8 12 11) |PMPLCAT;patternMatch;PPPmrMPmr;2|
             (7 . |patternMatch|) (|Boolean|) (14 . |generic?|)
             (19 . |addMatch|) (|Union| 9 '"failed")
             (26 . |retractIfCan|) (|PatternMatchPushDown| 6 9 10)
             (31 . |patternMatch|) (|Union| 8 '"failed")
             (38 . |retractIfCan|) (|Union| 38 '"failed")
             (43 . |isPlus|) (48 . |isPlus|) (53 . +) (59 . |Zero|)
             (|List| 10) (|List| 12) (|Mapping| 10 32)
             (|Mapping| 11 10 12 11) (|PatternMatchTools| 6 9 10)
             (63 . |patternMatch|) (|List| $) (72 . |optpair|)
             (77 . |failed?|) (82 . |failed|) (86 . |second|)
             (91 . |isTimes|) (96 . |isTimes|)
             (101 . |patternMatchTimes|) (109 . |One|)
             (|Record| (|:| |val| $) (|:| |exponent| $))
             (|Union| 47 '"failed") (113 . |isPower|)
             (|Record| (|:| |var| 8)
                 (|:| |exponent| (|NonNegativeInteger|)))
             (|Union| 50 '"failed") (118 . |isExpt|) (|Integer|)
             (123 . |coerce|) (128 . |optional?|)
             (|Record| (|:| |val| $)
                 (|:| |exponent| (|NonNegativeInteger|)))
             (|Union| 56 '"failed") (133 . |isExpt|))
          '#(|patternMatch| 138) 'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 58
                                '(3 13 11 8 12 11 14 3 0 11 10 12 11 17
                                  1 12 18 0 19 3 11 0 12 10 0 20 1 10
                                  21 0 22 3 23 11 9 12 11 24 1 10 25 0
                                  26 1 12 27 0 28 1 10 27 0 29 2 10 0 0
                                  0 30 0 10 0 31 5 36 11 32 33 34 11 35
                                  37 1 12 27 38 39 1 11 18 0 40 0 11 0
                                  41 1 33 12 0 42 1 12 27 0 43 1 10 27
                                  0 44 4 36 11 32 33 11 35 45 0 10 0 46
                                  1 12 48 0 49 1 10 51 0 52 1 10 0 53
                                  54 1 12 18 0 55 1 12 57 0 58 3 1 11
                                  10 12 11 17 4 0 11 10 12 11 15 16)))))
          '|lookupComplete|)) 
