
(/VERSIONCHECK 2) 

(DEFUN |PMINS;patternMatch;IP2Pmr;1| (|x| |p| |l| $)
  (COND ((SPADCALL |p| (QREFELT $ 9)) (SPADCALL |p| |x| |l| (QREFELT $ 11)))
        ('T (|PMINS;patternMatchInner| |x| |p| |l| $)))) 

(DEFUN |PMINS;patternMatchRestricted| (|x| |p| |l| |y| $)
  (COND
   ((SPADCALL |p| (QREFELT $ 9)) (SPADCALL |p| |x| |l| |y| (QREFELT $ 13)))
   ('T (|PMINS;patternMatchInner| |x| |p| |l| $)))) 

(DEFUN |PMINS;patternMatchSumProd| (|x| |lp| |l| |invOp| |ident| $)
  (PROG (|y| |r| |p2| |p1|)
    (RETURN
     (SEQ
      (COND
       ((EQL (LENGTH |lp|) 2)
        (SEQ
         (LETT |p2| (SPADCALL |lp| (QREFELT $ 15))
               . #1=(|PMINS;patternMatchSumProd|))
         (SEQ
          (LETT |r|
                (SPADCALL (LETT |p1| (|SPADfirst| |lp|) . #1#) (QREFELT $ 17))
                . #1#)
          (EXIT
           (COND
            ((QEQCAR |r| 1)
             (SEQ (LETT |p1| |p2| . #1#)
                  (EXIT (LETT |p2| (|SPADfirst| |lp|) . #1#)))))))
         (LETT |r| (SPADCALL |p1| (QREFELT $ 17)) . #1#)
         (EXIT
          (COND ((QEQCAR |r| 1) (SPADCALL (QREFELT $ 18)))
                (#2='T
                 (SEQ
                  (LETT |y|
                        (SPADCALL |x| (SPADCALL (QCDR |r|) (QREFELT $ 20))
                                  |invOp|)
                        . #1#)
                  (EXIT
                   (COND ((QEQCAR |y| 1) (SPADCALL (QREFELT $ 18)))
                         (#2#
                          (|PMINS;patternMatchRestricted| (QCDR |y|) |p2| |l|
                           |ident| $))))))))))
       (#2# (SPADCALL (QREFELT $ 18)))))))) 

(DEFUN |PMINS;patternMatchInner| (|x| |p| |l| $)
  (PROG (|r| #1=#:G1859 |v| |uvr| |uv| |w| |pr| |uur| |uu| |ur| |u|)
    (RETURN
     (SEQ
      (COND
       ((SPADCALL |p| (QREFELT $ 21))
        (SEQ
         (LETT |r| (SPADCALL |p| (QREFELT $ 17))
               . #2=(|PMINS;patternMatchInner|))
         (EXIT
          (COND
           ((QEQCAR |r| 0)
            (COND ((EQL (SPADCALL |x| (QREFELT $ 22)) (QCDR |r|)) |l|)
                  (#3='T (SPADCALL (QREFELT $ 18)))))
           (#3# (SPADCALL (QREFELT $ 18)))))))
       (#3#
        (SEQ (LETT |u| (SPADCALL |p| (QREFELT $ 25)) . #2#)
             (EXIT
              (COND
               ((QEQCAR |u| 0)
                (SEQ (LETT |ur| (QCDR |u|) . #2#)
                     (LETT |v| (SPADCALL |x| (QCDR |ur|) (QREFELT $ 29)) . #2#)
                     (EXIT
                      (COND ((QEQCAR |v| 1) (SPADCALL (QREFELT $ 18)))
                            (#3#
                             (|PMINS;patternMatchRestricted| (QCDR |v|)
                              (QCAR |ur|) |l| (|spadConstant| $ 30) $))))))
               (#3#
                (SEQ (LETT |uu| (SPADCALL |p| (QREFELT $ 33)) . #2#)
                     (EXIT
                      (COND
                       ((QEQCAR |uu| 0)
                        (SEQ (LETT |uur| (QCDR |uu|) . #2#)
                             (LETT |pr| (SPADCALL |x| (QREFELT $ 35)) . #2#)
                             (EXIT
                              (COND
                               ((SPADCALL
                                 (LETT |l|
                                       (|PMINS;patternMatchRestricted|
                                        (SPADCALL (QCDR |pr|) (QREFELT $ 20))
                                        (QCDR |uur|) |l| (|spadConstant| $ 30)
                                        $)
                                       . #2#)
                                 (QREFELT $ 36))
                                (SPADCALL (QREFELT $ 18)))
                               (#3#
                                (|PMINS;patternMatchRestricted| (QCAR |pr|)
                                 (QCAR |uur|) |l| (|spadConstant| $ 30) $))))))
                       (#3#
                        (SEQ (LETT |w| (SPADCALL |p| (QREFELT $ 39)) . #2#)
                             (EXIT
                              (COND
                               ((QEQCAR |w| 0)
                                (|PMINS;patternMatchSumProd| |x| (QCDR |w|) |l|
                                 (ELT $ 41) (|spadConstant| $ 30) $))
                               (#3#
                                (SEQ
                                 (LETT |w| (SPADCALL |p| (QREFELT $ 42)) . #2#)
                                 (EXIT
                                  (COND
                                   ((QEQCAR |w| 0)
                                    (|PMINS;patternMatchSumProd| |x| (QCDR |w|)
                                     |l| (CONS #'|PMINS;patternMatchInner!0| $)
                                     (|spadConstant| $ 44) $))
                                   (#3#
                                    (SEQ
                                     (LETT |uv| (SPADCALL |p| (QREFELT $ 47))
                                           . #2#)
                                     (EXIT
                                      (COND
                                       ((QEQCAR |uv| 0)
                                        (SEQ
                                         (EXIT
                                          (SEQ (LETT |uvr| (QCDR |uv|) . #2#)
                                               (SEQ
                                                (LETT |r|
                                                      (SPADCALL (QCAR |uvr|)
                                                                (QREFELT $ 17))
                                                      . #2#)
                                                (EXIT
                                                 (COND
                                                  ((QEQCAR |r| 0)
                                                   (SEQ
                                                    (LETT |v|
                                                          (SPADCALL
                                                           (SPADCALL (QCDR |r|)
                                                                     (QREFELT $
                                                                              20))
                                                           |x| (QREFELT $ 41))
                                                          . #2#)
                                                    (EXIT
                                                     (COND
                                                      ((QEQCAR |v| 0)
                                                       (PROGN
                                                        (LETT #1#
                                                              (|PMINS;patternMatchRestricted|
                                                               (QCDR |v|)
                                                               (QCDR |uvr|) |l|
                                                               (|spadConstant|
                                                                $ 30)
                                                               $)
                                                              . #2#)
                                                        (GO #1#))))))))))
                                               (LETT |r|
                                                     (SPADCALL (QCDR |uvr|)
                                                               (QREFELT $ 17))
                                                     . #2#)
                                               (EXIT
                                                (COND
                                                 ((QEQCAR |r| 0)
                                                  (SPADCALL
                                                   (SPADCALL (QCDR |r|) |x|
                                                             (QREFELT $ 48))
                                                   (QCAR |uvr|) |l|
                                                   (QREFELT $ 12)))
                                                 (#3#
                                                  (SPADCALL
                                                   (QREFELT $ 18)))))))
                                         #1# (EXIT #1#)))
                                       (#3#
                                        (SPADCALL
                                         (QREFELT $
                                                  18)))))))))))))))))))))))))))) 

(DEFUN |PMINS;patternMatchInner!0| (|i1| |i2| $)
  (CONS 0 (SPADCALL |i1| |i2| (QREFELT $ 43)))) 

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

(DEFUN |PatternMatchIntegerNumberSystem;| (|#1|)
  (PROG (|pv$| $ |dv$| DV$1)
    (RETURN
     (PROGN
      (LETT DV$1 (|devaluate| |#1|) . #1=(|PatternMatchIntegerNumberSystem|))
      (LETT |dv$| (LIST '|PatternMatchIntegerNumberSystem| DV$1) . #1#)
      (LETT $ (GETREFV 49) . #1#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#))
      (|haddProp| |$ConstructorCache| '|PatternMatchIntegerNumberSystem|
                  (LIST DV$1) (CONS 1 $))
      (|stuffDomainSlots| $)
      (QSETREFV $ 6 |#1|)
      (SETF |pv$| (QREFELT $ 3))
      $)))) 

(MAKEPROP '|PatternMatchIntegerNumberSystem| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|Boolean|) (|Pattern| 19)
              (0 . |generic?|) (|PatternMatchResult| 19 6) (5 . |addMatch|)
              |PMINS;patternMatch;IP2Pmr;1| (12 . |addMatchRestricted|)
              (|List| 8) (20 . |last|) (|Union| 19 '"failed")
              (25 . |retractIfCan|) (30 . |failed|) (|Integer|) (34 . |coerce|)
              (39 . |constant?|) (44 . |convert|)
              (|Record| (|:| |val| $) (|:| |exponent| 27))
              (|Union| 23 '"failed") (49 . |isExpt|) (|Union| 6 '"failed")
              (|NonNegativeInteger|) (|IntegerRoots| 6) (54 . |perfectNthRoot|)
              (60 . |One|) (|Record| (|:| |val| $) (|:| |exponent| $))
              (|Union| 31 '"failed") (64 . |isPower|)
              (|Record| (|:| |base| 6) (|:| |exponent| 27))
              (69 . |perfectNthRoot|) (74 . |failed?|) (79 . |base|)
              (|Union| (|List| $) '"failed") (83 . |isTimes|)
              (|Union| $ '"failed") (88 . |exquo|) (94 . |isPlus|) (99 . -)
              (105 . |Zero|) (|Record| (|:| |num| $) (|:| |den| $))
              (|Union| 45 '"failed") (109 . |isQuotient|) (114 . *))
           '#(|patternMatch| 120) 'NIL
           (CONS (|makeByteWordVec2| 1 'NIL)
                 (CONS '#()
                       (CONS '#()
                             (|makeByteWordVec2| 48
                                                 '(1 8 7 0 9 3 10 0 8 6 0 11 4
                                                   10 0 8 6 0 6 13 1 14 8 0 15
                                                   1 8 16 0 17 0 10 0 18 1 6 0
                                                   19 20 1 8 7 0 21 1 6 19 0 22
                                                   1 8 24 0 25 2 28 26 6 27 29
                                                   0 6 0 30 1 8 32 0 33 1 28 34
                                                   6 35 1 10 7 0 36 0 6 0 37 1
                                                   8 38 0 39 2 6 40 0 0 41 1 8
                                                   38 0 42 2 6 0 0 0 43 0 6 0
                                                   44 1 8 46 0 47 2 6 0 19 0 48
                                                   3 0 10 6 8 10 12)))))
           '|lookupComplete|)) 
