
(/VERSIONCHECK 2) 

(DEFUN |PATTERN1;st| (|p| |l| $)
  (SPADCALL |p|
      (SPADCALL (SPADCALL |p| (QREFELT $ 10)) |l| (QREFELT $ 11))
      (QREFELT $ 12))) 

(DEFUN |PATTERN1;predicate;PM;2| (|p| $)
  (PROG ()
    (RETURN (CONS #'|PATTERN1;predicate;PM;2!0| (VECTOR $ |p|))))) 

(DEFUN |PATTERN1;predicate;PM;2!0| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |PATTERN1;predicate;PM;2|)
    (RETURN
      (PROGN
        (|PATTERN1;applyAll| (SPADCALL (QREFELT $$ 1) (QREFELT $ 10))
            |#1| $))))) 

(DEFUN |PATTERN1;addBadValue;PDP;3| (|p| |v| $)
  (SPADCALL |p| (SPADCALL |v| (QREFELT $ 17)) (QREFELT $ 18))) 

(DEFUN |PATTERN1;badValues;PL;4| (|p| $)
  (PROG (#0=#:G1823 |v| #1=#:G1824)
    (RETURN
      (SEQ (PROGN
             (LETT #0# NIL . #2=(|PATTERN1;badValues;PL;4|))
             (SEQ (LETT |v| NIL . #2#)
                  (LETT #1# (SPADCALL |p| (QREFELT $ 20)) . #2#) G190
                  (COND
                    ((OR (ATOM #1#)
                         (PROGN (LETT |v| (CAR #1#) . #2#) NIL))
                     (GO G191)))
                  (SEQ (EXIT (LETT #0#
                                   (CONS (SPADCALL |v| (QREFELT $ 21))
                                    #0#) . #2#)))
                  (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                  (EXIT (NREVERSE0 #0#)))))))) 

(DEFUN |PATTERN1;suchThat;PLMP;5| (|p| |l| |f| $)
  (SPADCALL (SPADCALL |p| (QREFELT $ 24)) |l|
      (SPADCALL |f| (QREFELT $ 27)) (QREFELT $ 29))) 

(DEFUN |PATTERN1;suchThat;PMP;6| (|p| |f| $)
  (|PATTERN1;st| |p| (LIST (SPADCALL |f| (QREFELT $ 32))) $)) 

(DEFUN |PATTERN1;satisfy?;DPB;7| (|d| |p| $)
  (|PATTERN1;applyAll| (SPADCALL |p| (QREFELT $ 10)) |d| $)) 

(DEFUN |PATTERN1;satisfy?;LPB;8| (|l| |p| $)
  (PROG (|rec|)
    (RETURN
      (COND
        ((NULL (QCAR (LETT |rec| (SPADCALL |p| (QREFELT $ 37))
                           |PATTERN1;satisfy?;LPB;8|)))
         'T)
        ('T (SPADCALL |l| (SPADCALL (QCDR |rec|) (QREFELT $ 38)))))))) 

(DEFUN |PATTERN1;applyAll| (|l| |d| $)
  (PROG (|f| #0=#:G1839 #1=#:G1838 #2=#:G1836)
    (RETURN
      (SEQ (EXIT (SEQ (SEQ (EXIT (SEQ (LETT |f| NIL
                                       . #3=(|PATTERN1;applyAll|))
                                      (LETT #0# |l| . #3#) G190
                                      (COND
                                        ((OR (ATOM #0#)
                                          (PROGN
                                            (LETT |f| (CAR #0#) . #3#)
                                            NIL))
                                         (GO G191)))
                                      (SEQ
                                       (EXIT
                                        (COND
                                          ((NULL
                                            (SPADCALL |d|
                                             (SPADCALL |f|
                                              (QREFELT $ 40))))
                                           (PROGN
                                             (LETT #2#
                                              (PROGN
                                                (LETT #1# 'NIL . #3#)
                                                (GO #1#)) . #3#)
                                             (GO #2#))))))
                                      (LETT #0# (CDR #0#) . #3#)
                                      (GO G190) G191 (EXIT NIL)))
                           #2# (EXIT #2#))
                      (EXIT 'T)))
           #1# (EXIT #1#))))) 

(DEFUN |PATTERN1;suchThat;PLP;10| (|p| |l| $)
  (PROG (#0=#:G1843 |f| #1=#:G1844)
    (RETURN
      (SEQ (|PATTERN1;st| |p|
               (PROGN
                 (LETT #0# NIL . #2=(|PATTERN1;suchThat;PLP;10|))
                 (SEQ (LETT |f| NIL . #2#) (LETT #1# |l| . #2#) G190
                      (COND
                        ((OR (ATOM #1#)
                             (PROGN (LETT |f| (CAR #1#) . #2#) NIL))
                         (GO G191)))
                      (SEQ (EXIT (LETT #0#
                                       (CONS
                                        (SPADCALL |f| (QREFELT $ 32))
                                        #0#) . #2#)))
                      (LETT #1# (CDR #1#) . #2#) (GO G190) G191
                      (EXIT (NREVERSE0 #0#))))
               $))))) 

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

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

(MAKEPROP '|PatternFunctions1| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|local| |#2|)
             (|List| 15) (|Pattern| 6) (0 . |predicates|)
             (5 . |concat|) (11 . |withPredicates|) (|Mapping| 34 7)
             |PATTERN1;predicate;PM;2| (|Any|) (|AnyFunctions1| 7)
             (17 . |coerce|) (22 . |addBadValue|)
             |PATTERN1;addBadValue;PDP;3| (28 . |getBadValues|)
             (33 . |retract|) (|List| 7) |PATTERN1;badValues;PL;4|
             (38 . |copy|) (|Mapping| 34 22) (|AnyFunctions1| 25)
             (43 . |coerce|) (|List| (|Symbol|))
             (48 . |setTopPredicate|) |PATTERN1;suchThat;PLMP;5|
             (|AnyFunctions1| 13) (55 . |coerce|)
             |PATTERN1;suchThat;PMP;6| (|Boolean|)
             |PATTERN1;satisfy?;DPB;7|
             (|Record| (|:| |var| 28) (|:| |pred| 15))
             (60 . |topPredicate|) (65 . |retract|)
             |PATTERN1;satisfy?;LPB;8| (70 . |retract|) (|List| 13)
             |PATTERN1;suchThat;PLP;10|)
          '#(|suchThat| 75 |satisfy?| 94 |predicate| 106 |badValues|
             111 |addBadValue| 116)
          'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 42
                                '(1 9 8 0 10 2 8 0 0 0 11 2 9 0 0 8 12
                                  1 16 15 7 17 2 9 0 0 15 18 1 9 8 0 20
                                  1 16 7 15 21 1 9 0 0 24 1 26 15 25 27
                                  3 9 0 0 28 15 29 1 31 15 13 32 1 9 36
                                  0 37 1 26 25 15 38 1 31 13 15 40 2 0
                                  9 9 41 42 2 0 9 9 13 33 3 0 9 9 28 25
                                  30 2 0 34 22 9 39 2 0 34 7 9 35 1 0
                                  13 9 14 1 0 22 9 23 2 0 9 9 7 19)))))
          '|lookupComplete|)) 
