
(/VERSIONCHECK 2) 

(DEFUN |MKFLCFN;streq?| (|s| |st| $)
  (SPADCALL |s| (SPADCALL (SPADCALL |st| (QREFELT $ 9)) (QREFELT $ 11))
      (QREFELT $ 16))) 

(DEFUN |MKFLCFN;gencode| (|s| |l| $)
  (SPADCALL
      (CONS (SPADCALL (SPADCALL |s| (QREFELT $ 9)) (QREFELT $ 11)) |l|)
      (QREFELT $ 13))) 

(DEFUN |MKFLCFN;streqlist?| (|s| |l| $)
  (SPADCALL (SPADCALL (SPADCALL |s| (QREFELT $ 17)) (QREFELT $ 18)) |l|
      (QREFELT $ 20))) 

(DEFUN |MKFLCFN;mkPretend| (|form| $)
  (SPADCALL
      (LIST (SPADCALL (SPADCALL "pretend" (QREFELT $ 9))
                (QREFELT $ 11))
            |form| (QREFELT $ 14))
      (QREFELT $ 13))) 

(DEFUN |MKFLCFN;mkCTOR| (|form| $)
  (SPADCALL
      (LIST (SPADCALL (SPADCALL "C-TO-R" (QREFELT $ 9)) (QREFELT $ 11))
            |form|)
      (QREFELT $ 13))) 

(DEFUN |MKFLCFN;mkLispCall| (|name| $)
  (SPADCALL (LIST (SPADCALL (SPADCALL "$elt" (QREFELT $ 9))
                      (QREFELT $ 11))
                  (SPADCALL (SPADCALL "Lisp" (QREFELT $ 9))
                      (QREFELT $ 11))
                  |name|)
            (QREFELT $ 13))) 

