
(/VERSIONCHECK 2) 

(DEFUN |PMFS;patternMatch;FP2Pmr;1| (|x| |p| |l| $)
  (PROG (|r| |v| |q| #0=#:G1851 |uq| |lx| #1=#:G1861 |u| #2=#:G1858
             |uu| #3=#:G1881 |uur| |ep| |ex| #4=#:G1906)
    (RETURN
      (SEQ (COND
             ((SPADCALL |p| (QREFELT $ 11))
              (SPADCALL |p| |x| |l| (QREFELT $ 13)))
             ('T
              (SEQ (LETT |r| (SPADCALL |x| (QREFELT $ 15))
                         . #5=(|PMFS;patternMatch;FP2Pmr;1|))
                   (EXIT (COND
                           ((QEQCAR |r| 0)
                            (SPADCALL (QCDR |r|) |p| |l|
                                (QREFELT $ 17)))
                           ('T
                            (SEQ (LETT |v|
                                       (SPADCALL |x| (QREFELT $ 19)) . #5#)
                                 (EXIT (COND
                                         ((QEQCAR |v| 0)
                                          (SPADCALL (QCDR |v|) |p| |l|
                                           (QREFELT $ 22)))
                                         ((QEQCAR
                                           (LETT |q|
                                            (SPADCALL |p|
                                             (QREFELT $ 25)) . #5#)
                                           0)
                                          (SEQ
                                           (LETT |uq|
                                            (PROG2 (LETT #0# |q| . #5#)
                                             (QCDR #0#)
                                              (|check-union|
                                               (QEQCAR #0# 0)
                                               (|Record|
                                                (|:| |num|
                                                 (|Pattern|
                                                  (QREFELT $ 6)))
                                                (|:| |den|
                                                 (|Pattern|
                                                  (QREFELT $ 6))))
                                               #0#)) . #5#)
                                           (EXIT
                                            (COND
                                              ((SPADCALL
                                                (LETT |l|
                                                 (SPADCALL
                                                  (SPADCALL
                                                   (SPADCALL |x|
                                                    (QREFELT $ 27))
                                                   (QREFELT $ 28))
                                                  (QCAR |uq|) |l|
                                                  (QREFELT $ 29)) . #5#)
                                                (QREFELT $ 30))
                                               |l|)
                                              ('T
                                               (SPADCALL
                                                (SPADCALL
                                                 (SPADCALL |x|
                                                  (QREFELT $ 31))
                                                 (QREFELT $ 28))
                                                (QCDR |uq|) |l|
                                                (QREFELT $ 29)))))))
                                         ((QEQCAR
                                           (LETT |u|
                                            (SPADCALL |p|
                                             (QREFELT $ 33)) . #5#)
                                           0)
                                          (COND
                                            ((QEQCAR
                                              (LETT |lx|
                                               (SPADCALL |x|
                                                (QREFELT $ 34)) . #5#)
                                              0)
                                             (SPADCALL
                                              (PROG2
                                               (LETT #1# |lx| . #5#)
                                               (QCDR #1#)
                                                (|check-union|
                                                 (QEQCAR #1# 0)
                                                 (|List| (QREFELT $ 8))
                                                 #1#))
                                              (PROG2
                                               (LETT #2# |u| . #5#)
                                               (QCDR #2#)
                                                (|check-union|
                                                 (QEQCAR #2# 0)
                                                 (|List|
                                                  (|Pattern|
                                                   (QREFELT $ 6)))
                                                 #2#))
                                              (CONS
                                               #'|PMFS;patternMatch;FP2Pmr;1!0|
                                               $)
                                              |l| (ELT $ 29)
                                              (QREFELT $ 42)))
                                            ((QEQCAR
                                              (LETT |u|
                                               (SPADCALL
                                                (PROG2
                                                 (LETT #2# |u| . #5#)
                                                 (QCDR #2#)
                                                  (|check-union|
                                                   (QEQCAR #2# 0)
                                                   (|List|
                                                    (|Pattern|
                                                     (QREFELT $ 6)))
                                                   #2#))
                                                (QREFELT $ 44)) . #5#)
                                              0)
                                             (COND
                                               ((SPADCALL
                                                 (LETT |l|
                                                  (SPADCALL
                                                   (|SPADfirst|
                                                    (PROG2
                                                     (LETT #2#
                                                      |u| . #5#)
                                                     (QCDR #2#)
                                                      (|check-union|
                                                       (QEQCAR #2# 0)
                                                       (|List|
                                                        (|Pattern|
                                                         (QREFELT $ 6)))
                                                       #2#)))
                                                   (|spadConstant| $
                                                    36)
                                                   |l| (QREFELT $ 13)) . #5#)
                                                 (QREFELT $ 30))
                                                (SPADCALL
                                                 (QREFELT $ 45)))
                                               ('T
                                                (SPADCALL |x|
                                                 (SPADCALL
                                                  (PROG2
                                                   (LETT #2# |u| . #5#)
                                                   (QCDR #2#)
                                                    (|check-union|
                                                     (QEQCAR #2# 0)
                                                     (|List|
                                                      (|Pattern|
                                                       (QREFELT $ 6)))
                                                     #2#))
                                                  (QREFELT $ 46))
                                                 |l| (QREFELT $ 29)))))
                                            ('T
                                             (SPADCALL (QREFELT $ 45)))))
                                         ((QEQCAR
                                           (LETT |u|
                                            (SPADCALL |p|
                                             (QREFELT $ 47)) . #5#)
                                           0)
                                          (COND
                                            ((QEQCAR
                                              (LETT |lx|
                                               (SPADCALL |x|
                                                (QREFELT $ 48)) . #5#)
                                              0)
                                             (SPADCALL
                                              (PROG2
                                               (LETT #1# |lx| . #5#)
                                               (QCDR #1#)
                                                (|check-union|
                                                 (QEQCAR #1# 0)
                                                 (|List| (QREFELT $ 8))
                                                 #1#))
                                              (PROG2
                                               (LETT #2# |u| . #5#)
                                               (QCDR #2#)
                                                (|check-union|
                                                 (QEQCAR #2# 0)
                                                 (|List|
                                                  (|Pattern|
                                                   (QREFELT $ 6)))
                                                 #2#))
                                              |l| (ELT $ 29)
                                              (QREFELT $ 49)))
                                            ((QEQCAR
                                              (LETT |u|
                                               (SPADCALL
                                                (PROG2
                                                 (LETT #2# |u| . #5#)
                                                 (QCDR #2#)
                                                  (|check-union|
                                                   (QEQCAR #2# 0)
                                                   (|List|
                                                    (|Pattern|
                                                     (QREFELT $ 6)))
                                                   #2#))
                                                (QREFELT $ 44)) . #5#)
                                              0)
                                             (COND
                                               ((SPADCALL
                                                 (LETT |l|
                                                  (SPADCALL
                                                   (|SPADfirst|
                                                    (PROG2
                                                     (LETT #2#
                                                      |u| . #5#)
                                                     (QCDR #2#)
                                                      (|check-union|
                                                       (QEQCAR #2# 0)
                                                       (|List|
                                                        (|Pattern|
                                                         (QREFELT $ 6)))
                                                       #2#)))
                                                   (|spadConstant| $
                                                    50)
                                                   |l| (QREFELT $ 13)) . #5#)
                                                 (QREFELT $ 30))
                                                (SPADCALL
                                                 (QREFELT $ 45)))
                                               ('T
                                                (SPADCALL |x|
                                                 (SPADCALL
                                                  (PROG2
                                                   (LETT #2# |u| . #5#)
                                                   (QCDR #2#)
                                                    (|check-union|
                                                     (QEQCAR #2# 0)
                                                     (|List|
                                                      (|Pattern|
                                                       (QREFELT $ 6)))
                                                     #2#))
                                                  (QREFELT $ 46))
                                                 |l| (QREFELT $ 29)))))
                                            ('T
                                             (SPADCALL (QREFELT $ 45)))))
                                         ((QEQCAR
                                           (LETT |uu|
                                            (SPADCALL |p|
                                             (QREFELT $ 53)) . #5#)
                                           0)
                                          (SEQ
                                           (LETT |uur|
                                            (PROG2
                                             (LETT #3# |uu| . #5#)
                                             (QCDR #3#)
                                              (|check-union|
                                               (QEQCAR #3# 0)
                                               (|Record|
                                                (|:| |val|
                                                 (|Pattern|
                                                  (QREFELT $ 6)))
                                                (|:| |exponent|
                                                 (|Pattern|
                                                  (QREFELT $ 6))))
                                               #3#)) . #5#)
                                           (LETT |ex|
                                            (SPADCALL |x|
                                             (QREFELT $ 56)) . #5#)
                                           (EXIT
                                            (COND
                                              ((QEQCAR |ex| 0)
                                               (COND
                                                 ((SPADCALL
                                                   (LETT |l|
                                                    (SPADCALL
                                                     (SPADCALL
                                                      (QCDR
                                                       (QCDR |ex|))
                                                      (QREFELT $ 58))
                                                     (QCDR |uur|) |l|
                                                     (QREFELT $ 29)) . #5#)
                                                   (QREFELT $ 30))
                                                  (SPADCALL
                                                   (QREFELT $ 45)))
                                                 ('T
                                                  (SPADCALL
                                                   (QCAR (QCDR |ex|))
                                                   (QCAR |uur|) |l|
                                                   (QREFELT $ 22)))))
                                              ((SPADCALL (QCDR |uur|)
                                                (QREFELT $ 59))
                                               (COND
                                                 ((SPADCALL
                                                   (LETT |l|
                                                    (SPADCALL
                                                     (QCDR |uur|)
                                                     (|spadConstant| $
                                                      50)
                                                     |l|
                                                     (QREFELT $ 13)) . #5#)
                                                   (QREFELT $ 30))
                                                  (SPADCALL
                                                   (QREFELT $ 45)))
                                                 ('T
                                                  (SPADCALL |x|
                                                   (QCAR |uur|) |l|
                                                   (QREFELT $ 29)))))
                                              ('T
                                               (SPADCALL
                                                (QREFELT $ 45)))))))
                                         ('T
                                          (SEQ
                                           (EXIT
                                            (SEQ
                                             (SEQ
                                              (LETT |ep|
                                               (SPADCALL |p|
                                                (QREFELT $ 62)) . #5#)
                                              (EXIT
                                               (COND
                                                 ((QEQCAR |ep| 0)
                                                  (SEQ
                                                   (LETT |ex|
                                                    (SPADCALL |x|
                                                     (QREFELT $ 56)) . #5#)
                                                   (EXIT
                                                    (COND
                                                      ((QEQCAR |ex| 0)
                                                       (COND
                                                         ((EQL
                                                           (QCDR
                                                            (QCDR |ex|))
                                                           (QCDR
                                                            (QCDR |ep|)))
                                                          (PROGN
                                                            (LETT #4#
                                                             (SPADCALL
                                                              (QCAR
                                                               (QCDR
                                                                |ex|))
                                                              (QCAR
                                                               (QCDR
                                                                |ep|))
                                                              |l|
                                                              (QREFELT
                                                               $ 22)) . #5#)
                                                            (GO #4#))))))))))))
                                             (EXIT
                                              (SPADCALL (QREFELT $ 45)))))
                                           #4# (EXIT #4#)))))))))))))))) 

(DEFUN |PMFS;patternMatch;FP2Pmr;1!0| (|#1| $)
  (PROG (#0=#:G1815 #1=#:G1866 #2=#:G1865 #3=#:G1863 #4=#:G1864)
    (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 $ 35))
                                       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| $ 36)))))))) 

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

(DEFUN |PatternMatchFunctionSpace;| (|#1| |#2| |#3|)
  (PROG (DV$1 DV$2 DV$3 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|)
              . #0=(|PatternMatchFunctionSpace|))
        (LETT DV$2 (|devaluate| |#2|) . #0#)
        (LETT DV$3 (|devaluate| |#3|) . #0#)
        (LETT |dv$|
              (LIST '|PatternMatchFunctionSpace| DV$1 DV$2 DV$3) . #0#)
        (LETT $ (GETREFV 63) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
        (|haddProp| |$ConstructorCache| '|PatternMatchFunctionSpace|
            (LIST DV$1 DV$2 DV$3) (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 7 |#2|)
        (QSETREFV $ 8 |#3|)
        $)))) 

(MAKEPROP '|PatternMatchFunctionSpace| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|local| |#3|) (|Boolean|) (|Pattern| 6) (0 . |generic?|)
             (|PatternMatchResult| 6 8) (5 . |addMatch|)
             (|Union| 7 '"failed") (12 . |retractIfCan|)
             (|PatternMatchPushDown| 6 7 8) (17 . |patternMatch|)
             (|Union| (|Kernel| $) '"failed") (24 . |retractIfCan|)
             (|Kernel| 8) (|PatternMatchKernel| 6 8)
             (29 . |patternMatch|)
             (|Record| (|:| |num| $) (|:| |den| $))
             (|Union| 23 '"failed") (36 . |isQuotient|)
             (|SparseMultivariatePolynomial| 7 (|Kernel| $))
             (41 . |numer|) (46 . |coerce|)
             |PMFS;patternMatch;FP2Pmr;1| (51 . |failed?|)
             (56 . |denom|) (|Union| 43 '"failed") (61 . |isPlus|)
             (66 . |isPlus|) (71 . +) (77 . |Zero|) (|List| 8)
             (|List| 10) (|Mapping| 8 37) (|Mapping| 12 8 10 12)
             (|PatternMatchTools| 6 7 8) (81 . |patternMatch|)
             (|List| $) (90 . |optpair|) (95 . |failed|)
             (99 . |second|) (104 . |isTimes|) (109 . |isTimes|)
             (114 . |patternMatchTimes|) (122 . |One|)
             (|Record| (|:| |val| $) (|:| |exponent| $))
             (|Union| 51 '"failed") (126 . |isPower|)
             (|Record| (|:| |var| (|Kernel| $)) (|:| |exponent| 57))
             (|Union| 54 '"failed") (131 . |isExpt|) (|Integer|)
             (136 . |coerce|) (141 . |optional?|)
             (|Record| (|:| |val| $)
                 (|:| |exponent| (|NonNegativeInteger|)))
             (|Union| 60 '"failed") (146 . |isExpt|))
          '#(|patternMatch| 151) 'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 62
                                '(1 10 9 0 11 3 12 0 10 8 0 13 1 8 14 0
                                  15 3 16 12 7 10 12 17 1 8 18 0 19 3
                                  21 12 20 10 12 22 1 10 24 0 25 1 8 26
                                  0 27 1 8 0 26 28 1 12 9 0 30 1 8 26 0
                                  31 1 10 32 0 33 1 8 32 0 34 2 8 0 0 0
                                  35 0 8 0 36 5 41 12 37 38 39 12 40 42
                                  1 10 32 43 44 0 12 0 45 1 38 10 0 46
                                  1 10 32 0 47 1 8 32 0 48 4 41 12 37
                                  38 12 40 49 0 8 0 50 1 10 52 0 53 1 8
                                  55 0 56 1 8 0 57 58 1 10 9 0 59 1 10
                                  61 0 62 3 0 12 8 10 12 29)))))
          '|lookupComplete|)) 
