
(SDEFUN |BOP1;evaluate;BoMBo;1|
        ((|op| (|BasicOperator|)) (|func| (|Mapping| A A))
         (% (|BasicOperator|)))
        (SPROG NIL
               (SPADCALL |op|
                         (CONS #'|BOP1;evaluate;BoMBo;1!0| (VECTOR |func| %))
                         (QREFELT % 14)))) 

(SDEFUN |BOP1;evaluate;BoMBo;1!0| ((|l1| NIL) ($$ NIL))
        (PROG (% |func|)
          (LETT % (QREFELT $$ 1))
          (LETT |func| (QREFELT $$ 0))
          (RETURN (PROGN (SPADCALL (SPADCALL |l1| (QREFELT % 11)) |func|))))) 

(SDEFUN |BOP1;evaluate;BoU;2|
        ((|op| (|BasicOperator|))
         (% (|Union| (|Mapping| A (|List| A)) "failed")))
        (SPROG ((|func| (|Union| (|None|) "failed")))
               (SEQ (LETT |func| (SPADCALL |op| (QREFELT % 7) (QREFELT % 19)))
                    (EXIT
                     (COND ((QEQCAR |func| 1) (CONS 1 "failed"))
                           ('T (CONS 0 (QCDR |func|)))))))) 

(SDEFUN |BOP1;evaluate;BoLU;3|
        ((|op| (|BasicOperator|)) (|args| (|List| A)) (% (|Union| A "failed")))
        (SPROG ((|func| (|Union| (|None|) "failed")))
               (SEQ (LETT |func| (SPADCALL |op| (QREFELT % 7) (QREFELT % 19)))
                    (EXIT
                     (COND ((QEQCAR |func| 1) (CONS 1 "failed"))
                           ('T (CONS 0 (SPADCALL |args| (QCDR |func|))))))))) 

(SDEFUN |BOP1;evaluate;BoMBo;4|
        ((|op| (|BasicOperator|)) (|func| (|Mapping| A (|List| A)))
         (% (|BasicOperator|)))
        (SPADCALL |op| (QREFELT % 7) |func| (QREFELT % 25))) 

(SDEFUN |BOP1;derivative;BoU;5|
        ((|op| (|BasicOperator|))
         (% (|Union| (|List| (|Mapping| A (|List| A))) "failed")))
        (SPROG ((|func| (|Union| (|None|) "failed")))
               (SEQ (LETT |func| (SPADCALL |op| (QREFELT % 9) (QREFELT % 19)))
                    (EXIT
                     (COND ((QEQCAR |func| 1) (CONS 1 "failed"))
                           ('T (CONS 0 (QCDR |func|)))))))) 

(SDEFUN |BOP1;derivative;BoLBo;6|
        ((|op| (|BasicOperator|)) (|grad| (|List| (|Mapping| A (|List| A))))
         (% (|BasicOperator|)))
        (SPADCALL |op| (QREFELT % 9) |grad| (QREFELT % 25))) 

(SDEFUN |BOP1;derivative;BoMBo;7|
        ((|op| (|BasicOperator|)) (|f| (|Mapping| A A)) (% (|BasicOperator|)))
        (SPROG NIL
               (COND
                ((OR (SPADCALL |op| (QREFELT % 31))
                     (SPADCALL |op| (QREFELT % 32)))
                 (SPADCALL |op|
                           (LIST
                            (CONS #'|BOP1;derivative;BoMBo;7!0|
                                  (VECTOR |f| %)))
                           (QREFELT % 29)))
                ('T (|error| "Operator is not unary"))))) 

(SDEFUN |BOP1;derivative;BoMBo;7!0| ((|l1| NIL) ($$ NIL))
        (PROG (% |f|)
          (LETT % (QREFELT $$ 1))
          (LETT |f| (QREFELT $$ 0))
          (RETURN (PROGN (SPADCALL (SPADCALL |l1| (QREFELT % 11)) |f|))))) 

(PUT '|BOP1;cdisp| '|SPADreplace| '(XLAM (|a| |l|) |a|)) 

(SDEFUN |BOP1;cdisp|
        ((|a| (|OutputForm|)) (|l| (|List| (|OutputForm|))) (% (|OutputForm|)))
        |a|) 

(PUT '|BOP1;csex| '|SPADreplace| '(XLAM (|a| |l|) |a|)) 

(SDEFUN |BOP1;csex|
        ((|a| (|InputForm|)) (|l| (|List| (|InputForm|))) (% (|InputForm|)))
        |a|) 

(SDEFUN |BOP1;eqconst?|
        ((|a| (|BasicOperator|)) (|b| (|BasicOperator|)) (% (|Boolean|)))
        (SPROG ((|vb| #1=(|Union| (|None|) "failed")) (|va| #1#))
               (SEQ (LETT |va| (SPADCALL |a| (QREFELT % 8) (QREFELT % 19)))
                    (EXIT
                     (COND
                      ((QEQCAR |va| 1)
                       (NULL (SPADCALL |b| (QREFELT % 8) (QREFELT % 34))))
                      (#2='T
                       (SEQ
                        (LETT |vb| (SPADCALL |b| (QREFELT % 8) (QREFELT % 19)))
                        (EXIT
                         (COND
                          ((QEQCAR |vb| 0)
                           (SPADCALL (QCDR |va|) (QCDR |vb|) (QREFELT % 35)))
                          (#2# NIL)))))))))) 

(SDEFUN |BOP1;ltconst?|
        ((|a| (|BasicOperator|)) (|b| (|BasicOperator|)) (% (|Boolean|)))
        (SPROG ((|vb| #1=(|Union| (|None|) "failed")) (|va| #1#))
               (SEQ (LETT |va| (SPADCALL |a| (QREFELT % 8) (QREFELT % 19)))
                    (EXIT
                     (COND
                      ((QEQCAR |va| 1)
                       (SPADCALL |b| (QREFELT % 8) (QREFELT % 34)))
                      (#2='T
                       (SEQ
                        (LETT |vb| (SPADCALL |b| (QREFELT % 8) (QREFELT % 19)))
                        (EXIT
                         (COND
                          ((QEQCAR |vb| 0)
                           (SPADCALL (QCDR |va|) (QCDR |vb|) (QREFELT % 36)))
                          (#2# NIL)))))))))) 

(SDEFUN |BOP1;constOp| ((|a| (A)) (% (|BasicOperator|)))
        (SPROG NIL
               (SPADCALL
                (SPADCALL (SPADCALL (QREFELT % 42) (QREFELT % 43))
                          (CONS #'|BOP1;constOp!0| (VECTOR % |a|))
                          (QREFELT % 47))
                (QREFELT % 8) |a| (QREFELT % 25)))) 

(SDEFUN |BOP1;constOp!0| ((|l1| NIL) ($$ NIL))
        (PROG (|a| %)
          (LETT |a| (QREFELT $$ 1))
          (LETT % (QREFELT $$ 0))
          (RETURN (PROGN (|BOP1;cdisp| (SPADCALL |a| (QREFELT % 45)) |l1| %))))) 

(SDEFUN |BOP1;constantOpIfCan;BoU;13|
        ((|op| (|BasicOperator|)) (% (|Union| A "failed")))
        (SPROG ((#1=#:G238 NIL) (|u| (|Union| (|None|) "failed")))
               (SEQ
                (EXIT
                 (SEQ
                  (COND
                   ((SPADCALL |op| '|constant| (QREFELT % 48))
                    (SEQ
                     (LETT |u| (SPADCALL |op| (QREFELT % 8) (QREFELT % 19)))
                     (EXIT
                      (COND
                       ((QEQCAR |u| 0)
                        (PROGN
                         (LETT #1# (CONS 0 (QCDR |u|)))
                         (GO #2=#:G236))))))))
                  (EXIT (CONS 1 "failed"))))
                #2# (EXIT #1#)))) 

(SDEFUN |BOP1;constantOperator;ABo;14| ((|a| (A)) (% (|BasicOperator|)))
        (SPROG NIL
               (SPADCALL (|BOP1;constOp| |a| %)
                         (CONS #'|BOP1;constantOperator;ABo;14!0|
                               (VECTOR % |a|))
                         (QREFELT % 53)))) 

(SDEFUN |BOP1;constantOperator;ABo;14!0| ((|l1| NIL) ($$ NIL))
        (PROG (|a| %)
          (LETT |a| (QREFELT $$ 1))
          (LETT % (QREFELT $$ 0))
          (RETURN (PROGN (|BOP1;csex| (SPADCALL |a| (QREFELT % 51)) |l1| %))))) 

(SDEFUN |BOP1;constantOperator;ABo;15| ((|a| (A)) (% (|BasicOperator|)))
        (|BOP1;constOp| |a| %)) 

(DECLAIM (NOTINLINE |BasicOperatorFunctions1;|)) 

(DEFUN |BasicOperatorFunctions1| (#1=#:G242)
  (SPROG NIL
         (PROG (#2=#:G243)
           (RETURN
            (COND
             ((LETT #2#
                    (|lassocShiftWithFunction| (LIST (|devaluate| #1#))
                                               (HGET |$ConstructorCache|
                                                     '|BasicOperatorFunctions1|)
                                               '|domainEqualList|))
              (|CDRwithIncrement| #2#))
             ('T
              (UNWIND-PROTECT
                  (PROG1 (|BasicOperatorFunctions1;| #1#) (LETT #2# T))
                (COND
                 ((NOT #2#)
                  (HREM |$ConstructorCache| '|BasicOperatorFunctions1|)))))))))) 

(DEFUN |BasicOperatorFunctions1;| (|#1|)
  (SPROG ((|pv$| NIL) (% NIL) (|dv$| NIL) (DV$1 NIL))
         (PROGN
          (LETT DV$1 (|devaluate| |#1|))
          (LETT |dv$| (LIST '|BasicOperatorFunctions1| DV$1))
          (LETT % (GETREFV 55))
          (QSETREFV % 0 |dv$|)
          (QSETREFV % 3 (LETT |pv$| (|buildPredVector| 0 0 NIL)))
          (|haddProp| |$ConstructorCache| '|BasicOperatorFunctions1|
                      (LIST DV$1) (CONS 1 %))
          (|stuffDomainSlots| %)
          (QSETREFV % 6 |#1|)
          (SETF |pv$| (QREFELT % 3))
          (QSETREFV % 7 '|%eval|)
          (QSETREFV % 8 '|%constant|)
          (QSETREFV % 9 '|%diff|)
          (COND
           ((|HasCategory| |#1| '(|Comparable|))
            (PROGN
             (QSETREFV % 42
                       (SPADCALL
                        (SPADCALL (SPADCALL '|constant| 0 (QREFELT % 38))
                                  (CONS (|function| |BOP1;eqconst?|) %)
                                  (QREFELT % 40))
                        (CONS (|function| |BOP1;ltconst?|) %)
                        (QREFELT % 41)))))
           ('T
            (SETELT % 42
                    (SPADCALL (SPADCALL '|constant| 0 (QREFELT % 38))
                              (CONS (|function| |BOP1;eqconst?|) %)
                              (QREFELT % 40)))))
          (COND
           ((|HasCategory| |#1| '(|ConvertibleTo| (|InputForm|)))
            (QSETREFV % 54
                      (CONS (|dispatchFunction| |BOP1;constantOperator;ABo;14|)
                            %)))
           ('T
            (QSETREFV % 54
                      (CONS (|dispatchFunction| |BOP1;constantOperator;ABo;15|)
                            %))))
          %))) 

(MAKEPROP '|BasicOperatorFunctions1| '|infovec|
          (LIST
           '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) 'EVAL 'CONST 'DIFF
              (|List| 6) (0 . |first|) (|BasicOperator|) (|Mapping| 6 10)
              |BOP1;evaluate;BoMBo;4| (|Mapping| 6 6) |BOP1;evaluate;BoMBo;1|
              (|Union| 24 '"failed") (|Symbol|) (5 . |property|)
              (|Union| 13 '#1="failed") |BOP1;evaluate;BoU;2|
              (|Union| 6 '#2="failed") |BOP1;evaluate;BoLU;3| (|None|)
              (11 . |setProperty|) (|Union| 28 '#3="failed")
              |BOP1;derivative;BoU;5| (|List| 13) |BOP1;derivative;BoLBo;6|
              (|Boolean|) (18 . |unary?|) (23 . |nary?|)
              |BOP1;derivative;BoMBo;7| (28 . |has?|) (34 . =)
              (40 . |smaller?|) (|NonNegativeInteger|) (46 . |operator|)
              (|Mapping| 30 % %) (52 . |equality|) (58 . |comparison|)
              '|opconst| (64 . |copy|) (|OutputForm|) (69 . |coerce|)
              (|Mapping| 44 (|List| 44)) (74 . |display|) (80 . |is?|)
              |BOP1;constantOpIfCan;BoU;13| (|InputForm|) (86 . |convert|)
              (|Mapping| 50 (|List| 50)) (91 . |input|)
              (97 . |constantOperator|))
           '#(|evaluate| 102 |derivative| 125 |constantOperator| 142
              |constantOpIfCan| 147)
           'NIL
           (CONS (|makeByteWordVec2| 1 '(0))
                 (CONS '#(NIL)
                       (CONS
                        '#((|Join|
                            (|mkCategory|
                             (LIST
                              '((|evaluate|
                                 ((|Union| |#1| #2#) (|BasicOperator|)
                                  (|List| |#1|)))
                                T)
                              '((|evaluate|
                                 ((|BasicOperator|) (|BasicOperator|)
                                  (|Mapping| |#1| (|List| |#1|))))
                                T)
                              '((|evaluate|
                                 ((|BasicOperator|) (|BasicOperator|)
                                  (|Mapping| |#1| |#1|)))
                                T)
                              '((|evaluate|
                                 ((|Union| (|Mapping| |#1| (|List| |#1|)) #1#)
                                  (|BasicOperator|)))
                                T)
                              '((|derivative|
                                 ((|BasicOperator|) (|BasicOperator|)
                                  (|List| (|Mapping| |#1| (|List| |#1|)))))
                                T)
                              '((|derivative|
                                 ((|BasicOperator|) (|BasicOperator|)
                                  (|Mapping| |#1| |#1|)))
                                T)
                              '((|derivative|
                                 ((|Union|
                                   (|List| (|Mapping| |#1| (|List| |#1|))) #3#)
                                  (|BasicOperator|)))
                                T)
                              '((|constantOperator| ((|BasicOperator|) |#1|))
                                T)
                              '((|constantOpIfCan|
                                 ((|Union| |#1| "failed") (|BasicOperator|)))
                                T))
                             (LIST) NIL NIL)))
                        (|makeByteWordVec2| 54
                                            '(1 10 6 0 11 2 12 17 0 18 19 3 12
                                              0 0 18 24 25 1 12 30 0 31 1 12 30
                                              0 32 2 12 30 0 18 34 2 6 30 0 0
                                              35 2 6 30 0 0 36 2 12 0 18 37 38
                                              2 12 0 0 39 40 2 12 0 0 39 41 1
                                              12 0 0 43 1 6 44 0 45 2 12 0 0 46
                                              47 2 12 30 0 18 48 1 6 50 0 51 2
                                              12 0 0 52 53 1 0 12 6 54 2 0 12
                                              12 15 16 1 0 20 12 21 2 0 22 12
                                              10 23 2 0 12 12 13 14 1 0 26 12
                                              27 2 0 12 12 28 29 2 0 12 12 15
                                              33 1 0 12 6 54 1 0 22 12 49)))))
           '|lookupComplete|)) 