(DEFUN |MKFLCFN;mkDefun| (|s| |lv| $)
  (PROG (|name| |fun|)
    (RETURN
      (SEQ (LETT |name|
                 (SPADCALL (SPADCALL (QREFELT $ 21)) (QREFELT $ 11))
                 . #0=(|MKFLCFN;mkDefun|))
           (LETT |fun|
                 (SPADCALL
                     (LIST (SPADCALL (SPADCALL "DEFUN" (QREFELT $ 9))
                               (QREFELT $ 11))
                           |name| (SPADCALL |lv| (QREFELT $ 13))
                           (|MKFLCFN;gencode| "DECLARE"
                               (LIST (|MKFLCFN;gencode| "FLOAT" |lv| $))
                               $)
                           (|MKFLCFN;mkCTOR| |s| $))
                     (QREFELT $ 13)) . #0#)
           (EVAL |fun|)
           (COND (|$compileDontDefineFunctions| (COMPILE |name|)))
           (EXIT |name|))))) 

(DEFUN |MKFLCFN;makeFloatFunction;S2SM;8| (|f| |x| |y| $)
  (PROG (|u| |ix| |iy| |name| |t| |spadname| |spadform|)
    (RETURN
      (SEQ (LETT |u| (|MKFLCFN;mkLisp| (SPADCALL |f| (QREFELT $ 22)) $)
                 . #0=(|MKFLCFN;makeFloatFunction;S2SM;8|))
           (EXIT (COND
                   ((QEQCAR |u| 1)
                    (SPADCALL |f| |x| |y| (QREFELT $ 25)))
                   ('T
                    (SEQ (LETT |name|
                               (|MKFLCFN;mkDefun| (QCDR |u|)
                                   (LIST
                                    (LETT |ix|
                                     (SPADCALL |x| (QREFELT $ 11)) . #0#)
                                    (LETT |iy|
                                     (SPADCALL |y| (QREFELT $ 11)) . #0#))
                                   $) . #0#)
                         (LETT |t|
                               (LIST (QREFELT $ 14) (QREFELT $ 14)) . #0#)
                         (LETT |spadname|
                               (SPADCALL
                                   (|devaluate|
                                    (|Mapping| (|DoubleFloat|)
                                     (|DoubleFloat|) (|DoubleFloat|)))
                                   (QREFELT $ 26)) . #0#)
                         (LETT |spadform|
                               (|MKFLCFN;mkPretend|
                                   (SPADCALL
                                    (LIST
                                     (|MKFLCFN;mkLispCall| |name| $)
                                     |ix| |iy|)
                                    (QREFELT $ 13))
                                   $) . #0#)
                         (SPADCALL
                             (SPADCALL |spadform| (LIST |x| |y|)
                                 |spadname| (QREFELT $ 28))
                             (QREFELT $ 30))
                         (EXIT (SPADCALL
                                   (SPADCALL |spadname| |t|
                                    (QREFELT $ 31))
                                   (QREFELT $ 32))))))))))) 

(DEFUN |MKFLCFN;makeFloatFunction;SSM;9| (|f| |var| $)
  (PROG (|u| |ivar| |name| |t| |spadname| |spadform|)
    (RETURN
      (SEQ (LETT |u| (|MKFLCFN;mkLisp| (SPADCALL |f| (QREFELT $ 22)) $)
                 . #0=(|MKFLCFN;makeFloatFunction;SSM;9|))
           (EXIT (COND
                   ((QEQCAR |u| 1) (SPADCALL |f| |var| (QREFELT $ 36)))
                   ('T
                    (SEQ (LETT |name|
                               (|MKFLCFN;mkDefun| (QCDR |u|)
                                   (LIST
                                    (LETT |ivar|
                                     (SPADCALL |var| (QREFELT $ 11)) . #0#))
                                   $) . #0#)
                         (LETT |t| (LIST (QREFELT $ 14)) . #0#)
                         (LETT |spadname|
                               (SPADCALL
                                   (|devaluate|
                                    (|Mapping| (|DoubleFloat|)
                                     (|DoubleFloat|)))
                                   (QREFELT $ 26)) . #0#)
                         (LETT |spadform|
                               (|MKFLCFN;mkPretend|
                                   (SPADCALL
                                    (LIST
                                     (|MKFLCFN;mkLispCall| |name| $)
                                     |ivar|)
                                    (QREFELT $ 13))
                                   $) . #0#)
                         (SPADCALL
                             (SPADCALL |spadform| (LIST |var|)
                                 |spadname| (QREFELT $ 28))
                             (QREFELT $ 30))
                         (EXIT (SPADCALL
                                   (SPADCALL |spadname| |t|
                                    (QREFELT $ 31))
                                   (QREFELT $ 37))))))))))) 

(DEFUN |MKFLCFN;mkLispList| (|l| $)
  (PROG (|s| #0=#:G1857 |u| #1=#:G1856 |ans|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |ans| NIL . #2=(|MKFLCFN;mkLispList|))
                      (SEQ (LETT |s| NIL . #2#) (LETT #0# |l| . #2#)
                           G190
                           (COND
                             ((OR (ATOM #0#)
                                  (PROGN
                                    (LETT |s| (CAR #0#) . #2#)
                                    NIL))
                              (GO G191)))
                           (SEQ (LETT |u|
                                      (|MKFLCFN;mkLisp| |s| $) . #2#)
                                (EXIT (COND
                                        ((QEQCAR |u| 1)
                                         (PROGN
                                           (LETT #1#
                                            (CONS 1 "failed") . #2#)
                                           (GO #1#)))
                                        ('T
                                         (LETT |ans|
                                          (CONS (QCDR |u|) |ans|) . #2#)))))
                           (LETT #0# (CDR #0#) . #2#) (GO G190) G191
                           (EXIT NIL))
                      (EXIT (CONS 0 (NREVERSE |ans|)))))
           #1# (EXIT #1#))))) 

(DEFUN |MKFLCFN;mkLisp| (|s| $)
  (PROG (|l| |op| |u| |ll| |a| |e| |b|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |s| (QREFELT $ 39)) (CONS 0 |s|))
             ('T
              (SEQ (LETT |op|
                         (|SPADfirst|
                             (LETT |l| (SPADCALL |s| (QREFELT $ 40))
                                   . #0=(|MKFLCFN;mkLisp|))) . #0#)
                   (LETT |u| (|MKFLCFN;mkLispList| (CDR |l|) $) . #0#)
                   (EXIT (COND
                           ((QEQCAR |u| 1) (CONS 1 "failed"))
                           ('T
                            (SEQ (LETT |ll| (QCDR |u|) . #0#)
                                 (EXIT (COND
                                         ((|MKFLCFN;streqlist?| |op|
                                           (LIST "+" "*" "/" "-") $)
                                          (CONS 0
                                           (SPADCALL (CONS |op| |ll|)
                                            (QREFELT $ 13))))
                                         ((|MKFLCFN;streq?| |op| "**"
                                           $)
                                          (CONS 0
                                           (|MKFLCFN;gencode| "EXPT"
                                            |ll| $)))
                                         ((|MKFLCFN;streqlist?| |op|
                                           (LIST "exp" "sin" "cos"
                                            "tan" "atan" "log" "sinh"
                                            "cosh" "tanh" "asinh"
                                            "acosh" "atanh" "sqrt")
                                           $)
                                          (CONS 0
                                           (|MKFLCFN;gencode|
                                            (SPADCALL
                                             (SPADCALL
                                              (SPADCALL |op|
                                               (QREFELT $ 17))
                                              (QREFELT $ 18))
                                             (QREFELT $ 41))
                                            |ll| $)))
                                         ((|MKFLCFN;streq?| |op|
                                           "nthRoot" $)
                                          (COND
                                            ((SPADCALL
                                              (SPADCALL |ll|
                                               (QREFELT $ 43))
                                              (SPADCALL 2
                                               (QREFELT $ 45))
                                              (QREFELT $ 16))
                                             (CONS 0
                                              (|MKFLCFN;gencode| "SQRT"
                                               (LIST
                                                (|SPADfirst| |ll|))
                                               $)))
                                            ('T
                                             (CONS 0
                                              (|MKFLCFN;gencode| "EXPT"
                                               (CONS (|SPADfirst| |ll|)
                                                (LIST
                                                 (SPADCALL
                                                  (|spadConstant| $ 46)
                                                  (SPADCALL |ll|
                                                   (QREFELT $ 43))
                                                  (QREFELT $ 47))))
                                               $)))))
                                         ((|MKFLCFN;streq?| |op|
                                           "float" $)
                                          (SEQ
                                           (LETT |a|
                                            (SPADCALL |ll| 1
                                             (QREFELT $ 48)) . #0#)
                                           (LETT |e|
                                            (SPADCALL |ll| 2
                                             (QREFELT $ 48)) . #0#)
                                           (LETT |b|
                                            (SPADCALL |ll| 3
                                             (QREFELT $ 48)) . #0#)
                                           (EXIT
                                            (CONS 0
                                             (* |a| (EXPT |b| |e|))))))
                                         ('T (CONS 1 "failed"))))))))))))))) 

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

(DEFUN |MakeFloatCompiledFunction;| (|#1|)
  (PROG (DV$1 |dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT DV$1 (|devaluate| |#1|)
              . #0=(|MakeFloatCompiledFunction|))
        (LETT |dv$| (LIST '|MakeFloatCompiledFunction| DV$1) . #0#)
        (LETT $ (GETREFV 49) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
        (|haddProp| |$ConstructorCache| '|MakeFloatCompiledFunction|
            (LIST DV$1) (CONS 1 $))
        (|stuffDomainSlots| $)
        (QSETREFV $ 6 |#1|)
        (QSETREFV $ 14
            (SPADCALL
                (LIST (SPADCALL (SPADCALL "DoubleFloat" (QREFELT $ 9))
                          (QREFELT $ 11)))
                (QREFELT $ 13)))
        $)))) 

(MAKEPROP '|MakeFloatCompiledFunction| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|String|)
             (|Symbol|) (0 . |coerce|) (|InputForm|) (5 . |convert|)
             (|List| $) (10 . |convert|) '|lsf| (|Boolean|) (15 . =)
             (21 . |symbol|) (26 . |string|) (|List| 7)
             (31 . |member?|) (37 . |new|) (41 . |convert|)
             (|Mapping| (|DoubleFloat|) (|DoubleFloat|)
                 (|DoubleFloat|))
             (|MakeBinaryCompiledFunction| 6 (|DoubleFloat|)
                 (|DoubleFloat|) (|DoubleFloat|))
             (46 . |compiledFunction|) (53 . |declare|) (|List| 8)
             (58 . |function|) (|Any|) (65 . |interpret|)
             (70 . |compile|) (76 . |binaryFunction|)
             |MKFLCFN;makeFloatFunction;S2SM;8|
             (|Mapping| (|DoubleFloat|) (|DoubleFloat|))
             (|MakeUnaryCompiledFunction| 6 (|DoubleFloat|)
                 (|DoubleFloat|))
             (81 . |compiledFunction|) (87 . |unaryFunction|)
             |MKFLCFN;makeFloatFunction;SSM;9| (92 . |atom?|)
             (97 . |destruct|) (102 . |upperCase|) (|List| 10)
             (107 . |second|) (|Integer|) (112 . |convert|)
             (117 . |One|) (121 . /) (127 . |elt|))
          '#(|makeFloatFunction| 133) 'NIL
          (CONS (|makeByteWordVec2| 1 'NIL)
                (CONS '#()
                      (CONS '#()
                            (|makeByteWordVec2| 48
                                '(1 8 0 7 9 1 10 0 8 11 1 10 0 12 13 2
                                  10 15 0 0 16 1 10 8 0 17 1 8 7 0 18 2
                                  19 15 7 0 20 0 8 0 21 1 6 10 0 22 3
                                  24 23 6 8 8 25 1 10 8 12 26 3 10 0 0
                                  27 8 28 1 10 29 0 30 2 10 8 8 12 31 1
                                  24 23 8 32 2 35 34 6 8 36 1 35 34 8
                                  37 1 10 15 0 39 1 10 12 0 40 1 7 0 0
                                  41 1 42 10 0 43 1 10 0 44 45 0 10 0
                                  46 2 10 0 0 0 47 2 42 10 0 44 48 3 0
                                  23 6 8 8 33 2 0 34 6 8 38)))))
          '|lookupComplete|)) 
