
(/VERSIONCHECK 2) 

(DEFUN |BOP1;evaluate;BoMBo;1| (|op| |func| $)
  (SPADCALL |op| (CONS #'|BOP1;evaluate;BoMBo;1!0| (VECTOR |func| $))
      (QREFELT $ 17))) 

(DEFUN |BOP1;evaluate;BoMBo;1!0| (|#1| $$)
  (SPADCALL (SPADCALL |#1| (QREFELT (QREFELT $$ 1) 14)) (QREFELT $$ 0))) 

(DEFUN |BOP1;evaluate;BoU;2| (|op| $)
  (PROG (|func|)
    (RETURN
      (SEQ (LETT |func| (SPADCALL |op| (QREFELT $ 10) (QREFELT $ 21))
                 |BOP1;evaluate;BoU;2|)
           (EXIT (COND
                   ((QEQCAR |func| 1) (CONS 1 "failed"))
                   ('T (CONS 0 (QCDR |func|))))))))) 

(DEFUN |BOP1;evaluate;BoLU;3| (|op| |args| $)
  (PROG (|func|)
    (RETURN
      (SEQ (LETT |func| (SPADCALL |op| (QREFELT $ 10) (QREFELT $ 21))
                 |BOP1;evaluate;BoLU;3|)
           (EXIT (COND
                   ((QEQCAR |func| 1) (CONS 1 "failed"))
                   ('T (CONS 0 (SPADCALL |args| (QCDR |func|)))))))))) 

(DEFUN |BOP1;evaluate;BoMBo;4| (|op| |func| $)
  (SPADCALL |op| (QREFELT $ 10) |func| (QREFELT $ 27))) 

(DEFUN |BOP1;derivative;BoU;5| (|op| $)
  (PROG (|func|)
    (RETURN
      (SEQ (LETT |func| (SPADCALL |op| (QREFELT $ 12) (QREFELT $ 21))
                 |BOP1;derivative;BoU;5|)
           (EXIT (COND
                   ((QEQCAR |func| 1) (CONS 1 "failed"))
                   ('T (CONS 0 (QCDR |func|))))))))) 

(DEFUN |BOP1;derivative;BoLBo;6| (|op| |grad| $)
  (SPADCALL |op| (QREFELT $ 12) |grad| (QREFELT $ 27))) 

(DEFUN |BOP1;derivative;BoMBo;7| (|op| |f| $)
  (COND
    ((OR (SPADCALL |op| (QREFELT $ 33)) (SPADCALL |op| (QREFELT $ 34)))
     (SPADCALL |op|
         (LIST (CONS #'|BOP1;derivative;BoMBo;7!0| (VECTOR |f| $)))
         (QREFELT $ 31)))
    ('T (|error| "Operator is not unary")))) 

(DEFUN |BOP1;derivative;BoMBo;7!0| (|#1| $$)
  (SPADCALL (SPADCALL |#1| (QREFELT (QREFELT $$ 1) 14)) (QREFELT $$ 0))) 

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

(DEFUN |BOP1;cdisp| (|a| |l| $) |a|) 

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

(DEFUN |BOP1;csex| (|a| |l| $) |a|) 

(DEFUN |BOP1;eqconst?| (|a| |b| $)
  (PROG (|va| |vb|)
    (RETURN
      (SEQ (LETT |va| (SPADCALL |a| (QREFELT $ 11) (QREFELT $ 21))
                 . #0=(|BOP1;eqconst?|))
           (EXIT (COND
                   ((QEQCAR |va| 1)
                    (COND
                      ((SPADCALL |b| (QREFELT $ 11) (QREFELT $ 42))
                       'NIL)
                      ('T 'T)))
                   (#1='T
                    (SEQ (LETT |vb|
                               (SPADCALL |b| (QREFELT $ 11)
                                   (QREFELT $ 21)) . #0#)
                         (EXIT (COND
                                 ((QEQCAR |vb| 0)
                                  (SPADCALL (QCDR |va|) (QCDR |vb|)
                                      (QREFELT $ 43)))
                                 (#1# 'NIL))))))))))) 

(DEFUN |BOP1;ltconst?| (|a| |b| $)
  (PROG (|va| |vb|)
    (RETURN
      (SEQ (LETT |va| (SPADCALL |a| (QREFELT $ 11) (QREFELT $ 21))
                 . #0=(|BOP1;ltconst?|))
           (EXIT (COND
                   ((QEQCAR |va| 1)
                    (SPADCALL |b| (QREFELT $ 11) (QREFELT $ 42)))
                   (#1='T
                    (SEQ (LETT |vb|
                               (SPADCALL |b| (QREFELT $ 11)
                                   (QREFELT $ 21)) . #0#)
                         (EXIT (COND
                                 ((QEQCAR |vb| 0)
                                  (SPADCALL (QCDR |va|) (QCDR |vb|)
                                      (QREFELT $ 44)))
                                 (#1# 'NIL))))))))))) 

(DEFUN |BOP1;constOp| (|a| $)
  (PROG ()
    (RETURN
      (SPADCALL
          (SPADCALL (SPADCALL (QREFELT $ 41) (QREFELT $ 45))
              (CONS #'|BOP1;constOp!0| (VECTOR $ |a|)) (QREFELT $ 49))
          (QREFELT $ 11) |a| (QREFELT $ 27))))) 

(DEFUN |BOP1;constOp!0| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |BOP1;constOp|)
    (RETURN
      (PROGN
        (|BOP1;cdisp| (SPADCALL (QREFELT $$ 1) (QREFELT $ 47)) |#1| $))))) 

(DEFUN |BOP1;constantOpIfCan;BoU;13| (|op| $)
  (PROG (|u| #0=#:G1892)
    (RETURN
      (SEQ (EXIT (SEQ (COND
                        ((SPADCALL |op|
                             (SPADCALL "constant" (QREFELT $ 9))
                             (QREFELT $ 50))
                         (SEQ (LETT |u|
                                    (SPADCALL |op| (QREFELT $ 11)
                                     (QREFELT $ 21))
                                    . #1=(|BOP1;constantOpIfCan;BoU;13|))
                              (EXIT (COND
                                      ((QEQCAR |u| 0)
                                       (PROGN
                                         (LETT #0#
                                          (CONS 0 (QCDR |u|)) . #1#)
                                         (GO #0#))))))))
                      (EXIT (CONS 1 "failed"))))
           #0# (EXIT #0#))))) 

(DEFUN |BOP1;constantOperator;ABo;14| (|a| $)
  (PROG ()
    (RETURN
      (SPADCALL (|BOP1;constOp| |a| $)
          (CONS #'|BOP1;constantOperator;ABo;14!0| (VECTOR $ |a|))
          (QREFELT $ 55))))) 

(DEFUN |BOP1;constantOperator;ABo;14!0| (|#1| $$)
  (PROG ($)
    (LETT $ (QREFELT $$ 0) |BOP1;constantOperator;ABo;14|)
    (RETURN
      (PROGN
        (|BOP1;csex| (SPADCALL (QREFELT $$ 1) (QREFELT $ 53)) |#1| $))))) 

(DEFUN |BOP1;constantOperator;ABo;15| (|a| $) (|BOP1;constOp| |a| $)) 

(DEFUN |BasicOperatorFunctions1| (#0=#:G1897)
  (PROG ()
    (RETURN
      (PROG (#1=#:G1898)
        (RETURN
          (COND
            ((LETT #1#
                   (|lassocShiftWithFunction| (LIST (|devaluate| #0#))
                       (HGET |$ConstructorCache|
                             '|BasicOperatorFunctions1|)
                       '|domainEqualList|)
                   . #2=(|BasicOperatorFunctions1|))
             (|CDRwithIncrement| #1#))
            ('T
             (UNWIND-PROTECT
               (PROG1 (|BasicOperatorFunctions1;| #0#)
                 (LETT #1# T . #2#))
               (COND
                 ((NOT #1#)
                  (HREM |$ConstructorCache| '|BasicOperatorFunctions1|))))))))))) 

(DEFUN |BasicOperatorFunctions1;| (|#1|)
  (PROG (DV$1 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|) . #0=(|BasicOperatorFunctions1|))
        (LETT |dv$| (LIST '|BasicOperatorFunctions1| DV$1) . #0#)
        (LETT $ (GETREFV 57) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3
            (LETT |pv$|
                  (|buildPredVector| 0 0
                      (LIST (|HasCategory| |#1| '(|OrderedSet|)))) . #0#))
        (|haddProp| |$ConstructorCache| '|BasicOperatorFunctions1|
            (LIST DV$1) (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 10 (SPADCALL "%eval" (QREFELT $ 9)))
        (QSETREFV $ 11 (SPADCALL "%constant" (QREFELT $ 9)))
        (QSETREFV $ 12 (SPADCALL "%diff" (QREFELT $ 9)))
        (COND
          ((|testBitVector| |pv$| 1)
           (PROGN
             (QSETREFV $ 41
                 (SPADCALL
                     (SPADCALL
                         (SPADCALL (SPADCALL "constant" (QREFELT $ 9))
                             0 (QREFELT $ 37))
                         (CONS (|function| |BOP1;eqconst?|) $)
                         (QREFELT $ 39))
                     (CONS (|function| |BOP1;ltconst?|) $)
                     (QREFELT $ 40)))
             (QSETREFV $ 51
                 (CONS (|dispatchFunction|
                           |BOP1;constantOpIfCan;BoU;13|)
                       $))
             (COND
               ((|HasCategory| |#1| '(|ConvertibleTo| (|InputForm|)))
                (QSETREFV $ 56
                    (CONS (|dispatchFunction|
                              |BOP1;constantOperator;ABo;14|)
                          $)))
               ('T
                (QSETREFV $ 56
                    (CONS (|dispatchFunction|
                              |BOP1;constantOperator;ABo;15|)
                          $)))))))
        $)))) 

(MAKEPROP '|BasicOperatorFunctions1| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|String|)
             (|Symbol|) (0 . |coerce|) 'EVAL 'CONST 'DIFF (|List| 6)
             (5 . |first|) (|BasicOperator|) (|Mapping| 6 13)
             |BOP1;evaluate;BoMBo;4| (|Mapping| 6 6)
             |BOP1;evaluate;BoMBo;1| (|Union| 26 '"failed")
             (10 . |property|) (|Union| 16 '"failed")
             |BOP1;evaluate;BoU;2| (|Union| 6 '"failed")
             |BOP1;evaluate;BoLU;3| (|None|) (16 . |setProperty|)
             (|Union| 30 '"failed") |BOP1;derivative;BoU;5| (|List| 16)
             |BOP1;derivative;BoLBo;6| (|Boolean|) (23 . |unary?|)
             (28 . |nary?|) |BOP1;derivative;BoMBo;7|
             (|NonNegativeInteger|) (33 . |operator|)
             (|Mapping| 32 $ $) (39 . |equality|) (45 . |comparison|)
             '|opconst| (51 . |has?|) (57 . =) (63 . <) (69 . |copy|)
             (|OutputForm|) (74 . |coerce|) (|Mapping| 46 (|List| 46))
             (79 . |display|) (85 . |is?|) (91 . |constantOpIfCan|)
             (|InputForm|) (96 . |convert|) (|Mapping| 52 (|List| 52))
             (101 . |input|) (107 . |constantOperator|))
          '#(|evaluate| 112 |derivative| 135 |constantOperator| 152
             |constantOpIfCan| 157)
          'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 56
                                '(1 8 0 7 9 1 13 6 0 14 2 15 20 0 8 21
                                  3 15 0 0 8 26 27 1 15 32 0 33 1 15 32
                                  0 34 2 15 0 8 36 37 2 15 0 0 38 39 2
                                  15 0 0 38 40 2 15 32 0 8 42 2 6 32 0
                                  0 43 2 6 32 0 0 44 1 15 0 0 45 1 6 46
                                  0 47 2 15 0 0 48 49 2 15 32 0 8 50 1
                                  0 24 15 51 1 6 52 0 53 2 15 0 0 54 55
                                  1 0 15 6 56 2 0 15 15 16 17 2 0 24 15
                                  13 25 1 0 22 15 23 2 0 15 15 18 19 2
                                  0 15 15 18 35 2 0 15 15 30 31 1 0 28
                                  15 29 1 1 15 6 56 1 1 24 15 51)))))
          '|lookupComplete|)) 
