
(/VERSIONCHECK 2) 

(DEFUN |PMTOOLS;negConstant| (|l| $)
  (PROG (|x| #0=#:G1862 |r| #1=#:G1861 #2=#:G1859)
    (RETURN
      (SEQ (EXIT (SEQ (SEQ (EXIT (SEQ (LETT |x| NIL
                                       . #3=(|PMTOOLS;negConstant|))
                                      (LETT #0# |l| . #3#) G190
                                      (COND
                                        ((OR (ATOM #0#)
                                          (PROGN
                                            (LETT |x| (CAR #0#) . #3#)
                                            NIL))
                                         (GO G191)))
                                      (SEQ
                                       (LETT |r|
                                        (SPADCALL |x| (QREFELT $ 15)) . #3#)
                                       (EXIT
                                        (COND
                                          ((QEQCAR |r| 0)
                                           (COND
                                             ((SPADCALL (QCDR |r|)
                                               (|spadConstant| $ 16)
                                               (QREFELT $ 19))
                                              (PROGN
                                                (LETT #2#
                                                 (PROGN
                                                   (LETT #1#
                                                    (CONS 0 |x|) . #3#)
                                                   (GO #1#)) . #3#)
                                                (GO #2#))))))))
                                      (LETT #0# (CDR #0#) . #3#)
                                      (GO G190) G191 (EXIT NIL)))
                           #2# (EXIT #2#))
                      (EXIT (CONS 1 "failed"))))
           #1# (EXIT #1#))))) 

(DEFUN |PMTOOLS;tryToMatch| (|lp| |rc| |ident| |pmatch| $)
  (PROG (|p| #0=#:G1871 |rec| |l| #1=#:G1870 |ls|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |rec|
                            (CONS (LETT |l| (QCAR |rc|)
                                        . #2=(|PMTOOLS;tryToMatch|))
                                  (LETT |ls| (QCDR |rc|) . #2#)) . #2#)
                      (SEQ (LETT |p| NIL . #2#) (LETT #0# |lp| . #2#)
                           G190
                           (COND
                             ((OR (ATOM #0#)
                                  (PROGN
                                    (LETT |p| (CAR #0#) . #2#)
                                    NIL))
                              (GO G191)))
                           (SEQ (LETT |rec|
                                      (|PMTOOLS;findMatch| |p| |ls| |l|
                                       |ident| |pmatch| $) . #2#)
                                (EXIT (COND
                                        ((SPADCALL
                                          (LETT |l| (QCAR |rec|) . #2#)
                                          (QREFELT $ 21))
                                         (PROGN
                                           (LETT #1#
                                            (CONS 1 "failed") . #2#)
                                           (GO #1#)))
                                        ('T
                                         (LETT |ls| (QCDR |rec|) . #2#)))))
                           (LETT #0# (CDR #0#) . #2#) (GO G190) G191
                           (EXIT NIL))
                      (EXIT (CONS 0 |rec|))))
           #1# (EXIT #1#))))) 

(DEFUN |PMTOOLS;patternMatchTimes;LLPmrMPmr;3|
       (|ls| |lp| |l| |pmatch| $)
  (PROG (|u|)
    (RETURN
      (SEQ (COND
             ((SPADCALL (QREFELT $ 13) |lp| (QREFELT $ 23))
              (SEQ (LETT |u| (|PMTOOLS;negConstant| |ls| $)
                         . #0=(|PMTOOLS;patternMatchTimes;LLPmrMPmr;3|))
                   (EXIT (COND
                           ((QEQCAR |u| 1) (SPADCALL (QREFELT $ 24)))
                           ('T
                            (SEQ (COND
                                   ((NULL
                                     (SPADCALL (QCDR |u|)
                                      (SPADCALL (|spadConstant| $ 9)
                                       (QREFELT $ 10))
                                      (QREFELT $ 25)))
                                    (LETT |ls|
                                     (CONS
                                      (SPADCALL (QCDR |u|)
                                       (QREFELT $ 10))
                                      |ls|) . #0#)))
                                 (EXIT (SPADCALL
                                        (SPADCALL (QCDR |u|) |ls|
                                         (QREFELT $ 27))
                                        (SPADCALL (QREFELT $ 13) |lp|
                                         (QREFELT $ 28))
                                        (CONS
                                         #'|PMTOOLS;patternMatchTimes;LLPmrMPmr;3!0|
                                         $)
                                        |l| |pmatch| (QREFELT $ 32)))))))))
             ('T
              (SPADCALL |ls| |lp|
                  (CONS #'|PMTOOLS;patternMatchTimes;LLPmrMPmr;3!1| $)
                  |l| |pmatch| (QREFELT $ 32)))))))) 

(DEFUN |PMTOOLS;patternMatchTimes;LLPmrMPmr;3!1| (|#1| $)
  (PROG (#0=#:G1816 #1=#:G1887 #2=#:G1886 #3=#:G1884 #4=#:G1885)
    (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 $ 29))
                                       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| $ 9)))))))) 

(DEFUN |PMTOOLS;patternMatchTimes;LLPmrMPmr;3!0| (|#1| $)
  (PROG (#0=#:G1815 #1=#:G1879 #2=#:G1878 #3=#:G1876 #4=#:G1877)
    (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 $ 29))
                                       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| $ 9)))))))) 

(DEFUN |PMTOOLS;findMatch| (|p| |ls| |l| |ident| |pmatch| $)
  (PROG (|bad| #0=#:G1899 |x| #1=#:G1900 |t| |l1|)
    (RETURN
      (SEQ (LETT |bad|
                 (COND
                   ((SPADCALL |p| (QREFELT $ 34))
                    (SPADCALL (SPADCALL |p| (QREFELT $ 36)) |ls|
                        (QREFELT $ 37)))
                   ('T NIL))
                 . #2=(|PMTOOLS;findMatch|))
           (LETT |l1| (SPADCALL (QREFELT $ 24)) . #2#)
           (SEQ (LETT |x| NIL . #2#)
                (LETT #0# (SPADCALL |ls| |bad| (QREFELT $ 38)) . #2#)
                G190
                (COND
                  ((OR (ATOM #0#)
                       (PROGN (LETT |x| (CAR #0#) . #2#) NIL)
                       (NULL (SEQ (LETT |t| |x| . #2#)
                                  (EXIT (SPADCALL
                                         (LETT |l1|
                                          (SPADCALL |x| |p| |l|
                                           |pmatch|) . #2#)
                                         (QREFELT $ 21))))))
                   #3=(GO G191)))
                (SEQ (EXIT (|spadConstant| $ 16)))
                (LETT #0# (CDR #0#) . #2#) #4=(GO G190) G191
                (EXIT NIL))
           (EXIT (COND
                   ((SPADCALL |l1| (QREFELT $ 21))
                    (SEQ (SEQ (LETT |x| NIL . #2#)
                              (LETT #1# |bad| . #2#) G190
                              (COND
                                ((OR (ATOM #1#)
                                     (PROGN
                                       (LETT |x| (CAR #1#) . #2#)
                                       NIL)
                                     (NULL
                                      (SEQ (LETT |t| |x| . #2#)
                                       (EXIT
                                        (SPADCALL
                                         (LETT |l1|
                                          (SPADCALL |x| |p| |l|
                                           |pmatch|) . #2#)
                                         (QREFELT $ 21))))))
                                 #3#))
                              (SEQ (EXIT (|spadConstant| $ 16)))
                              (LETT #1# (CDR #1#) . #2#) #4# G191
                              (EXIT NIL))
                         (EXIT (COND
                                 ((SPADCALL |l1| (QREFELT $ 21))
                                  (CONS (SPADCALL |p| |ident| |l|
                                         |ident| (QREFELT $ 39))
                                        |ls|))
                                 ('T
                                  (CONS |l1|
                                        (SPADCALL |t| |ls|
                                         (QREFELT $ 27))))))))
                   ('T (CONS |l1| (SPADCALL |t| |ls| (QREFELT $ 27)))))))))) 

(DEFUN |PMTOOLS;preprocessList| (|pattern| |ls| |l| $)
  (PROG (|u|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |pattern| (QREFELT $ 34))
              (SEQ (LETT |u| (SPADCALL |pattern| |l| (QREFELT $ 41))
                         |PMTOOLS;preprocessList|)
                   (EXIT (COND
                           ((QEQCAR |u| 0)
                            (COND
                              ((SPADCALL (QCDR |u|) |ls|
                                   (QREFELT $ 42))
                               (CONS 0 (LIST (QCDR |u|))))
                              ('T (CONS 1 "failed"))))
                           ('T (CONS 0 NIL))))))
             ('T (CONS 0 NIL))))))) 

(DEFUN |PMTOOLS;filterMatchedPatterns| (|lp| |ls| |l| $)
  (PROG (|p| #0=#:G1927 |rc| #1=#:G1926)
    (RETURN
      (SEQ (EXIT (SEQ (SEQ (LETT |p| NIL
                                 . #2=(|PMTOOLS;filterMatchedPatterns|))
                           (LETT #0# |lp| . #2#) G190
                           (COND
                             ((OR (ATOM #0#)
                                  (PROGN
                                    (LETT |p| (CAR #0#) . #2#)
                                    NIL))
                              (GO G191)))
                           (SEQ (LETT |rc|
                                      (|PMTOOLS;preprocessList| |p|
                                       |ls| |l| $) . #2#)
                                (EXIT (COND
                                        ((QEQCAR |rc| 1)
                                         (PROGN
                                           (LETT #1#
                                            (CONS 1 "failed") . #2#)
                                           (GO #1#)))
                                        ((NULL (NULL (QCDR |rc|)))
                                         (SEQ
                                          (LETT |lp|
                                           (SPADCALL |p| |lp|
                                            (QREFELT $ 28)) . #2#)
                                          (EXIT
                                           (LETT |ls|
                                            (SPADCALL
                                             (|SPADfirst| (QCDR |rc|))
                                             |ls| (QREFELT $ 27)) . #2#)))))))
                           (LETT #0# (CDR #0#) . #2#) (GO G190) G191
                           (EXIT NIL))
                      (EXIT (CONS 0 (CONS |lp| |ls|)))))
           #1# (EXIT #1#))))) 

(DEFUN |PMTOOLS;selBestGen| (|l| $)
  (PROG (|p| #0=#:G1932 |ans| #1=#:G1931 #2=#:G1928)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |ans| NIL . #3=(|PMTOOLS;selBestGen|))
                      (SEQ (LETT |p| NIL . #3#) (LETT #0# |l| . #3#)
                           G190
                           (COND
                             ((OR (ATOM #0#)
                                  (PROGN
                                    (LETT |p| (CAR #0#) . #3#)
                                    NIL))
                              (GO G191)))
                           (SEQ (EXIT (COND
                                        ((SPADCALL |p| (QREFELT $ 34))
                                         (SEQ
                                          (EXIT
                                           (SEQ
                                            (LETT |ans|
                                             (LIST |p|) . #3#)
                                            (EXIT
                                             (COND
                                               ((NULL
                                                 (SPADCALL |p|
                                                  (QREFELT $ 43)))
                                                (PROGN
                                                  (LETT #2#
                                                   (PROGN
                                                     (LETT #1#
                                                      |ans| . #3#)
                                                     (GO #1#)) . #3#)
                                                  (GO #2#)))))))
                                          #2# (EXIT #2#))))))
                           (LETT #0# (CDR #0#) . #3#) (GO G190) G191
                           (EXIT NIL))
                      (EXIT |ans|)))
           #1# (EXIT #1#))))) 

(DEFUN |PMTOOLS;patternMatch;LLMPmrMPmr;8|
       (|ls| |lp| |op| |l| |pmatch| $)
  (PROG (|ident| #0=#:G1970 |lpm| |l1| |l2| |l3| |l4| |rc| |u| |rec|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |ident| (SPADCALL NIL |op|)
                            . #1=(|PMTOOLS;patternMatch;LLMPmrMPmr;8|))
                      (LETT |rc|
                            (|PMTOOLS;filterMatchedPatterns| |lp| |ls|
                                |l| $) . #1#)
                      (EXIT (COND
                              ((QEQCAR |rc| 1)
                               (PROGN
                                 (LETT #0#
                                       (SPADCALL (QREFELT $ 24)) . #1#)
                                 (GO #0#)))
                              ('T
                               (SEQ (LETT |lp|
                                     (QCAR (QCDR |rc|)) . #1#)
                                    (LETT |ls|
                                     (QCDR (QCDR |rc|)) . #1#)
                                    (EXIT
                                     (COND
                                       ((NULL |lp|) |l|)
                                       ((< 1
                                         (LENGTH
                                          (LETT |lpm|
                                           (SPADCALL (ELT $ 45) |lp|
                                            (QREFELT $ 47)) . #1#)))
                                        (|error|
                                         "More than one optional pattern in sum/product"))
                                       ((<
                                         (+ (LENGTH |ls|)
                                          (LENGTH |lpm|))
                                         (LENGTH |lp|))
                                        (SPADCALL (QREFELT $ 24)))
                                       ('T
                                        (SEQ
                                         (COND
                                           ((NULL (NULL |lpm|))
                                            (COND
                                              ((EQL (+ (LENGTH |ls|) 1)
                                                (LENGTH |lp|))
                                               (SEQ
                                                (LETT |lp|
                                                 (SPADCALL
                                                  (|SPADfirst| |lpm|)
                                                  |lp| (QREFELT $ 28)) . #1#)
                                                (EXIT
                                                 (COND
                                                   ((SPADCALL
                                                     (LETT |l|
                                                      (SPADCALL
                                                       (|SPADfirst|
                                                        |lpm|)
                                                       |ident| |l|
                                                       (QREFELT $ 49)) . #1#)
                                                     (QREFELT $ 21))
                                                    (PROGN
                                                      (LETT #0#
                                                       |l| . #1#)
                                                      (GO #0#))))))))))
                                         (EXIT
                                          (COND
                                            ((< 1
                                              (LENGTH
                                               (LETT |lpm|
                                                (SPADCALL (ELT $ 50)
                                                 |lp| (QREFELT $ 47)) . #1#)))
                                             (|error|
                                              "More than one expandable pattern in sum/product"))
                                            ('T
                                             (SEQ
                                              (COND
                                                ((< (LENGTH |lp|)
                                                  (LENGTH |ls|))
                                                 (COND
                                                   ((NULL |lpm|)
                                                    (COND
                                                      ((NULL
                                                        (LETT |lpm|
                                                         (|PMTOOLS;selBestGen|
                                                          |lp| $) . #1#))
                                                       (EXIT
                                                        (SPADCALL
                                                         (QREFELT $ 24)))))))))
                                              (COND
                                                ((NULL (NULL |lpm|))
                                                 (LETT |lp|
                                                  (SPADCALL
                                                   (|SPADfirst| |lpm|)
                                                   |lp| (QREFELT $ 28)) . #1#)))
                                              (LETT |l1|
                                               (SPADCALL (ELT $ 51)
                                                |lp| (QREFELT $ 47)) . #1#)
                                              (LETT |l2|
                                               (SPADCALL
                                                (CONS
                                                 #'|PMTOOLS;patternMatch;LLMPmrMPmr;8!0|
                                                 $)
                                                |lp| (QREFELT $ 47)) . #1#)
                                              (LETT |l3|
                                               (SPADCALL
                                                (CONS
                                                 #'|PMTOOLS;patternMatch;LLMPmrMPmr;8!1|
                                                 $)
                                                (SPADCALL
                                                 (CONS
                                                  #'|PMTOOLS;patternMatch;LLMPmrMPmr;8!2|
                                                  $)
                                                 |lp| (QREFELT $ 47))
                                                (QREFELT $ 58)) . #1#)
                                              (LETT |l4|
                                               (SPADCALL
                                                (CONS
                                                 #'|PMTOOLS;patternMatch;LLMPmrMPmr;8!3|
                                                 $)
                                                |lp| (QREFELT $ 47)) . #1#)
                                              (LETT |rec|
                                               (CONS |l| |ls|) . #1#)
                                              (LETT |u|
                                               (|PMTOOLS;tryToMatch|
                                                |l1| |rec| |ident|
                                                |pmatch| $) . #1#)
                                              (EXIT
                                               (COND
                                                 ((QEQCAR |u| 1)
                                                  (SPADCALL
                                                   (QREFELT $ 24)))
                                                 ('T
                                                  (SEQ
                                                   (LETT |u|
                                                    (|PMTOOLS;tryToMatch|
                                                     |l2| (QCDR |u|)
                                                     |ident| |pmatch|
                                                     $) . #1#)
                                                   (EXIT
                                                    (COND
                                                      ((QEQCAR |u| 1)
                                                       (SPADCALL
                                                        (QREFELT $ 24)))
                                                      ('T
                                                       (SEQ
                                                        (LETT |u|
                                                         (|PMTOOLS;tryToMatch|
                                                          |l3|
                                                          (QCDR |u|)
                                                          |ident|
                                                          |pmatch| $) . #1#)
                                                        (EXIT
                                                         (COND
                                                           ((QEQCAR |u|
                                                             1)
                                                            (SPADCALL
                                                             (QREFELT $
                                                              24)))
                                                           ('T
                                                            (SEQ
                                                             (LETT
                                                              |rec|
                                                              (QCDR
                                                               |u|) . #1#)
                                                             (LETT |rc|
                                                              (|PMTOOLS;filterMatchedPatterns|
                                                               |l4|
                                                               (QCDR
                                                                |rec|)
                                                               (QCAR
                                                                |rec|)
                                                               $) . #1#)
                                                             (EXIT
                                                              (COND
                                                                ((QEQCAR
                                                                  |rc|
                                                                  1)
                                                                 (SPADCALL
                                                                  (QREFELT
                                                                   $
                                                                   24)))
                                                                ('T
                                                                 (SEQ
                                                                  (LETT
                                                                   |rec|
                                                                   (CONS
                                                                    (QCAR
                                                                     |rec|)
                                                                    (QCDR
                                                                     (QCDR
                                                                      |rc|))) . #1#)
                                                                  (LETT
                                                                   |u|
                                                                   (|PMTOOLS;tryToMatch|
                                                                    (QCAR
                                                                     (QCDR
                                                                      |rc|))
                                                                    |rec|
                                                                    |ident|
                                                                    |pmatch|
                                                                    $) . #1#)
                                                                  (EXIT
                                                                   (COND
                                                                     ((QEQCAR
                                                                       |u|
                                                                       1)
                                                                      (SPADCALL
                                                                       (QREFELT
                                                                        $
                                                                        24)))
                                                                     ('T
                                                                      (SEQ
                                                                       (LETT
                                                                        |rec|
                                                                        (QCDR
                                                                         |u|) . #1#)
                                                                       (LETT
                                                                        |l|
                                                                        (QCAR
                                                                         |rec|) . #1#)
                                                                       (LETT
                                                                        |ls|
                                                                        (QCDR
                                                                         |rec|) . #1#)
                                                                       (EXIT
                                                                        (COND
                                                                          ((NULL
                                                                            |lpm|)
                                                                           (COND
                                                                             ((NULL
                                                                               |ls|)
                                                                              |l|)
                                                                             ('T
                                                                              (SPADCALL
                                                                               (QREFELT
                                                                                $
                                                                                24)))))
                                                                          ('T
                                                                           (SPADCALL
                                                                            (|SPADfirst|
                                                                             |lpm|)
                                                                            (SPADCALL
                                                                             |ls|
                                                                             |op|)
                                                                            |l|
                                                                            (QREFELT
                                                                             $
                                                                             49)))))))))))))))))))))))))))))))))))))))
           #0# (EXIT #0#))))) 

(DEFUN |PMTOOLS;patternMatch;LLMPmrMPmr;8!3| (|#1| $)
  (COND
    ((SPADCALL |#1| (QREFELT $ 34))
     (COND
       ((OR (SPADCALL |#1| (QREFELT $ 43))
            (SPADCALL |#1| (QREFELT $ 51)))
        (|spadConstant| $ 52))
       ('T (|spadConstant| $ 53))))
    ('T (|spadConstant| $ 52)))) 

(DEFUN |PMTOOLS;patternMatch;LLMPmrMPmr;8!2| (|#1| $)
  (COND
    ((OR (SPADCALL |#1| (QREFELT $ 43))
         (OR (SPADCALL |#1| (QREFELT $ 34))
             (SPADCALL |#1| (QREFELT $ 51))))
     (|spadConstant| $ 52))
    ('T (|spadConstant| $ 53)))) 

(DEFUN |PMTOOLS;patternMatch;LLMPmrMPmr;8!1| (|#1| |#2| $)
  (SPADCALL (SPADCALL |#2| (QREFELT $ 55))
      (SPADCALL |#1| (QREFELT $ 55)) (QREFELT $ 56))) 

(DEFUN |PMTOOLS;patternMatch;LLMPmrMPmr;8!0| (|#1| $)
  (COND
    ((SPADCALL |#1| (QREFELT $ 43))
     (COND
       ((SPADCALL |#1| (QREFELT $ 51)) (|spadConstant| $ 52))
       ('T (|spadConstant| $ 53))))
    ('T (|spadConstant| $ 52)))) 

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

(DEFUN |PatternMatchTools;| (|#1| |#2| |#3|)
  (PROG (DV$1 DV$2 DV$3 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|) . #0=(|PatternMatchTools|))
        (LETT DV$2 (|devaluate| |#2|) . #0#)
        (LETT DV$3 (|devaluate| |#3|) . #0#)
        (LETT |dv$| (LIST '|PatternMatchTools| DV$1 DV$2 DV$3) . #0#)
        (LETT $ (GETREFV 59) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
        (|haddProp| |$ConstructorCache| '|PatternMatchTools|
            (LIST DV$1 DV$2 DV$3) (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 7 |#2|)
        (QSETREFV $ 8 |#3|)
        (QSETREFV $ 13
            (SPADCALL (SPADCALL (|spadConstant| $ 9) (QREFELT $ 10))
                (QREFELT $ 12)))
        $)))) 

(MAKEPROP '|PatternMatchTools| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|local| |#3|) (0 . |One|) (4 . -) (|Pattern| 6)
             (9 . |convert|) '|mn1| (|Union| 7 '"failed")
             (14 . |retractIfCan|) (19 . |Zero|) (23 . |Zero|)
             (|Boolean|) (27 . <) (|PatternMatchResult| 6 8)
             (33 . |failed?|) (|List| 11) (38 . |member?|)
             (44 . |failed|) (48 . =) (|List| 8) (54 . |remove|)
             (60 . |remove|) (66 . *) (|Mapping| 8 26)
             (|Mapping| 20 8 11 20) |PMTOOLS;patternMatch;LLMPmrMPmr;8|
             |PMTOOLS;patternMatchTimes;LLPmrMPmr;3| (72 . |generic?|)
             (|PatternFunctions1| 6 8) (77 . |badValues|)
             (82 . |setIntersection|) (88 . |setDifference|)
             (94 . |addMatchRestricted|) (|Union| 8 '"failed")
             (102 . |getMatch|) (108 . |member?|)
             (114 . |hasPredicate?|) (119 . |One|) (123 . |optional?|)
             (|Mapping| 18 11) (128 . |select|) (134 . |One|)
             (138 . |addMatch|) (145 . |multiple?|) (150 . |constant?|)
             (155 . |false|) (159 . |true|) (|NonNegativeInteger|)
             (163 . |depth|) (168 . <) (|Mapping| 18 11 11)
             (174 . |sort!|))
          '#(|patternMatchTimes| 180 |patternMatch| 188) 'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 58
                                '(0 8 0 9 1 8 0 0 10 1 8 11 0 12 1 8 14
                                  0 15 0 7 0 16 0 8 0 17 2 7 18 0 0 19
                                  1 20 18 0 21 2 22 18 11 0 23 0 20 0
                                  24 2 8 18 0 0 25 2 26 0 8 0 27 2 22 0
                                  11 0 28 2 8 0 0 0 29 1 11 18 0 34 1
                                  35 26 11 36 2 26 0 0 0 37 2 26 0 0 0
                                  38 4 20 0 11 8 0 8 39 2 20 40 11 0 41
                                  2 26 18 8 0 42 1 11 18 0 43 0 7 0 44
                                  1 11 18 0 45 2 22 0 46 0 47 0 11 0 48
                                  3 20 0 11 8 0 49 1 11 18 0 50 1 11 18
                                  0 51 0 18 0 52 0 18 0 53 1 11 54 0 55
                                  2 54 18 0 0 56 2 22 0 57 0 58 4 0 20
                                  26 22 20 31 33 5 0 20 26 22 30 20 31
                                  32)))))
          '|lookupComplete|)) 
