
(/VERSIONCHECK 2) 

(DEFUN |FLOAT;writeOMFloat| (|dev| |x| $)
  (SEQ (SPADCALL |dev| (QREFELT $ 13))
       (SPADCALL |dev| "bigfloat1" "bigfloat" (QREFELT $ 15))
       (SPADCALL |dev| (SPADCALL |x| (QREFELT $ 17)) (QREFELT $ 18))
       (SPADCALL |dev| 2 (QREFELT $ 18))
       (SPADCALL |dev| (SPADCALL |x| (QREFELT $ 19)) (QREFELT $ 18))
       (EXIT (SPADCALL |dev| (QREFELT $ 20))))) 

(DEFUN |FLOAT;OMwrite;$S;2| (|x| $)
  (PROG (|sp| |dev| |s|)
    (RETURN
      (SEQ (LETT |s| "" . #0=(|FLOAT;OMwrite;$S;2|))
           (LETT |sp| (OM-STRINGTOSTRINGPTR |s|) . #0#)
           (LETT |dev|
                 (SPADCALL |sp| (SPADCALL (QREFELT $ 22))
                     (QREFELT $ 23)) . #0#)
           (SPADCALL |dev| (QREFELT $ 24))
           (|FLOAT;writeOMFloat| |dev| |x| $)
           (SPADCALL |dev| (QREFELT $ 25))
           (SPADCALL |dev| (QREFELT $ 26))
           (LETT |s| (OM-STRINGPTRTOSTRING |sp|) . #0#) (EXIT |s|))))) 

(DEFUN |FLOAT;OMwrite;$BS;3| (|x| |wholeObj| $)
  (PROG (|sp| |dev| |s|)
    (RETURN
      (SEQ (LETT |s| "" . #0=(|FLOAT;OMwrite;$BS;3|))
           (LETT |sp| (OM-STRINGTOSTRINGPTR |s|) . #0#)
           (LETT |dev|
                 (SPADCALL |sp| (SPADCALL (QREFELT $ 22))
                     (QREFELT $ 23)) . #0#)
           (COND (|wholeObj| (SPADCALL |dev| (QREFELT $ 24))))
           (|FLOAT;writeOMFloat| |dev| |x| $)
           (COND (|wholeObj| (SPADCALL |dev| (QREFELT $ 25))))
           (SPADCALL |dev| (QREFELT $ 26))
           (LETT |s| (OM-STRINGPTRTOSTRING |sp|) . #0#) (EXIT |s|))))) 

(DEFUN |FLOAT;OMwrite;Omd$V;4| (|dev| |x| $)
  (SEQ (SPADCALL |dev| (QREFELT $ 24))
       (|FLOAT;writeOMFloat| |dev| |x| $)
       (EXIT (SPADCALL |dev| (QREFELT $ 25))))) 

(DEFUN |FLOAT;OMwrite;Omd$BV;5| (|dev| |x| |wholeObj| $)
  (SEQ (COND (|wholeObj| (SPADCALL |dev| (QREFELT $ 24))))
       (|FLOAT;writeOMFloat| |dev| |x| $)
       (EXIT (COND (|wholeObj| (SPADCALL |dev| (QREFELT $ 25))))))) 

(DEFUN |FLOAT;shift2| (|x| |y| $)
  (* (SPADCALL |x| (QREFELT $ 32))
     (ASH (* (SPADCALL |x| (QREFELT $ 32)) |x|) |y|))) 

(DEFUN |FLOAT;asin;2$;7| (|x| $)
  (PROG (|r|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |x| (QREFELT $ 33)) (|spadConstant| $ 34))
             ((SPADCALL |x| (QREFELT $ 35))
              (SPADCALL
                  (SPADCALL (SPADCALL |x| (QREFELT $ 36))
                      (QREFELT $ 37))
                  (QREFELT $ 36)))
             ((SPADCALL |x| (|spadConstant| $ 38) (QREFELT $ 39))
              (SPADCALL (SPADCALL (QREFELT $ 40)) 2 (QREFELT $ 41)))
             ((SPADCALL (|spadConstant| $ 38) |x| (QREFELT $ 42))
              (|error| "asin: argument > 1 in magnitude"))
             ('T
              (SEQ (SPADCALL 5 (QREFELT $ 43))
                   (LETT |r|
                         (SPADCALL
                             (SPADCALL |x|
                                 (SPADCALL
                                     (|FLOAT;sub| (|spadConstant| $ 38)
                                      (|FLOAT;times| |x| |x| $) $)
                                     (QREFELT $ 44))
                                 (QREFELT $ 45))
                             (QREFELT $ 46))
                         |FLOAT;asin;2$;7|)
                   (SPADCALL 5 (QREFELT $ 47))
                   (EXIT (SPADCALL |r| (QREFELT $ 48)))))))))) 

(DEFUN |FLOAT;acos;2$;8| (|x| $)
  (PROG (|r|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |x| (QREFELT $ 33))
              (SPADCALL (SPADCALL (QREFELT $ 40)) 2 (QREFELT $ 41)))
             ((SPADCALL |x| (QREFELT $ 35))
              (SEQ (SPADCALL 3 (QREFELT $ 43))
                   (LETT |r|
                         (SPADCALL (SPADCALL (QREFELT $ 40))
                             (SPADCALL (SPADCALL |x| (QREFELT $ 36))
                                 (QREFELT $ 49))
                             (QREFELT $ 50))
                         . #0=(|FLOAT;acos;2$;8|))
                   (SPADCALL 3 (QREFELT $ 47))
                   (EXIT (SPADCALL |r| (QREFELT $ 48)))))
             ((SPADCALL |x| (|spadConstant| $ 38) (QREFELT $ 39))
              (|spadConstant| $ 34))
             ((SPADCALL (|spadConstant| $ 38) |x| (QREFELT $ 42))
              (|error| "acos: argument > 1 in magnitude"))
             ('T
              (SEQ (SPADCALL 5 (QREFELT $ 43))
                   (LETT |r|
                         (SPADCALL
                             (SPADCALL
                                 (SPADCALL
                                     (|FLOAT;sub| (|spadConstant| $ 38)
                                      (|FLOAT;times| |x| |x| $) $)
                                     (QREFELT $ 44))
                                 |x| (QREFELT $ 45))
                             (QREFELT $ 46)) . #0#)
                   (SPADCALL 5 (QREFELT $ 47))
                   (EXIT (SPADCALL |r| (QREFELT $ 48)))))))))) 

(DEFUN |FLOAT;atan;3$;9| (|x| |y| $)
  (PROG (|theta|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |x| (|spadConstant| $ 34) (QREFELT $ 39))
              (COND
                ((SPADCALL (|spadConstant| $ 34) |y| (QREFELT $ 42))
                 (SPADCALL (SPADCALL (QREFELT $ 40)) 2 (QREFELT $ 41)))
                ((SPADCALL |y| (|spadConstant| $ 34) (QREFELT $ 42))
                 (SPADCALL
                     (SPADCALL (SPADCALL (QREFELT $ 40)) 2
                         (QREFELT $ 41))
                     (QREFELT $ 36)))
                (#0='T (|spadConstant| $ 34))))
             (#0#
              (SEQ (LETT |theta|
                         (SPADCALL
                             (SPADCALL
                                 (SPADCALL |y| |x| (QREFELT $ 45))
                                 (QREFELT $ 51))
                             (QREFELT $ 46))
                         . #1=(|FLOAT;atan;3$;9|))
                   (COND
                     ((SPADCALL |x| (|spadConstant| $ 34)
                          (QREFELT $ 42))
                      (LETT |theta|
                            (SPADCALL (SPADCALL (QREFELT $ 40)) |theta|
                                (QREFELT $ 50)) . #1#)))
                   (COND
                     ((SPADCALL |y| (|spadConstant| $ 34)
                          (QREFELT $ 42))
                      (LETT |theta|
                            (SPADCALL |theta| (QREFELT $ 36)) . #1#)))
                   (EXIT |theta|)))))))) 

(DEFUN |FLOAT;atan;2$;10| (|x| $)
  (PROG (|r| #0=#:G1942 |k| |i| |t|)
    (RETURN
      (SEQ (EXIT (COND
                   ((SPADCALL |x| (QREFELT $ 33))
                    (|spadConstant| $ 34))
                   ((SPADCALL |x| (QREFELT $ 35))
                    (SPADCALL
                        (SPADCALL (SPADCALL |x| (QREFELT $ 36))
                            (QREFELT $ 46))
                        (QREFELT $ 36)))
                   ('T
                    (SEQ (COND
                           ((SPADCALL (|spadConstant| $ 38) |x|
                                (QREFELT $ 42))
                            (SEQ (SPADCALL 4 (QREFELT $ 43))
                                 (LETT |r|
                                       (COND
                                         ((SPADCALL
                                           (SPADCALL |x|
                                            (QREFELT $ 53))
                                           (QREFELT $ 33))
                                          (COND
                                            ((SPADCALL |x|
                                              (CONS
                                               (SPADCALL
                                                (QREFELT $ 54))
                                               0)
                                              (QREFELT $ 42))
                                             (|FLOAT;atanInverse|
                                              (SPADCALL |x|
                                               (QREFELT $ 55))
                                              $))
                                            ('T
                                             (SPADCALL
                                              (SPADCALL
                                               (|spadConstant| $ 38)
                                               |x| (QREFELT $ 45))
                                              (QREFELT $ 46)))))
                                         ('T
                                          (SPADCALL
                                           (SPADCALL
                                            (|spadConstant| $ 38) |x|
                                            (QREFELT $ 45))
                                           (QREFELT $ 46))))
                                       . #1=(|FLOAT;atan;2$;10|))
                                 (LETT |r|
                                       (SPADCALL
                                        (SPADCALL
                                         (SPADCALL (QREFELT $ 40)) 2
                                         (QREFELT $ 41))
                                        |r| (QREFELT $ 50)) . #1#)
                                 (SPADCALL 4 (QREFELT $ 47))
                                 (EXIT (PROGN
                                         (LETT #0#
                                          (SPADCALL |r| (QREFELT $ 48)) . #1#)
                                         (GO #0#))))))
                         (LETT |k|
                               (QUOTIENT2
                                   (SPADCALL
                                    (- (SPADCALL (QREFELT $ 54)) 100)
                                    (QREFELT $ 57))
                                   5) . #1#)
                         (LETT |k|
                               (MAX 0
                                    (+ (+ 2 |k|)
                                     (SPADCALL |x| (QREFELT $ 58)))) . #1#)
                         (SPADCALL (SPADCALL 2 |k| (QREFELT $ 59))
                             (QREFELT $ 43))
                         (SEQ (LETT |i| 1 . #1#) G190
                              (COND ((QSGREATERP |i| |k|) (GO G191)))
                              (SEQ (EXIT
                                    (LETT |x|
                                     (SPADCALL |x|
                                      (SPADCALL (|spadConstant| $ 38)
                                       (SPADCALL
                                        (SPADCALL (|spadConstant| $ 38)
                                         (SPADCALL |x| |x|
                                          (QREFELT $ 60))
                                         (QREFELT $ 61))
                                        (QREFELT $ 44))
                                       (QREFELT $ 61))
                                      (QREFELT $ 45)) . #1#)))
                              (LETT |i| (QSADD1 |i|) . #1#) (GO G190)
                              G191 (EXIT NIL))
                         (LETT |t| (|FLOAT;atanSeries| |x| $) . #1#)
                         (SPADCALL (SPADCALL 2 |k| (QREFELT $ 59))
                             (QREFELT $ 47))
                         (LETT |t|
                               (SPADCALL |t| |k| (QREFELT $ 62)) . #1#)
                         (EXIT (SPADCALL |t| (QREFELT $ 48)))))))
           #0# (EXIT #0#))))) 

(DEFUN |FLOAT;atanSeries| (|x| $)
  (PROG (|p| |d| |y| |m| |i| |s| |t|)
    (RETURN
      (SEQ (LETT |p|
                 (+ (+ (SPADCALL (QREFELT $ 54))
                       (INTEGER-LENGTH (SPADCALL (QREFELT $ 54))))
                    2)
                 . #0=(|FLOAT;atanSeries|))
           (LETT |s| (LETT |d| (ASH 1 |p|) . #0#) . #0#)
           (LETT |y| (|FLOAT;times| |x| |x| $) . #0#)
           (LETT |t|
                 (LETT |m|
                       (- (|FLOAT;shift2| (QCAR |y|) (+ (QCDR |y|) |p|)
                              $)) . #0#) . #0#)
           (SEQ (LETT |i| 3 . #0#) G190
                (COND
                  ((NULL (COND ((EQL |t| 0) 'NIL) ('T 'T))) (GO G191)))
                (SEQ (LETT |s| (+ |s| (QUOTIENT2 |t| |i|)) . #0#)
                     (EXIT (LETT |t| (QUOTIENT2 (* |m| |t|) |d|) . #0#)))
                (LETT |i| (QSPLUS |i| 2) . #0#) (GO G190) G191
                (EXIT NIL))
           (EXIT (SPADCALL |x| (CONS |s| (- |p|)) (QREFELT $ 60))))))) 

(DEFUN |FLOAT;atanInverse| (|n| $)
  (PROG (|n2| |e| |k| |s| |t|)
    (RETURN
      (SEQ (LETT |n2| (- (* |n| |n|)) . #0=(|FLOAT;atanInverse|))
           (LETT |e|
                 (+ (+ (+ (SPADCALL (QREFELT $ 54))
                          (INTEGER-LENGTH (SPADCALL (QREFELT $ 54))))
                       (INTEGER-LENGTH |n|))
                    1) . #0#)
           (LETT |s| (QUOTIENT2 (ASH 1 |e|) |n|) . #0#)
           (LETT |t| (QUOTIENT2 |s| |n2|) . #0#)
           (SEQ (LETT |k| 3 . #0#) G190
                (COND
                  ((NULL (COND ((EQL |t| 0) 'NIL) ('T 'T))) (GO G191)))
                (SEQ (LETT |s| (+ |s| (QUOTIENT2 |t| |k|)) . #0#)
                     (EXIT (LETT |t| (QUOTIENT2 |t| |n2|) . #0#)))
                (LETT |k| (QSPLUS |k| 2) . #0#) (GO G190) G191
                (EXIT NIL))
           (EXIT (SPADCALL (CONS |s| (- |e|)) (QREFELT $ 48))))))) 

(DEFUN |FLOAT;sin;2$;13| (|x| $)
  (PROG (|p| |s| |k| #0=#:G1963 |i| |r|)
    (RETURN
      (SEQ (LETT |s| (SPADCALL |x| (QREFELT $ 63))
                 . #1=(|FLOAT;sin;2$;13|))
           (LETT |x| (SPADCALL |x| (QREFELT $ 51)) . #1#)
           (LETT |p| (SPADCALL (QREFELT $ 54)) . #1#)
           (SPADCALL 4 (QREFELT $ 43))
           (COND
             ((SPADCALL (CONS 6 0) |x| (QREFELT $ 42))
              (SEQ (SPADCALL |p| (QREFELT $ 43))
                   (LETT |x|
                         (SPADCALL
                             (SPADCALL 2 (SPADCALL (QREFELT $ 40))
                                 (QREFELT $ 64))
                             (SPADCALL
                                 (SPADCALL
                                     (SPADCALL |x|
                                      (SPADCALL (QREFELT $ 40))
                                      (QREFELT $ 45))
                                     2 (QREFELT $ 41))
                                 (QREFELT $ 53))
                             (QREFELT $ 60)) . #1#)
                   (EXIT (SPADCALL |p| (QREFELT $ 65))))))
           (COND
             ((SPADCALL (CONS 3 0) |x| (QREFELT $ 42))
              (SEQ (SPADCALL |p| (QREFELT $ 43))
                   (LETT |s| (- |s|) . #1#)
                   (LETT |x|
                         (SPADCALL |x| (SPADCALL (QREFELT $ 40))
                             (QREFELT $ 50)) . #1#)
                   (EXIT (SPADCALL |p| (QREFELT $ 65))))))
           (COND
             ((SPADCALL (CONS 3 -1) |x| (QREFELT $ 42))
              (SEQ (SPADCALL |p| (QREFELT $ 43))
                   (LETT |x|
                         (SPADCALL (SPADCALL (QREFELT $ 40)) |x|
                             (QREFELT $ 50)) . #1#)
                   (EXIT (SPADCALL |p| (QREFELT $ 47))))))
           (LETT |k|
                 (QUOTIENT2
                     (SPADCALL (- (SPADCALL (QREFELT $ 54)) 100)
                         (QREFELT $ 57))
                     4) . #1#)
           (LETT |k|
                 (MAX 0 (+ (+ 2 |k|) (SPADCALL |x| (QREFELT $ 58)))) . #1#)
           (COND
             ((< 0 |k|)
              (SEQ (SPADCALL |k| (QREFELT $ 43))
                   (EXIT (LETT |x|
                               (SPADCALL |x|
                                   (EXPT 3
                                    (PROG1 (LETT #0# |k| . #1#)
                                      (|check-subtype| (>= #0# 0)
                                       '(|NonNegativeInteger|) #0#)))
                                   (QREFELT $ 41)) . #1#)))))
           (LETT |r| (|FLOAT;sinSeries| |x| $) . #1#)
           (SEQ (LETT |i| 1 . #1#) G190
                (COND ((QSGREATERP |i| |k|) (GO G191)))
                (SEQ (EXIT (LETT |r|
                                 (SPADCALL (|FLOAT;itimes| 3 |r| $)
                                     (SPADCALL
                                      (SPADCALL |r| 3 (QREFELT $ 66)) 2
                                      (QREFELT $ 62))
                                     (QREFELT $ 50)) . #1#)))
                (LETT |i| (QSADD1 |i|) . #1#) (GO G190) G191
                (EXIT NIL))
           (SPADCALL |p| (QREFELT $ 65))
           (EXIT (SPADCALL |s| |r| (QREFELT $ 67))))))) 

(DEFUN |FLOAT;sinSeries| (|x| $)
  (PROG (|p| |y| |d| |m| |i| |s| |t|)
    (RETURN
      (SEQ (LETT |p|
                 (+ (+ (SPADCALL (QREFELT $ 54))
                       (INTEGER-LENGTH (SPADCALL (QREFELT $ 54))))
                    2)
                 . #0=(|FLOAT;sinSeries|))
           (LETT |y| (|FLOAT;times| |x| |x| $) . #0#)
           (LETT |s| (LETT |d| (ASH 1 |p|) . #0#) . #0#)
           (LETT |m|
                 (- (|FLOAT;shift2| (QCAR |y|) (+ (QCDR |y|) |p|) $)) . #0#)
           (LETT |t| (QUOTIENT2 |m| 6) . #0#)
           (SEQ (LETT |i| 4 . #0#) G190
                (COND
                  ((NULL (COND ((EQL |t| 0) 'NIL) ('T 'T))) (GO G191)))
                (SEQ (LETT |s| (+ |s| |t|) . #0#)
                     (LETT |t|
                           (QUOTIENT2 (* |m| |t|) (* |i| (+ |i| 1))) . #0#)
                     (EXIT (LETT |t| (QUOTIENT2 |t| |d|) . #0#)))
                (LETT |i| (QSPLUS |i| 2) . #0#) (GO G190) G191
                (EXIT NIL))
           (EXIT (SPADCALL |x| (CONS |s| (- |p|)) (QREFELT $ 60))))))) 

(DEFUN |FLOAT;cos;2$;15| (|x| $)
  (PROG (|p| |s| #0=#:G1983 |k| |i| |r|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |s| 1 . #1=(|FLOAT;cos;2$;15|))
                      (LETT |x| (SPADCALL |x| (QREFELT $ 51)) . #1#)
                      (LETT |p| (SPADCALL (QREFELT $ 54)) . #1#)
                      (SPADCALL 4 (QREFELT $ 43))
                      (COND
                        ((SPADCALL (CONS 6 0) |x| (QREFELT $ 42))
                         (SEQ (SPADCALL |p| (QREFELT $ 43))
                              (LETT |x|
                                    (SPADCALL
                                     (SPADCALL 2
                                      (SPADCALL (QREFELT $ 40))
                                      (QREFELT $ 64))
                                     (SPADCALL
                                      (SPADCALL
                                       (SPADCALL |x|
                                        (SPADCALL (QREFELT $ 40))
                                        (QREFELT $ 45))
                                       2 (QREFELT $ 41))
                                      (QREFELT $ 53))
                                     (QREFELT $ 60)) . #1#)
                              (EXIT (SPADCALL |p| (QREFELT $ 47))))))
                      (COND
                        ((SPADCALL (CONS 3 0) |x| (QREFELT $ 42))
                         (SEQ (SPADCALL |p| (QREFELT $ 43))
                              (LETT |s| (- |s|) . #1#)
                              (LETT |x|
                                    (SPADCALL |x|
                                     (SPADCALL (QREFELT $ 40))
                                     (QREFELT $ 50)) . #1#)
                              (EXIT (SPADCALL |p| (QREFELT $ 47))))))
                      (COND
                        ((SPADCALL (CONS 1 0) |x| (QREFELT $ 42))
                         (SEQ (SPADCALL |p| (QREFELT $ 43))
                              (LETT |x|
                                    (SPADCALL
                                     (SPADCALL
                                      (SPADCALL (QREFELT $ 40)) 2
                                      (QREFELT $ 41))
                                     |x| (QREFELT $ 50)) . #1#)
                              (SPADCALL |p| (QREFELT $ 65))
                              (LETT |x|
                                    (SPADCALL |x| (QREFELT $ 48)) . #1#)
                              (EXIT (PROGN
                                      (LETT #0#
                                       (SPADCALL |s|
                                        (SPADCALL |x| (QREFELT $ 68))
                                        (QREFELT $ 67)) . #1#)
                                      (GO #0#))))))
                      (LETT |k|
                            (QUOTIENT2
                                (SPADCALL
                                    (- (SPADCALL (QREFELT $ 54)) 100)
                                    (QREFELT $ 57))
                                3) . #1#)
                      (LETT |k|
                            (MAX 0
                                 (+ (+ 2 |k|)
                                    (SPADCALL |x| (QREFELT $ 58)))) . #1#)
                      (COND
                        ((< 0 |k|)
                         (SEQ (SPADCALL
                                  (+ |k| (EXPT (INTEGER-LENGTH |k|) 2))
                                  (QREFELT $ 43))
                              (EXIT (LETT |x|
                                     (SPADCALL |x| (- |k|)
                                      (QREFELT $ 62)) . #1#)))))
                      (LETT |r| (|FLOAT;cosSeries| |x| $) . #1#)
                      (SEQ (LETT |i| 1 . #1#) G190
                           (COND ((QSGREATERP |i| |k|) (GO G191)))
                           (SEQ (EXIT (LETT |r|
                                       (SPADCALL
                                        (SPADCALL
                                         (SPADCALL |r| |r|
                                          (QREFELT $ 60))
                                         1 (QREFELT $ 62))
                                        (|spadConstant| $ 38)
                                        (QREFELT $ 50)) . #1#)))
                           (LETT |i| (QSADD1 |i|) . #1#) (GO G190) G191
                           (EXIT NIL))
                      (SPADCALL |p| (QREFELT $ 65))
                      (EXIT (SPADCALL |s| |r| (QREFELT $ 67)))))
           #0# (EXIT #0#))))) 

(DEFUN |FLOAT;cosSeries| (|x| $)
  (PROG (|p| |y| |d| |m| |i| |s| |t|)
    (RETURN
      (SEQ (LETT |p|
                 (+ (+ (SPADCALL (QREFELT $ 54))
                       (INTEGER-LENGTH (SPADCALL (QREFELT $ 54))))
                    1)
                 . #0=(|FLOAT;cosSeries|))
           (LETT |y| (|FLOAT;times| |x| |x| $) . #0#)
           (LETT |s| (LETT |d| (ASH 1 |p|) . #0#) . #0#)
           (LETT |m|
                 (- (|FLOAT;shift2| (QCAR |y|) (+ (QCDR |y|) |p|) $)) . #0#)
           (LETT |t| (QUOTIENT2 |m| 2) . #0#)
           (SEQ (LETT |i| 3 . #0#) G190
                (COND
                  ((NULL (COND ((EQL |t| 0) 'NIL) ('T 'T))) (GO G191)))
                (SEQ (LETT |s| (+ |s| |t|) . #0#)
                     (LETT |t|
                           (QUOTIENT2 (* |m| |t|) (* |i| (+ |i| 1))) . #0#)
                     (EXIT (LETT |t| (QUOTIENT2 |t| |d|) . #0#)))
                (LETT |i| (QSPLUS |i| 2) . #0#) (GO G190) G191
                (EXIT NIL))
           (EXIT (SPADCALL (CONS |s| (- |p|)) (QREFELT $ 48))))))) 

(DEFUN |FLOAT;tan;2$;17| (|x| $)
  (PROG (|p| |s| |c| |t|)
    (RETURN
      (SEQ (LETT |s| (SPADCALL |x| (QREFELT $ 63))
                 . #0=(|FLOAT;tan;2$;17|))
           (LETT |x| (SPADCALL |x| (QREFELT $ 51)) . #0#)
           (LETT |p| (SPADCALL (QREFELT $ 54)) . #0#)
           (SPADCALL 6 (QREFELT $ 43))
           (COND
             ((SPADCALL (CONS 3 0) |x| (QREFELT $ 42))
              (SEQ (SPADCALL |p| (QREFELT $ 43))
                   (LETT |x|
                         (SPADCALL (SPADCALL (QREFELT $ 40))
                             (SPADCALL
                                 (SPADCALL |x|
                                     (SPADCALL (QREFELT $ 40))
                                     (QREFELT $ 45))
                                 (QREFELT $ 53))
                             (QREFELT $ 60)) . #0#)
                   (EXIT (SPADCALL |p| (QREFELT $ 47))))))
           (COND
             ((SPADCALL (CONS 3 -1) |x| (QREFELT $ 42))
              (SEQ (SPADCALL |p| (QREFELT $ 43))
                   (LETT |x|
                         (SPADCALL (SPADCALL (QREFELT $ 40)) |x|
                             (QREFELT $ 50)) . #0#)
                   (LETT |s| (- |s|) . #0#)
                   (EXIT (SPADCALL |p| (QREFELT $ 47))))))
           (COND
             ((SPADCALL (|spadConstant| $ 38) |x| (QREFELT $ 42))
              (SEQ (LETT |c| (SPADCALL |x| (QREFELT $ 69)) . #0#)
                   (EXIT (LETT |t|
                               (SPADCALL
                                   (SPADCALL
                                    (SPADCALL (|spadConstant| $ 38)
                                     (SPADCALL |c| |c| (QREFELT $ 60))
                                     (QREFELT $ 50))
                                    (QREFELT $ 44))
                                   |c| (QREFELT $ 45)) . #0#))))
             ('T
              (SEQ (LETT |c| (SPADCALL |x| (QREFELT $ 68)) . #0#)
                   (EXIT (LETT |t|
                               (SPADCALL |c|
                                   (SPADCALL
                                    (SPADCALL (|spadConstant| $ 38)
                                     (SPADCALL |c| |c| (QREFELT $ 60))
                                     (QREFELT $ 50))
                                    (QREFELT $ 44))
                                   (QREFELT $ 45)) . #0#)))))
           (SPADCALL |p| (QREFELT $ 65))
           (EXIT (SPADCALL |s| |t| (QREFELT $ 67))))))) 

(DEFUN |FLOAT;pi;$;18| ($)
  (COND
    ((NULL (< (QCAR (QREFELT $ 71)) (SPADCALL (QREFELT $ 54))))
     (SPADCALL (QCDR (QREFELT $ 71)) (QREFELT $ 48)))
    ('T
     (QCDR (SETELT $ 71
                   (CONS (SPADCALL (QREFELT $ 54))
                         (|FLOAT;piRamanujan| $))))))) 

(DEFUN |FLOAT;piRamanujan| ($)
  (PROG (|n| |d| |j| |i| |s| |m| |t|)
    (RETURN
      (SEQ (LETT |n|
                 (+ (+ (SPADCALL (QREFELT $ 54))
                       (INTEGER-LENGTH (SPADCALL (QREFELT $ 54))))
                    11)
                 . #0=(|FLOAT;piRamanujan|))
           (LETT |t| (QUOTIENT2 (ASH 1 |n|) 882) . #0#)
           (LETT |d| (* 4 (SPADCALL 882 2 (QREFELT $ 73))) . #0#)
           (LETT |s| 0 . #0#)
           (SEQ (LETT |j| 1123 . #0#) (LETT |i| 2 . #0#) G190
                (COND
                  ((NULL (COND ((EQL |t| 0) 'NIL) ('T 'T))) (GO G191)))
                (SEQ (LETT |s|
                           (+ |s| (SPADCALL |j| |t| (QREFELT $ 75))) . #0#)
                     (LETT |m|
                           (- (* (* (- |i| 1)
                                    (- (SPADCALL 2 |i| (QREFELT $ 76))
                                     1))
                                 (- (SPADCALL 2 |i| (QREFELT $ 76)) 3))) . #0#)
                     (EXIT (LETT |t|
                                 (QUOTIENT2 (* |m| |t|)
                                     (* |d|
                                      (SPADCALL |i| 3 (QREFELT $ 77)))) . #0#)))
                (LETT |i|
                      (PROG1 (QSPLUS |i| 2)
                        (LETT |j| (QSPLUS |j| 21460) . #0#)) . #0#)
                (GO G190) G191 (EXIT NIL))
           (EXIT (SPADCALL (|spadConstant| $ 38)
                     (CONS |s| (- (- |n|) 2)) (QREFELT $ 45))))))) 

(DEFUN |FLOAT;sinh;2$;20| (|x| $)
  (PROG (|lost| |e| |s|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |x| (QREFELT $ 33)) (|spadConstant| $ 34))
             ('T
              (SEQ (LETT |lost|
                         (MAX (- (SPADCALL |x| (QREFELT $ 58))) 0)
                         . #0=(|FLOAT;sinh;2$;20|))
                   (EXIT (COND
                           ((< (SPADCALL (QREFELT $ 54))
                               (SPADCALL 2 |lost| (QREFELT $ 59)))
                            |x|)
                           ('T
                            (SEQ (SPADCALL (+ 5 |lost|) (QREFELT $ 43))
                                 (LETT |e|
                                       (SPADCALL |x| (QREFELT $ 78)) . #0#)
                                 (LETT |s|
                                       (SPADCALL
                                        (SPADCALL |e|
                                         (SPADCALL
                                          (|spadConstant| $ 38) |e|
                                          (QREFELT $ 45))
                                         (QREFELT $ 50))
                                        2 (QREFELT $ 41)) . #0#)
                                 (SPADCALL (+ 5 |lost|) (QREFELT $ 47))
                                 (EXIT (SPADCALL |s| (QREFELT $ 48)))))))))))))) 

(DEFUN |FLOAT;cosh;2$;21| (|x| $)
  (PROG (|e| |c|)
    (RETURN
      (SEQ (SPADCALL 5 (QREFELT $ 43))
           (LETT |e| (SPADCALL |x| (QREFELT $ 78))
                 . #0=(|FLOAT;cosh;2$;21|))
           (LETT |c|
                 (SPADCALL
                     (SPADCALL |e|
                         (SPADCALL (|spadConstant| $ 38) |e|
                             (QREFELT $ 45))
                         (QREFELT $ 61))
                     2 (QREFELT $ 41)) . #0#)
           (SPADCALL 5 (QREFELT $ 47))
           (EXIT (SPADCALL |c| (QREFELT $ 48))))))) 

(DEFUN |FLOAT;tanh;2$;22| (|x| $)
  (PROG (|lost| |e| |t|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |x| (QREFELT $ 33)) (|spadConstant| $ 34))
             ('T
              (SEQ (LETT |lost|
                         (MAX (- (SPADCALL |x| (QREFELT $ 58))) 0)
                         . #0=(|FLOAT;tanh;2$;22|))
                   (EXIT (COND
                           ((< (SPADCALL (QREFELT $ 54))
                               (SPADCALL 2 |lost| (QREFELT $ 59)))
                            |x|)
                           ('T
                            (SEQ (SPADCALL (+ 6 |lost|) (QREFELT $ 43))
                                 (LETT |e|
                                       (SPADCALL |x| (QREFELT $ 78)) . #0#)
                                 (LETT |e|
                                       (SPADCALL |e| |e|
                                        (QREFELT $ 60)) . #0#)
                                 (LETT |t|
                                       (SPADCALL
                                        (SPADCALL |e|
                                         (|spadConstant| $ 38)
                                         (QREFELT $ 50))
                                        (SPADCALL |e|
                                         (|spadConstant| $ 38)
                                         (QREFELT $ 61))
                                        (QREFELT $ 45)) . #0#)
                                 (SPADCALL (+ 6 |lost|) (QREFELT $ 47))
                                 (EXIT (SPADCALL |t| (QREFELT $ 48)))))))))))))) 

(DEFUN |FLOAT;asinh;2$;23| (|x| $)
  (PROG (|p| #0=#:G2024 |r|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |p| (MIN 0 (SPADCALL |x| (QREFELT $ 58)))
                            . #1=(|FLOAT;asinh;2$;23|))
                      (COND
                        ((OR (SPADCALL |x| (QREFELT $ 33))
                             (< (SPADCALL 2 |p| (QREFELT $ 59))
                                (- (SPADCALL (QREFELT $ 54)))))
                         (PROGN (LETT #0# |x| . #1#) (GO #0#))))
                      (SPADCALL (- 5 |p|) (QREFELT $ 43))
                      (LETT |r|
                            (SPADCALL
                                (SPADCALL |x|
                                    (SPADCALL
                                     (SPADCALL (|spadConstant| $ 38)
                                      (SPADCALL |x| |x| (QREFELT $ 60))
                                      (QREFELT $ 61))
                                     (QREFELT $ 44))
                                    (QREFELT $ 61))
                                (QREFELT $ 82)) . #1#)
                      (SPADCALL (- 5 |p|) (QREFELT $ 47))
                      (EXIT (SPADCALL |r| (QREFELT $ 48)))))
           #0# (EXIT #0#))))) 

(DEFUN |FLOAT;acosh;2$;24| (|x| $)
  (PROG (|r|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |x| (|spadConstant| $ 38) (QREFELT $ 42))
              (|error| "invalid argument to acosh")))
           (SPADCALL 5 (QREFELT $ 43))
           (LETT |r|
                 (SPADCALL
                     (SPADCALL |x|
                         (SPADCALL
                             (|FLOAT;sub| (|FLOAT;times| |x| |x| $)
                                 (|spadConstant| $ 38) $)
                             (QREFELT $ 44))
                         (QREFELT $ 61))
                     (QREFELT $ 82))
                 |FLOAT;acosh;2$;24|)
           (SPADCALL 5 (QREFELT $ 47))
           (EXIT (SPADCALL |r| (QREFELT $ 48))))))) 

(DEFUN |FLOAT;atanh;2$;25| (|x| $)
  (PROG (|p| #0=#:G2032 |r|)
    (RETURN
      (SEQ (EXIT (SEQ (COND
                        ((OR (SPADCALL (|spadConstant| $ 38) |x|
                                 (QREFELT $ 42))
                             (SPADCALL |x|
                                 (SPADCALL (|spadConstant| $ 38)
                                     (QREFELT $ 36))
                                 (QREFELT $ 42)))
                         (|error| "invalid argument to atanh")))
                      (LETT |p| (MIN 0 (SPADCALL |x| (QREFELT $ 58)))
                            . #1=(|FLOAT;atanh;2$;25|))
                      (COND
                        ((OR (SPADCALL |x| (QREFELT $ 33))
                             (< (SPADCALL 2 |p| (QREFELT $ 59))
                                (- (SPADCALL (QREFELT $ 54)))))
                         (PROGN (LETT #0# |x| . #1#) (GO #0#))))
                      (SPADCALL (- 5 |p|) (QREFELT $ 43))
                      (LETT |r|
                            (SPADCALL
                                (SPADCALL
                                    (SPADCALL
                                     (SPADCALL |x|
                                      (|spadConstant| $ 38)
                                      (QREFELT $ 61))
                                     (SPADCALL (|spadConstant| $ 38)
                                      |x| (QREFELT $ 50))
                                     (QREFELT $ 45))
                                    (QREFELT $ 82))
                                2 (QREFELT $ 41)) . #1#)
                      (SPADCALL (- 5 |p|) (QREFELT $ 47))
                      (EXIT (SPADCALL |r| (QREFELT $ 48)))))
           #0# (EXIT #0#))))) 

(DEFUN |FLOAT;log;2$;26| (|x| $)
  (PROG (|p| |n| |k| #0=#:G2037 |ek| |m| |l|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |x| (QREFELT $ 35)) (|error| "negative log"))
             ((SPADCALL |x| (QREFELT $ 33))
              (|error| "log 0 generated"))
             ('T
              (SEQ (LETT |p| (SPADCALL (QREFELT $ 54))
                         . #1=(|FLOAT;log;2$;26|))
                   (SPADCALL 5 (QREFELT $ 43))
                   (SEQ (LETT |n| (SPADCALL |x| (QREFELT $ 58)) . #1#)
                        (EXIT (COND
                                ((< |n| 0) (LETT |n| (+ |n| 1) . #1#)))))
                   (LETT |l|
                         (COND
                           ((EQL |n| 0) (|spadConstant| $ 34))
                           ('T
                            (SEQ (LETT |x|
                                       (SPADCALL |x| (- |n|)
                                        (QREFELT $ 62)) . #1#)
                                 (EXIT (SPADCALL |n|
                                        (SPADCALL (QREFELT $ 86))
                                        (QREFELT $ 67)))))) . #1#)
                   (LETT |k|
                         (QUOTIENT2
                             (SPADCALL (- |p| 100) (QREFELT $ 57)) 3) . #1#)
                   (COND
                     ((< 1 |k|)
                      (SEQ (LETT |k|
                                 (MAX 1
                                      (+ |k|
                                       (SPADCALL
                                        (SPADCALL |x|
                                         (|spadConstant| $ 38)
                                         (QREFELT $ 50))
                                        (QREFELT $ 58)))) . #1#)
                           (SPADCALL |k| (QREFELT $ 43))
                           (LETT |ek|
                                 (|FLOAT;expInverse|
                                     (EXPT 2
                                      (PROG1 (LETT #0# |k| . #1#)
                                        (|check-subtype| (>= #0# 0)
                                         '(|NonNegativeInteger|) #0#)))
                                     $) . #1#)
                           (SPADCALL (QUOTIENT2 |p| 2) (QREFELT $ 47))
                           (LETT |m|
                                 (SPADCALL (|FLOAT;square| |x| |k| $)
                                     (QREFELT $ 58)) . #1#)
                           (SPADCALL (QUOTIENT2 |p| 2) (QREFELT $ 43))
                           (LETT |m|
                                 (QUOTIENT2
                                     (SPADCALL 6847196937 |m|
                                      (QREFELT $ 59))
                                     9878417065) . #1#)
                           (LETT |x|
                                 (SPADCALL |x|
                                     (SPADCALL |ek| (- |m|)
                                      (QREFELT $ 87))
                                     (QREFELT $ 60)) . #1#)
                           (EXIT (LETT |l|
                                       (SPADCALL |l| (CONS |m| (- |k|))
                                        (QREFELT $ 61)) . #1#)))))
                   (LETT |l|
                         (SPADCALL |l| (|FLOAT;logSeries| |x| $)
                             (QREFELT $ 61)) . #1#)
                   (SPADCALL |p| (QREFELT $ 65))
                   (EXIT (SPADCALL |l| (QREFELT $ 48)))))))))) 

(DEFUN |FLOAT;logSeries| (|x| $)
  (PROG (|g| |p| |y| |d| |z| |m| |i| |s| |t|)
    (RETURN
      (SEQ (LETT |p|
                 (+ (SPADCALL (QREFELT $ 54))
                    (LETT |g|
                          (+ (INTEGER-LENGTH (SPADCALL (QREFELT $ 54)))
                             3)
                          . #0=(|FLOAT;logSeries|))) . #0#)
           (SPADCALL |g| (QREFELT $ 43))
           (LETT |y|
                 (SPADCALL
                     (SPADCALL |x| (|spadConstant| $ 38)
                         (QREFELT $ 50))
                     (SPADCALL |x| (|spadConstant| $ 38)
                         (QREFELT $ 61))
                     (QREFELT $ 45)) . #0#)
           (SPADCALL |g| (QREFELT $ 47))
           (LETT |s| (LETT |d| (ASH 1 |p|) . #0#) . #0#)
           (LETT |z| (|FLOAT;times| |y| |y| $) . #0#)
           (LETT |t|
                 (LETT |m|
                       (|FLOAT;shift2| (QCAR |z|) (+ (QCDR |z|) |p|) $) . #0#) . #0#)
           (SEQ (LETT |i| 3 . #0#) G190
                (COND
                  ((NULL (COND ((EQL |t| 0) 'NIL) ('T 'T))) (GO G191)))
                (SEQ (LETT |s| (+ |s| (QUOTIENT2 |t| |i|)) . #0#)
                     (EXIT (LETT |t| (QUOTIENT2 (* |m| |t|) |d|) . #0#)))
                (LETT |i| (QSPLUS |i| 2) . #0#) (GO G190) G191
                (EXIT NIL))
           (EXIT (SPADCALL |y| (CONS |s| (- 1 |p|)) (QREFELT $ 60))))))) 

(DEFUN |FLOAT;log2;$;28| ($)
  (PROG (|n| |k| |s| |t|)
    (RETURN
      (SEQ (LETT |n| (SPADCALL (QREFELT $ 54))
                 . #0=(|FLOAT;log2;$;28|))
           (COND
             ((NULL (< (QCAR (QREFELT $ 88)) |n|))
              (EXIT (SPADCALL (QCDR (QREFELT $ 88)) (QREFELT $ 48)))))
           (LETT |n| (+ (+ |n| (INTEGER-LENGTH |n|)) 3) . #0#)
           (LETT |s| (QUOTIENT2 (ASH 1 (+ |n| 1)) 3) . #0#)
           (LETT |t| (QUOTIENT2 |s| 9) . #0#)
           (SEQ (LETT |k| 3 . #0#) G190
                (COND
                  ((NULL (COND ((EQL |t| 0) 'NIL) ('T 'T))) (GO G191)))
                (SEQ (LETT |s| (+ |s| (QUOTIENT2 |t| |k|)) . #0#)
                     (EXIT (LETT |t| (QUOTIENT2 |t| 9) . #0#)))
                (LETT |k| (QSPLUS |k| 2) . #0#) (GO G190) G191
                (EXIT NIL))
           (SETELT $ 88
                   (CONS (SPADCALL (QREFELT $ 54)) (CONS |s| (- |n|))))
           (EXIT (SPADCALL (QCDR (QREFELT $ 88)) (QREFELT $ 48))))))) 

(DEFUN |FLOAT;log10;$;29| ($)
  (PROG (|n| |k| |s| |t|)
    (RETURN
      (SEQ (LETT |n| (SPADCALL (QREFELT $ 54))
                 . #0=(|FLOAT;log10;$;29|))
           (COND
             ((NULL (< (QCAR (QREFELT $ 89)) |n|))
              (EXIT (SPADCALL (QCDR (QREFELT $ 89)) (QREFELT $ 48)))))
           (LETT |n| (+ (+ |n| (INTEGER-LENGTH |n|)) 5) . #0#)
           (LETT |s| (QUOTIENT2 (ASH 1 (+ |n| 1)) 9) . #0#)
           (LETT |t| (QUOTIENT2 |s| 81) . #0#)
           (SEQ (LETT |k| 3 . #0#) G190
                (COND
                  ((NULL (COND ((EQL |t| 0) 'NIL) ('T 'T))) (GO G191)))
                (SEQ (LETT |s| (+ |s| (QUOTIENT2 |t| |k|)) . #0#)
                     (EXIT (LETT |t| (QUOTIENT2 |t| 81) . #0#)))
                (LETT |k| (QSPLUS |k| 2) . #0#) (GO G190) G191
                (EXIT NIL))
           (SPADCALL 2 (QREFELT $ 43))
           (SETELT $ 89
                   (CONS (SPADCALL (QREFELT $ 54))
                         (SPADCALL (CONS |s| (- |n|))
                             (SPADCALL 3 (SPADCALL (QREFELT $ 86))
                                 (QREFELT $ 64))
                             (QREFELT $ 61))))
           (SPADCALL 2 (QREFELT $ 47))
           (EXIT (SPADCALL (QCDR (QREFELT $ 89)) (QREFELT $ 48))))))) 

(DEFUN |FLOAT;log2;2$;30| (|x| $)
  (PROG (|r|)
    (RETURN
      (SEQ (SPADCALL 2 (QREFELT $ 43))
           (LETT |r|
                 (SPADCALL (SPADCALL |x| (QREFELT $ 82))
                     (SPADCALL (QREFELT $ 86)) (QREFELT $ 45))
                 |FLOAT;log2;2$;30|)
           (SPADCALL 2 (QREFELT $ 47))
           (EXIT (SPADCALL |r| (QREFELT $ 48))))))) 

(DEFUN |FLOAT;log10;2$;31| (|x| $)
  (PROG (|r|)
    (RETURN
      (SEQ (SPADCALL 2 (QREFELT $ 43))
           (LETT |r|
                 (SPADCALL (SPADCALL |x| (QREFELT $ 82))
                     (SPADCALL (QREFELT $ 90)) (QREFELT $ 45))
                 |FLOAT;log10;2$;31|)
           (SPADCALL 2 (QREFELT $ 47))
           (EXIT (SPADCALL |r| (QREFELT $ 48))))))) 

(DEFUN |FLOAT;exp;2$;32| (|x| $)
  (PROG (|p| |n| |e1| #0=#:G2071 |k| |e|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |p| (SPADCALL (QREFELT $ 54))
                            . #1=(|FLOAT;exp;2$;32|))
                      (SPADCALL 5 (QREFELT $ 43))
                      (LETT |e1| (|spadConstant| $ 38) . #1#)
                      (SEQ (LETT |n|
                                 (SPADCALL |x| (QREFELT $ 55)) . #1#)
                           (EXIT (COND
                                   ((NULL (EQL |n| 0))
                                    (SEQ
                                     (SPADCALL (INTEGER-LENGTH |n|)
                                      (QREFELT $ 43))
                                     (LETT |e1|
                                      (SPADCALL
                                       (SPADCALL (QREFELT $ 93)) |n|
                                       (QREFELT $ 87)) . #1#)
                                     (SPADCALL (INTEGER-LENGTH |n|)
                                      (QREFELT $ 47))
                                     (EXIT
                                      (LETT |x|
                                       (SPADCALL |x| (QREFELT $ 53)) . #1#)))))))
                      (COND
                        ((SPADCALL |x| (QREFELT $ 33))
                         (SEQ (SPADCALL |p| (QREFELT $ 65))
                              (EXIT (PROGN
                                      (LETT #0#
                                       (SPADCALL |e1| (QREFELT $ 48)) . #1#)
                                      (GO #0#))))))
                      (LETT |k|
                            (QUOTIENT2
                                (SPADCALL (- |p| 100) (QREFELT $ 57))
                                3) . #1#)
                      (LETT |k|
                            (MAX 0
                                 (+ (+ 2 |k|)
                                    (SPADCALL |x| (QREFELT $ 58)))) . #1#)
                      (COND
                        ((< 0 |k|)
                         (SEQ (SPADCALL |k| (QREFELT $ 43))
                              (EXIT (LETT |x|
                                     (SPADCALL |x| (- |k|)
                                      (QREFELT $ 62)) . #1#)))))
                      (LETT |e| (|FLOAT;expSeries| |x| $) . #1#)
                      (COND
                        ((< 0 |k|)
                         (LETT |e| (|FLOAT;square| |e| |k| $) . #1#)))
                      (SPADCALL |p| (QREFELT $ 65))
                      (EXIT (SPADCALL |e| |e1| (QREFELT $ 60)))))
           #0# (EXIT #0#))))) 

(DEFUN |FLOAT;expSeries| (|x| $)
  (PROG (|p| |d| |n| |i| |s| |t|)
    (RETURN
      (SEQ (LETT |p|
                 (+ (+ (SPADCALL (QREFELT $ 54))
                       (INTEGER-LENGTH (SPADCALL (QREFELT $ 54))))
                    1)
                 . #0=(|FLOAT;expSeries|))
           (LETT |s| (LETT |d| (ASH 1 |p|) . #0#) . #0#)
           (LETT |t|
                 (LETT |n|
                       (|FLOAT;shift2| (QCAR |x|) (+ (QCDR |x|) |p|) $) . #0#) . #0#)
           (SEQ (LETT |i| 2 . #0#) G190
                (COND
                  ((NULL (COND ((EQL |t| 0) 'NIL) ('T 'T))) (GO G191)))
                (SEQ (LETT |s| (+ |s| |t|) . #0#)
                     (LETT |t| (QUOTIENT2 (* |n| |t|) |i|) . #0#)
                     (EXIT (LETT |t| (QUOTIENT2 |t| |d|) . #0#)))
                (LETT |i| (QSADD1 |i|) . #0#) (GO G190) G191
                (EXIT NIL))
           (EXIT (SPADCALL (CONS |s| (- |p|)) (QREFELT $ 48))))))) 

(DEFUN |FLOAT;expInverse| (|k| $)
  (PROG (|i| #0=#:G2082 |#G61| |#G62| |p0| |p1| |#G63| |#G64| |q0|
             |q1|)
    (RETURN
      (SEQ (LETT |p0| (+ (SPADCALL 2 |k| (QREFELT $ 59)) 1)
                 . #1=(|FLOAT;expInverse|))
           (LETT |p1|
                 (+ (* (SPADCALL 6 |k| (QREFELT $ 59)) |p0|) 1) . #1#)
           (LETT |q0| (- (SPADCALL 2 |k| (QREFELT $ 59)) 1) . #1#)
           (LETT |q1|
                 (+ (* (SPADCALL 6 |k| (QREFELT $ 59)) |q0|) 1) . #1#)
           (SEQ (LETT |i| (SPADCALL 10 |k| (QREFELT $ 59)) . #1#)
                (LETT #0# (SPADCALL 4 |k| (QREFELT $ 59)) . #1#) G190
                (COND
                  ((NULL (< (* 2 (INTEGER-LENGTH |p0|))
                            (SPADCALL (QREFELT $ 54))))
                   (GO G191)))
                (SEQ (PROGN
                       (LETT |#G61| |p1| . #1#)
                       (LETT |#G62| (+ (* |i| |p1|) |p0|) . #1#)
                       (LETT |p0| |#G61| . #1#)
                       (LETT |p1| |#G62| . #1#))
                     (EXIT (PROGN
                             (LETT |#G63| |q1| . #1#)
                             (LETT |#G64| (+ (* |i| |q1|) |q0|) . #1#)
                             (LETT |q0| |#G63| . #1#)
                             (LETT |q1| |#G64| . #1#))))
                (LETT |i| (+ |i| #0#) . #1#) (GO G190) G191 (EXIT NIL))
           (EXIT (|FLOAT;dvide| (CONS |p1| 0) (CONS |q1| 0) $)))))) 

(DEFUN |FLOAT;exp1;$;35| ($)
  (SEQ (COND
         ((< (QCAR (QREFELT $ 94)) (SPADCALL (QREFELT $ 54)))
          (SETELT $ 94
                  (CONS (SPADCALL (QREFELT $ 54))
                        (|FLOAT;expInverse| 1 $)))))
       (EXIT (SPADCALL (QCDR (QREFELT $ 94)) (QREFELT $ 48))))) 

(DEFUN |FLOAT;sqrt;2$;36| (|x| $)
  (PROG (|m| |e| |l| |p| |i|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |x| (QREFELT $ 35)) (|error| "negative sqrt"))
             ('T
              (SEQ (LETT |m| (QCAR |x|) . #0=(|FLOAT;sqrt;2$;36|))
                   (LETT |e| (QCDR |x|) . #0#)
                   (LETT |l| (INTEGER-LENGTH |m|) . #0#)
                   (LETT |p|
                         (+ (- (* 2 (SPADCALL (QREFELT $ 54))) |l|) 2) . #0#)
                   (COND
                     ((ODDP (- |e| |l|)) (LETT |p| (- |p| 1) . #0#)))
                   (LETT |i| (|FLOAT;shift2| (QCAR |x|) |p| $) . #0#)
                   (LETT |i| (SPADCALL |i| (QREFELT $ 57)) . #0#)
                   (EXIT (SPADCALL (CONS |i| (QUOTIENT2 (- |e| |p|) 2))
                             (QREFELT $ 48)))))))))) 

(DEFUN |FLOAT;bits;Pi;37| ($) (SPADCALL (QREFELT $ 9) (QREFELT $ 95))) 

(DEFUN |FLOAT;bits;2Pi;38| (|n| $)
  (PROG (|t|)
    (RETURN
      (SEQ (LETT |t| (SPADCALL (QREFELT $ 54)) |FLOAT;bits;2Pi;38|)
           (SPADCALL (QREFELT $ 9) |n| (QREFELT $ 96)) (EXIT |t|))))) 

(DEFUN |FLOAT;precision;Pi;39| ($) (SPADCALL (QREFELT $ 54))) 

(DEFUN |FLOAT;precision;2Pi;40| (|n| $) (SPADCALL |n| (QREFELT $ 65))) 

(DEFUN |FLOAT;increasePrecision;IPi;41| (|n| $)
  (PROG (|b| #0=#:G2098)
    (RETURN
      (SEQ (LETT |b| (SPADCALL (QREFELT $ 54))
                 . #1=(|FLOAT;increasePrecision;IPi;41|))
           (SPADCALL
               (PROG1 (LETT #0# (+ |b| |n|) . #1#)
                 (|check-subtype| (> #0# 0) '(|PositiveInteger|) #0#))
               (QREFELT $ 65))
           (EXIT |b|))))) 

(DEFUN |FLOAT;decreasePrecision;IPi;42| (|n| $)
  (PROG (|b| #0=#:G2102)
    (RETURN
      (SEQ (LETT |b| (SPADCALL (QREFELT $ 54))
                 . #1=(|FLOAT;decreasePrecision;IPi;42|))
           (SPADCALL
               (PROG1 (LETT #0# (- |b| |n|) . #1#)
                 (|check-subtype| (> #0# 0) '(|PositiveInteger|) #0#))
               (QREFELT $ 65))
           (EXIT |b|))))) 

(DEFUN |FLOAT;ceillog10base2| (|n| $)
  (PROG (#0=#:G2106)
    (RETURN
      (PROG1 (LETT #0# (QUOTIENT2 (+ (* 13301 |n|) 4003) 4004)
                   |FLOAT;ceillog10base2|)
        (|check-subtype| (> #0# 0) '(|PositiveInteger|) #0#))))) 

(DEFUN |FLOAT;digits;Pi;44| ($)
  (PROG (#0=#:G2109)
    (RETURN
      (PROG1 (LETT #0#
                   (MAX 1
                        (QUOTIENT2
                            (SPADCALL 4004
                                (- (SPADCALL (QREFELT $ 54)) 1)
                                (QREFELT $ 59))
                            13301))
                   |FLOAT;digits;Pi;44|)
        (|check-subtype| (> #0# 0) '(|PositiveInteger|) #0#))))) 

(DEFUN |FLOAT;digits;2Pi;45| (|n| $)
  (PROG (|t|)
    (RETURN
      (SEQ (LETT |t| (SPADCALL (QREFELT $ 99)) |FLOAT;digits;2Pi;45|)
           (SPADCALL (+ 1 (|FLOAT;ceillog10base2| |n| $))
               (QREFELT $ 65))
           (EXIT |t|))))) 

(DEFUN |FLOAT;order;$I;46| (|a| $)
  (- (+ (INTEGER-LENGTH (QCAR |a|)) (QCDR |a|)) 1)) 

(DEFUN |FLOAT;relerror;2$I;47| (|a| |b| $)
  (SPADCALL
      (SPADCALL (SPADCALL |a| |b| (QREFELT $ 50)) |b| (QREFELT $ 45))
      (QREFELT $ 58))) 

(PUT '|FLOAT;Zero;$;48| '|SPADreplace| '(XLAM NIL (CONS 0 0))) 

(DEFUN |FLOAT;Zero;$;48| ($) (CONS 0 0)) 

(PUT '|FLOAT;One;$;49| '|SPADreplace| '(XLAM NIL (CONS 1 0))) 

(DEFUN |FLOAT;One;$;49| ($) (CONS 1 0)) 

(PUT '|FLOAT;base;Pi;50| '|SPADreplace| '(XLAM NIL 2)) 

(DEFUN |FLOAT;base;Pi;50| ($) 2) 

(PUT '|FLOAT;mantissa;$I;51| '|SPADreplace| 'QCAR) 

(DEFUN |FLOAT;mantissa;$I;51| (|x| $) (QCAR |x|)) 

(PUT '|FLOAT;exponent;$I;52| '|SPADreplace| 'QCDR) 

(DEFUN |FLOAT;exponent;$I;52| (|x| $) (QCDR |x|)) 

(DEFUN |FLOAT;one?;$B;53| (|a| $)
  (SPADCALL |a| (|spadConstant| $ 38) (QREFELT $ 39))) 

(DEFUN |FLOAT;zero?;$B;54| (|a| $) (ZEROP (QCAR |a|))) 

(DEFUN |FLOAT;negative?;$B;55| (|a| $) (MINUSP (QCAR |a|))) 

(DEFUN |FLOAT;positive?;$B;56| (|a| $)
  (SPADCALL (QCAR |a|) (QREFELT $ 104))) 

(DEFUN |FLOAT;chop| (|x| |p| $)
  (PROG (|e|)
    (RETURN
      (SEQ (LETT |e| (- (INTEGER-LENGTH (QCAR |x|)) |p|)
                 . #0=(|FLOAT;chop|))
           (COND
             ((< 0 |e|)
              (LETT |x|
                    (CONS (|FLOAT;shift2| (QCAR |x|) (- |e|) $)
                          (+ (QCDR |x|) |e|)) . #0#)))
           (EXIT |x|))))) 

(DEFUN |FLOAT;float;2I$;58| (|m| |e| $)
  (SPADCALL (CONS |m| |e|) (QREFELT $ 48))) 

(DEFUN |FLOAT;float;2IPi$;59| (|m| |e| |b| $)
  (PROG (|r|)
    (RETURN
      (SEQ (COND
             ((EQL |m| 0) (|spadConstant| $ 34))
             ('T
              (SEQ (SPADCALL 4 (QREFELT $ 43))
                   (LETT |r|
                         (SPADCALL |m|
                             (SPADCALL (CONS |b| 0) |e| (QREFELT $ 87))
                             (QREFELT $ 67))
                         |FLOAT;float;2IPi$;59|)
                   (SPADCALL 4 (QREFELT $ 47))
                   (EXIT (SPADCALL |r| (QREFELT $ 48)))))))))) 

(DEFUN |FLOAT;normalize;2$;60| (|x| $)
  (PROG (|m| |e| |y|)
    (RETURN
      (SEQ (LETT |m| (QCAR |x|) . #0=(|FLOAT;normalize;2$;60|))
           (EXIT (COND
                   ((EQL |m| 0) (|spadConstant| $ 34))
                   ('T
                    (SEQ (LETT |e|
                               (- (INTEGER-LENGTH |m|)
                                  (SPADCALL (QREFELT $ 54))) . #0#)
                         (COND
                           ((< 0 |e|)
                            (SEQ (LETT |y|
                                       (|FLOAT;shift2| |m| (- 1 |e|) $) . #0#)
                                 (COND
                                   ((ODDP |y|)
                                    (SEQ
                                     (LETT |y|
                                      (QUOTIENT2
                                       (COND
                                         ((< 0 |y|) (+ |y| 1))
                                         ('T (- |y| 1)))
                                       2) . #0#)
                                     (EXIT
                                      (COND
                                        ((< (SPADCALL (QREFELT $ 54))
                                          (INTEGER-LENGTH |y|))
                                         (SEQ
                                          (LETT |y|
                                           (QUOTIENT2 |y| 2) . #0#)
                                          (EXIT
                                           (LETT |e| (+ |e| 1) . #0#))))))))
                                   ('T
                                    (LETT |y| (QUOTIENT2 |y| 2) . #0#)))
                                 (EXIT (LETT |x|
                                        (CONS |y| (+ (QCDR |x|) |e|)) . #0#)))))
                         (EXIT |x|))))))))) 

(DEFUN |FLOAT;shift;$I$;61| (|x| |n| $)
  (CONS (QCAR |x|) (+ (QCDR |x|) |n|))) 

(DEFUN |FLOAT;=;2$B;62| (|x| |y| $)
  (COND
    ((EQL (QCDR |x|) (QCDR |y|)) (EQL (QCAR |x|) (QCAR |y|)))
    ((EQL (SPADCALL |x| (QREFELT $ 58)) (SPADCALL |y| (QREFELT $ 58)))
     (COND
       ((EQL (SPADCALL |x| (QREFELT $ 63))
             (SPADCALL |y| (QREFELT $ 63)))
        (SPADCALL (SPADCALL |x| |y| (QREFELT $ 50)) (QREFELT $ 33)))
       ('T 'NIL)))
    ('T 'NIL))) 

(DEFUN |FLOAT;<;2$B;63| (|x| |y| $)
  (SEQ (COND
         ((EQL (QCAR |y|) 0) (< (QCAR |x|) 0))
         ((EQL (QCAR |x|) 0) (< 0 (QCAR |y|)))
         ('T
          (SEQ (COND
                 ((SPADCALL |x| (QREFELT $ 35))
                  (COND ((SPADCALL |y| (QREFELT $ 105)) (EXIT 'T)))))
               (COND
                 ((SPADCALL |y| (QREFELT $ 35))
                  (COND ((SPADCALL |x| (QREFELT $ 105)) (EXIT 'NIL)))))
               (EXIT (COND
                       ((< (SPADCALL |x| (QREFELT $ 58))
                           (SPADCALL |y| (QREFELT $ 58)))
                        (SPADCALL |x| (QREFELT $ 105)))
                       ((< (SPADCALL |y| (QREFELT $ 58))
                           (SPADCALL |x| (QREFELT $ 58)))
                        (SPADCALL |x| (QREFELT $ 35)))
                       ('T
                        (SPADCALL (SPADCALL |x| |y| (QREFELT $ 50))
                            (QREFELT $ 35)))))))))) 

(DEFUN |FLOAT;abs;2$;64| (|x| $)
  (COND
    ((SPADCALL |x| (QREFELT $ 35)) (SPADCALL |x| (QREFELT $ 36)))
    ('T (SPADCALL |x| (QREFELT $ 48))))) 

(DEFUN |FLOAT;ceiling;2$;65| (|x| $)
  (PROG (#0=#:G2161)
    (RETURN
      (SEQ (EXIT (SEQ (COND
                        ((SPADCALL |x| (QREFELT $ 35))
                         (PROGN
                           (LETT #0#
                                 (SPADCALL
                                     (SPADCALL
                                      (SPADCALL |x| (QREFELT $ 36))
                                      (QREFELT $ 108))
                                     (QREFELT $ 36))
                                 |FLOAT;ceiling;2$;65|)
                           (GO #0#))))
                      (EXIT (COND
                              ((SPADCALL (SPADCALL |x| (QREFELT $ 53))
                                   (QREFELT $ 33))
                               |x|)
                              ('T
                               (SPADCALL (SPADCALL |x| (QREFELT $ 109))
                                   (|spadConstant| $ 38)
                                   (QREFELT $ 61)))))))
           #0# (EXIT #0#))))) 

(DEFUN |FLOAT;wholePart;$I;66| (|x| $)
  (|FLOAT;shift2| (QCAR |x|) (QCDR |x|) $)) 

(DEFUN |FLOAT;floor;2$;67| (|x| $)
  (COND
    ((SPADCALL |x| (QREFELT $ 35))
     (SPADCALL (SPADCALL (SPADCALL |x| (QREFELT $ 36)) (QREFELT $ 110))
         (QREFELT $ 36)))
    ('T (SPADCALL |x| (QREFELT $ 109))))) 

(DEFUN |FLOAT;round;2$;68| (|x| $)
  (PROG (|half|)
    (RETURN
      (SEQ (LETT |half| (CONS (SPADCALL |x| (QREFELT $ 63)) -1)
                 |FLOAT;round;2$;68|)
           (EXIT (SPADCALL (SPADCALL |x| |half| (QREFELT $ 61))
                     (QREFELT $ 109))))))) 

(DEFUN |FLOAT;sign;$I;69| (|x| $) (COND ((< (QCAR |x|) 0) -1) ('T 1))) 

(DEFUN |FLOAT;truncate;2$;70| (|x| $)
  (PROG (#0=#:G2173)
    (RETURN
      (SEQ (EXIT (SEQ (COND
                        ((NULL (< (QCDR |x|) 0))
                         (PROGN
                           (LETT #0# |x| |FLOAT;truncate;2$;70|)
                           (GO #0#))))
                      (EXIT (SPADCALL
                                (CONS (|FLOAT;shift2| (QCAR |x|)
                                       (QCDR |x|) $)
                                      0)
                                (QREFELT $ 48)))))
           #0# (EXIT #0#))))) 

(DEFUN |FLOAT;recip;$U;71| (|x| $)
  (COND
    ((SPADCALL |x| (|spadConstant| $ 34) (QREFELT $ 39))
     (CONS 1 "failed"))
    ('T (CONS 0 (SPADCALL (|spadConstant| $ 38) |x| (QREFELT $ 45)))))) 

(DEFUN |FLOAT;differentiate;2$;72| (|x| $) (|spadConstant| $ 34)) 

(DEFUN |FLOAT;-;2$;73| (|x| $)
  (SPADCALL (|FLOAT;negate| |x| $) (QREFELT $ 48))) 

(DEFUN |FLOAT;negate| (|x| $) (CONS (- (QCAR |x|)) (QCDR |x|))) 

(DEFUN |FLOAT;+;3$;75| (|x| |y| $)
  (SPADCALL (|FLOAT;plus| |x| |y| $) (QREFELT $ 48))) 

(DEFUN |FLOAT;-;3$;76| (|x| |y| $)
  (SPADCALL (|FLOAT;plus| |x| (|FLOAT;negate| |y| $) $) (QREFELT $ 48))) 

(DEFUN |FLOAT;sub| (|x| |y| $)
  (|FLOAT;plus| |x| (|FLOAT;negate| |y| $) $)) 

(DEFUN |FLOAT;plus| (|x| |y| $)
  (PROG (|de| |#G114| |#G115| |#G116| |#G117| |mx| |my| |ex| |ey| |mw|)
    (RETURN
      (SEQ (LETT |mx| (QCAR |x|) . #0=(|FLOAT;plus|))
           (LETT |my| (QCAR |y|) . #0#)
           (EXIT (COND
                   ((EQL |mx| 0) |y|)
                   ((EQL |my| 0) |x|)
                   (#1='T
                    (SEQ (LETT |ex| (QCDR |x|) . #0#)
                         (LETT |ey| (QCDR |y|) . #0#)
                         (EXIT (COND
                                 ((EQL |ex| |ey|)
                                  (CONS (+ |mx| |my|) |ex|))
                                 (#1#
                                  (SEQ (LETT |de|
                                        (-
                                         (-
                                          (+ |ex|
                                           (INTEGER-LENGTH |mx|))
                                          |ey|)
                                         (INTEGER-LENGTH |my|)) . #0#)
                                       (EXIT
                                        (COND
                                          ((<
                                            (+
                                             (SPADCALL (QREFELT $ 54))
                                             1)
                                            |de|)
                                           |x|)
                                          ((< |de|
                                            (-
                                             (+
                                              (SPADCALL (QREFELT $ 54))
                                              1)))
                                           |y|)
                                          ('T
                                           (SEQ
                                            (COND
                                              ((< |ex| |ey|)
                                               (PROGN
                                                 (LETT |#G114|
                                                  |my| . #0#)
                                                 (LETT |#G115|
                                                  |mx| . #0#)
                                                 (LETT |#G116|
                                                  |ey| . #0#)
                                                 (LETT |#G117|
                                                  |ex| . #0#)
                                                 (LETT |mx|
                                                  |#G114| . #0#)
                                                 (LETT |my|
                                                  |#G115| . #0#)
                                                 (LETT |ex|
                                                  |#G116| . #0#)
                                                 (LETT |ey|
                                                  |#G117| . #0#))))
                                            (LETT |mw|
                                             (+ |my|
                                              (|FLOAT;shift2| |mx|
                                               (- |ex| |ey|) $)) . #0#)
                                            (EXIT (CONS |mw| |ey|)))))))))))))))))) 

(DEFUN |FLOAT;*;3$;79| (|x| |y| $)
  (SPADCALL (|FLOAT;times| |x| |y| $) (QREFELT $ 48))) 

(DEFUN |FLOAT;*;I2$;80| (|x| |y| $)
  (COND
    ((< (SPADCALL (QREFELT $ 54)) (INTEGER-LENGTH |x|))
     (SPADCALL (SPADCALL (CONS |x| 0) (QREFELT $ 48)) |y|
         (QREFELT $ 60)))
    ('T (SPADCALL (CONS (* |x| (QCAR |y|)) (QCDR |y|)) (QREFELT $ 48))))) 

(DEFUN |FLOAT;/;3$;81| (|x| |y| $)
  (SPADCALL (|FLOAT;dvide| |x| |y| $) (QREFELT $ 48))) 

(DEFUN |FLOAT;/;$I$;82| (|x| |y| $)
  (COND
    ((< (SPADCALL (QREFELT $ 54)) (INTEGER-LENGTH |y|))
     (SPADCALL |x| (SPADCALL (CONS |y| 0) (QREFELT $ 48))
         (QREFELT $ 45)))
    ('T (SPADCALL |x| (CONS |y| 0) (QREFELT $ 45))))) 

(DEFUN |FLOAT;inv;2$;83| (|x| $)
  (SPADCALL (|spadConstant| $ 38) |x| (QREFELT $ 45))) 

(DEFUN |FLOAT;times| (|x| |y| $)
  (CONS (* (QCAR |x|) (QCAR |y|)) (+ (QCDR |x|) (QCDR |y|)))) 

(DEFUN |FLOAT;itimes| (|n| |y| $)
  (CONS (* |n| (QCAR |y|)) (QCDR |y|))) 

(DEFUN |FLOAT;dvide| (|x| |y| $)
  (PROG (|mw| |ew|)
    (RETURN
      (SEQ (LETT |ew|
                 (+ (+ (- (INTEGER-LENGTH (QCAR |y|))
                          (INTEGER-LENGTH (QCAR |x|)))
                       (SPADCALL (QREFELT $ 54)))
                    1)
                 . #0=(|FLOAT;dvide|))
           (LETT |mw|
                 (QUOTIENT2 (|FLOAT;shift2| (QCAR |x|) |ew| $)
                     (QCAR |y|)) . #0#)
           (LETT |ew| (- (- (QCDR |x|) (QCDR |y|)) |ew|) . #0#)
           (EXIT (CONS |mw| |ew|)))))) 

(DEFUN |FLOAT;square| (|x| |n| $)
  (PROG (|k| |l| |ma| |ex|)
    (RETURN
      (SEQ (LETT |ma| (QCAR |x|) . #0=(|FLOAT;square|))
           (LETT |ex| (QCDR |x|) . #0#)
           (SEQ (LETT |k| 1 . #0#) G190
                (COND ((QSGREATERP |k| |n|) (GO G191)))
                (SEQ (LETT |ma| (* |ma| |ma|) . #0#)
                     (LETT |ex| (+ |ex| |ex|) . #0#)
                     (LETT |l|
                           (- (SPADCALL (QREFELT $ 54))
                              (INTEGER-LENGTH |ma|)) . #0#)
                     (LETT |ma| (|FLOAT;shift2| |ma| |l| $) . #0#)
                     (EXIT (LETT |ex| (- |ex| |l|) . #0#)))
                (LETT |k| (QSADD1 |k|) . #0#) (GO G190) G191
                (EXIT NIL))
           (EXIT (CONS |ma| |ex|)))))) 

(DEFUN |FLOAT;power| (|x| |n| $)
  (PROG (|y| #0=#:G2217 |z|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |y| (|spadConstant| $ 38)
                            . #1=(|FLOAT;power|))
                      (LETT |z| |x| . #1#)
                      (EXIT (SEQ G190 NIL
                                 (SEQ (COND
                                        ((ODDP |n|)
                                         (LETT |y|
                                          (|FLOAT;chop|
                                           (|FLOAT;times| |y| |z| $)
                                           (SPADCALL (QREFELT $ 54)) $) . #1#)))
                                      (SEQ
                                       (LETT |n|
                                        (QUOTIENT2 |n| 2) . #1#)
                                       (EXIT
                                        (COND
                                          ((EQL |n| 0)
                                           (PROGN
                                             (LETT #0# |y| . #1#)
                                             (GO #0#))))))
                                      (EXIT
                                       (LETT |z|
                                        (|FLOAT;chop|
                                         (|FLOAT;times| |z| |z| $)
                                         (SPADCALL (QREFELT $ 54)) $) . #1#)))
                                 NIL (GO G190) G191 (EXIT NIL)))))
           #0# (EXIT #0#))))) 

(DEFUN |FLOAT;**;3$;89| (|x| |y| $)
  (PROG (|p| |r|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |x| (|spadConstant| $ 34) (QREFELT $ 39))
              (COND
                ((SPADCALL |y| (|spadConstant| $ 34) (QREFELT $ 39))
                 (|error| "0**0 is undefined"))
                ((SPADCALL |y| (|spadConstant| $ 34) (QREFELT $ 42))
                 (|error| "division by 0"))
                ((SPADCALL (|spadConstant| $ 34) |y| (QREFELT $ 42))
                 (|spadConstant| $ 34))))
             ((SPADCALL |y| (|spadConstant| $ 34) (QREFELT $ 39))
              (|spadConstant| $ 38))
             ((SPADCALL |y| (|spadConstant| $ 38) (QREFELT $ 39)) |x|)
             ((SPADCALL |x| (|spadConstant| $ 38) (QREFELT $ 39))
              (|spadConstant| $ 38))
             ('T
              (SEQ (LETT |p| (+ (ABS (SPADCALL |y| (QREFELT $ 58))) 5)
                         . #0=(|FLOAT;**;3$;89|))
                   (SPADCALL |p| (QREFELT $ 43))
                   (LETT |r|
                         (SPADCALL
                             (SPADCALL |y|
                                 (SPADCALL |x| (QREFELT $ 82))
                                 (QREFELT $ 60))
                             (QREFELT $ 78)) . #0#)
                   (SPADCALL |p| (QREFELT $ 47))
                   (EXIT (SPADCALL |r| (QREFELT $ 48)))))))))) 

(DEFUN |FLOAT;**;$F$;90| (|x| |r| $)
  (PROG (|n| |d| #0=#:G2227 |y|)
    (RETURN
      (SEQ (EXIT (COND
                   ((SPADCALL |x| (|spadConstant| $ 34) (QREFELT $ 39))
                    (COND
                      ((SPADCALL |r| (|spadConstant| $ 118)
                           (QREFELT $ 119))
                       (|error| "0**0 is undefined"))
                      ((SPADCALL |r| (|spadConstant| $ 118)
                           (QREFELT $ 120))
                       (|error| "division by 0"))
                      ((SPADCALL (|spadConstant| $ 118) |r|
                           (QREFELT $ 120))
                       (|spadConstant| $ 34))))
                   ((SPADCALL |r| (|spadConstant| $ 118)
                        (QREFELT $ 119))
                    (|spadConstant| $ 38))
                   ((SPADCALL |r| (|spadConstant| $ 121)
                        (QREFELT $ 119))
                    |x|)
                   ((SPADCALL |x| (|spadConstant| $ 38) (QREFELT $ 39))
                    (|spadConstant| $ 38))
                   ('T
                    (SEQ (LETT |n| (SPADCALL |r| (QREFELT $ 122))
                               . #1=(|FLOAT;**;$F$;90|))
                         (LETT |d|
                               (SPADCALL |r| (QREFELT $ 123)) . #1#)
                         (EXIT (COND
                                 ((SPADCALL |x| (QREFELT $ 35))
                                  (COND
                                    ((ODDP |d|)
                                     (COND
                                       ((ODDP |n|)
                                        (PROGN
                                          (LETT #0#
                                           (SPADCALL
                                            (SPADCALL
                                             (SPADCALL |x|
                                              (QREFELT $ 36))
                                             |r| (QREFELT $ 124))
                                            (QREFELT $ 36)) . #1#)
                                          (GO #0#)))
                                       ('T
                                        (PROGN
                                          (LETT #0#
                                           (SPADCALL
                                            (SPADCALL |x|
                                             (QREFELT $ 36))
                                            |r| (QREFELT $ 124)) . #1#)
                                          (GO #0#)))))
                                    ('T (|error| "negative root"))))
                                 ('T
                                  (SEQ (COND
                                         ((EQL |d| 2)
                                          (SEQ
                                           (SPADCALL
                                            (INTEGER-LENGTH |n|)
                                            (QREFELT $ 43))
                                           (LETT |y|
                                            (SPADCALL |x|
                                             (QREFELT $ 44)) . #1#)
                                           (LETT |y|
                                            (SPADCALL |y| |n|
                                             (QREFELT $ 87)) . #1#)
                                           (SPADCALL
                                            (INTEGER-LENGTH |n|)
                                            (QREFELT $ 47))
                                           (EXIT
                                            (PROGN
                                              (LETT #0#
                                               (SPADCALL |y|
                                                (QREFELT $ 48)) . #1#)
                                              (GO #0#))))))
                                       (LETT |y|
                                        (SPADCALL (CONS |n| 0)
                                         (CONS |d| 0) (QREFELT $ 45)) . #1#)
                                       (EXIT
                                        (SPADCALL |x| |y|
                                         (QREFELT $ 116)))))))))))
           #0# (EXIT #0#))))) 

(DEFUN |FLOAT;**;$I$;91| (|x| |n| $)
  (PROG (|p| |y|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |x| (|spadConstant| $ 34) (QREFELT $ 39))
              (COND
                ((EQL |n| 0) (|error| "0**0 is undefined"))
                ((< |n| 0) (|error| "division by 0"))
                ((< 0 |n|) (|spadConstant| $ 34))))
             ((EQL |n| 0) (|spadConstant| $ 38))
             ((EQL |n| 1) |x|)
             ((SPADCALL |x| (|spadConstant| $ 38) (QREFELT $ 39))
              (|spadConstant| $ 38))
             ('T
              (SEQ (LETT |p| (SPADCALL (QREFELT $ 54))
                         . #0=(|FLOAT;**;$I$;91|))
                   (SPADCALL (+ (+ |p| (INTEGER-LENGTH |n|)) 2)
                       (QREFELT $ 65))
                   (LETT |y| (|FLOAT;power| |x| (ABS |n|) $) . #0#)
                   (COND
                     ((< |n| 0)
                      (LETT |y|
                            (|FLOAT;dvide| (|spadConstant| $ 38) |y| $) . #0#)))
                   (SPADCALL |p| (QREFELT $ 65))
                   (EXIT (SPADCALL |y| (QREFELT $ 48)))))))))) 

(DEFUN |FLOAT;convert10| (|x| |d| $)
  (PROG (|m| |e| |#G147| |q| |b| #0=#:G2234 |r| |h|)
    (RETURN
      (SEQ (LETT |m| (QCAR |x|) . #1=(|FLOAT;convert10|))
           (LETT |e| (QCDR |x|) . #1#)
           (LETT |b| (SPADCALL (QREFELT $ 54)) . #1#)
           (PROGN
             (LETT |#G147| (DIVIDE2 (ABS |e|) |b|) . #1#)
             (LETT |q| (QCAR |#G147|) . #1#)
             (LETT |r| (QCDR |#G147|) . #1#)
             |#G147|)
           (LETT |b| (EXPT 2 |b|) . #1#)
           (LETT |r|
                 (EXPT 2
                       (PROG1 (LETT #0# |r| . #1#)
                         (|check-subtype| (>= #0# 0)
                             '(|NonNegativeInteger|) #0#))) . #1#)
           (LETT |h|
                 (|FLOAT;power10| (CONS |b| 0) |q| (+ |d| 5) $) . #1#)
           (LETT |h|
                 (|FLOAT;chop10| (CONS (* |r| (QCAR |h|)) (QCDR |h|))
                     (+ |d| 5) $) . #1#)
           (EXIT (COND
                   ((< |e| 0)
                    (LETT |h|
                          (|FLOAT;quotient10| (CONS |m| 0) |h| |d| $) . #1#))
                   ('T (|FLOAT;times10| (CONS |m| 0) |h| |d| $)))))))) 

(DEFUN |FLOAT;ceilLength10| (|n| $)
  (+ (QUOTIENT2 (* 146 (INTEGER-LENGTH |n|)) 485) 1)) 

(DEFUN |FLOAT;floorLength10| (|n| $)
  (QUOTIENT2 (* 643 (INTEGER-LENGTH |n|)) 2136)) 

(DEFUN |FLOAT;length10| (|n| $)
  (PROG (|ln| |upper| #0=#:G2241 |lower|)
    (RETURN
      (SEQ (LETT |ln|
                 (INTEGER-LENGTH
                     (LETT |n| (ABS |n|) . #1=(|FLOAT;length10|))) . #1#)
           (LETT |upper| (QUOTIENT2 (* 76573 |ln|) 254370) . #1#)
           (LETT |lower|
                 (QUOTIENT2 (SPADCALL 21306 (- |ln| 1) (QREFELT $ 59))
                     70777) . #1#)
           (EXIT (COND
                   ((EQL |upper| |lower|) (+ |upper| 1))
                   ('T
                    (SEQ (LETT |n|
                               (QUOTIENT2 |n|
                                   (EXPT 10
                                    (PROG1 (LETT #0# |lower| . #1#)
                                      (|check-subtype| (>= #0# 0)
                                       '(|NonNegativeInteger|) #0#)))) . #1#)
                         (SEQ G190
                              (COND
                                ((NULL (COND
                                         ((< |n| 10) 'NIL)
                                         ('T 'T)))
                                 (GO G191)))
                              (SEQ (LETT |n| (QUOTIENT2 |n| 10) . #1#)
                                   (EXIT
                                    (LETT |lower| (+ |lower| 1) . #1#)))
                              NIL (GO G190) G191 (EXIT NIL))
                         (EXIT (+ |lower| 1)))))))))) 

(DEFUN |FLOAT;chop10| (|x| |p| $)
  (PROG (|e| #0=#:G2249)
    (RETURN
      (SEQ (LETT |e| (- (|FLOAT;floorLength10| (QCAR |x|) $) |p|)
                 . #1=(|FLOAT;chop10|))
           (COND
             ((< 0 |e|)
              (LETT |x|
                    (CONS (QUOTIENT2 (QCAR |x|)
                              (EXPT 10
                                    (PROG1 (LETT #0# |e| . #1#)
                                      (|check-subtype| (>= #0# 0)
                                       '(|NonNegativeInteger|) #0#))))
                          (+ (QCDR |x|) |e|)) . #1#)))
           (EXIT |x|))))) 

(DEFUN |FLOAT;normalize10| (|x| |p| $)
  (PROG (|e| #0=#:G2254 |#G157| |r| #1=#:G2257 |ma| |ex|)
    (RETURN
      (SEQ (LETT |ma| (QCAR |x|) . #2=(|FLOAT;normalize10|))
           (LETT |ex| (QCDR |x|) . #2#)
           (LETT |e| (- (|FLOAT;length10| |ma| $) |p|) . #2#)
           (COND
             ((< 0 |e|)
              (SEQ (LETT |ma|
                         (QUOTIENT2 |ma|
                             (EXPT 10
                                   (PROG1 (LETT #0# (- |e| 1) . #2#)
                                     (|check-subtype| (>= #0# 0)
                                      '(|NonNegativeInteger|) #0#)))) . #2#)
                   (LETT |ex| (+ |ex| |e|) . #2#)
                   (PROGN
                     (LETT |#G157| (DIVIDE2 |ma| 10) . #2#)
                     (LETT |ma| (QCAR |#G157|) . #2#)
                     (LETT |r| (QCDR |#G157|) . #2#)
                     |#G157|)
                   (EXIT (COND
                           ((< 4 |r|)
                            (SEQ (LETT |ma| (+ |ma| 1) . #2#)
                                 (EXIT (COND
                                         ((EQL |ma|
                                           (EXPT 10
                                            (PROG1 (LETT #1# |p| . #2#)
                                              (|check-subtype|
                                               (>= #1# 0)
                                               '(|NonNegativeInteger|)
                                               #1#))))
                                          (SEQ (LETT |ma| 1 . #2#)
                                           (EXIT
                                            (LETT |ex|
                                             (+ |ex| |p|) . #2#)))))))))))))
           (EXIT (CONS |ma| |ex|)))))) 

(DEFUN |FLOAT;times10| (|x| |y| |p| $)
  (|FLOAT;normalize10| (|FLOAT;times| |x| |y| $) |p| $)) 

(DEFUN |FLOAT;quotient10| (|x| |y| |p| $)
  (PROG (#0=#:G2276 |mw| |ew|)
    (RETURN
      (SEQ (LETT |ew|
                 (+ (+ (- (|FLOAT;floorLength10| (QCAR |y|) $)
                          (|FLOAT;ceilLength10| (QCAR |x|) $))
                       |p|)
                    2)
                 . #1=(|FLOAT;quotient10|))
           (COND ((< |ew| 0) (LETT |ew| 0 . #1#)))
           (LETT |mw|
                 (QUOTIENT2
                     (* (QCAR |x|)
                        (EXPT 10
                              (PROG1 (LETT #0# |ew| . #1#)
                                (|check-subtype| (>= #0# 0)
                                    '(|NonNegativeInteger|) #0#))))
                     (QCAR |y|)) . #1#)
           (LETT |ew| (- (- (QCDR |x|) (QCDR |y|)) |ew|) . #1#)
           (EXIT (|FLOAT;normalize10| (CONS |mw| |ew|) |p| $)))))) 

(DEFUN |FLOAT;power10| (|x| |n| |d| $)
  (PROG (|p| |y| |e| #0=#:G2284 |z|)
    (RETURN
      (SEQ (EXIT (COND
                   ((SPADCALL |x| (|spadConstant| $ 34) (QREFELT $ 39))
                    (|spadConstant| $ 34))
                   ((EQL |n| 0) (|spadConstant| $ 38))
                   ((EQL |n| 1) |x|)
                   ((SPADCALL |x| (|spadConstant| $ 38) (QREFELT $ 39))
                    (|spadConstant| $ 38))
                   ('T
                    (SEQ (LETT |p| (+ (+ |d| (INTEGER-LENGTH |n|)) 1)
                               . #1=(|FLOAT;power10|))
                         (LETT |e| |n| . #1#)
                         (LETT |y| (|spadConstant| $ 38) . #1#)
                         (LETT |z| |x| . #1#)
                         (EXIT (SEQ G190 NIL
                                    (SEQ
                                     (COND
                                       ((ODDP |e|)
                                        (LETT |y|
                                         (|FLOAT;chop10|
                                          (|FLOAT;times| |y| |z| $) |p|
                                          $) . #1#)))
                                     (SEQ
                                      (LETT |e|
                                       (QUOTIENT2 |e| 2) . #1#)
                                      (EXIT
                                       (COND
                                         ((EQL |e| 0)
                                          (PROGN
                                            (LETT #0# |y| . #1#)
                                            (GO #0#))))))
                                     (EXIT
                                      (LETT |z|
                                       (|FLOAT;chop10|
                                        (|FLOAT;times| |z| |z| $) |p|
                                        $) . #1#)))
                                    NIL (GO G190) G191 (EXIT NIL)))))))
           #0# (EXIT #0#))))) 

(DEFUN |FLOAT;padFromLeft| (|s| $)
  (PROG (|n| #0=#:G2286 |t| |i| |j|)
    (RETURN
      (SEQ (COND
             ((ZEROP (SPADCALL (QREFELT $ 127) (QREFELT $ 134))) |s|)
             ('T
              (SEQ (LETT |n| (- (QCSIZE |s|) 1)
                         . #1=(|FLOAT;padFromLeft|))
                   (LETT |t|
                         (MAKE-FULL-CVEC
                             (PROG1 (LETT #0#
                                     (+ (+ |n| 1)
                                      (QUOTIENT2 |n|
                                       (SPADCALL (QREFELT $ 127)
                                        (QREFELT $ 134)))) . #1#)
                               (|check-subtype| (>= #0# 0)
                                   '(|NonNegativeInteger|) #0#))
                             (SPADCALL (QREFELT $ 136))) . #1#)
                   (SEQ (LETT |j| (SPADCALL |t| (QREFELT $ 137)) . #1#)
                        (LETT |i| 0 . #1#) G190
                        (COND ((QSGREATERP |i| |n|) (GO G191)))
                        (SEQ (SPADCALL |t| |j|
                                 (SPADCALL |s|
                                     (+ |i|
                                      (SPADCALL |s| (QREFELT $ 137)))
                                     (QREFELT $ 138))
                                 (QREFELT $ 139))
                             (EXIT (COND
                                     ((EQL
                                       (REMAINDER2 (+ |i| 1)
                                        (SPADCALL (QREFELT $ 127)
                                         (QREFELT $ 134)))
                                       0)
                                      (LETT |j| (+ |j| 1) . #1#)))))
                        (LETT |i|
                              (PROG1 (QSADD1 |i|)
                                (LETT |j| (+ |j| 1) . #1#)) . #1#)
                        (GO G190) G191 (EXIT NIL))
                   (EXIT |t|)))))))) 

(DEFUN |FLOAT;padFromRight| (|s| $)
  (PROG (|n| #0=#:G2293 |t| |i| |j|)
    (RETURN
      (SEQ (COND
             ((EQL (SPADCALL (QREFELT $ 127) (QREFELT $ 134)) 0) |s|)
             ('T
              (SEQ (LETT |n| (- (QCSIZE |s|) 1)
                         . #1=(|FLOAT;padFromRight|))
                   (LETT |t|
                         (MAKE-FULL-CVEC
                             (PROG1 (LETT #0#
                                     (+ (+ |n| 1)
                                      (QUOTIENT2 |n|
                                       (SPADCALL (QREFELT $ 127)
                                        (QREFELT $ 134)))) . #1#)
                               (|check-subtype| (>= #0# 0)
                                   '(|NonNegativeInteger|) #0#))
                             (SPADCALL (QREFELT $ 136))) . #1#)
                   (SEQ (LETT |j| (SPADCALL |t| (QREFELT $ 140)) . #1#)
                        (LETT |i| |n| . #1#) G190
                        (COND ((< |i| 0) (GO G191)))
                        (SEQ (SPADCALL |t| |j|
                                       (SPADCALL |s|
                                        (+ |i|
                                         (SPADCALL |s| (QREFELT $ 137)))
                                        (QREFELT $ 138))
                                       (QREFELT $ 139))
                             (EXIT (COND
                                     ((EQL
                                       (REMAINDER2 (+ (- |n| |i|) 1)
                                        (SPADCALL (QREFELT $ 127)
                                         (QREFELT $ 134)))
                                       0)
                                      (LETT |j| (- |j| 1) . #1#)))))
                        (LETT |i|
                              (PROG1 (+ |i| -1)
                                (LETT |j| (+ |j| -1) . #1#)) . #1#)
                        (GO G190) G191 (EXIT NIL))
                   (EXIT |t|)))))))) 

(DEFUN |FLOAT;fixed| (|f| $)
  (PROG (|d| |l| |g| |m| |e| |o| |p| #0=#:G2306 #1=#:G2308 |s| |n|
             #2=#:G2311 |t|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |f| (QREFELT $ 33)) "0.0")
             ((ZEROP (SPADCALL |f| (QREFELT $ 19)))
              (|FLOAT;padFromRight|
                  (STRCONC (STRINGIMAGE (SPADCALL |f| (QREFELT $ 17)))
                           ".0")
                  $))
             ((SPADCALL |f| (QREFELT $ 35))
              (STRCONC "-"
                       (|FLOAT;fixed| (SPADCALL |f| (QREFELT $ 51)) $)))
             ('T
              (SEQ (LETT |d|
                         (COND
                           ((EQL (SPADCALL (QREFELT $ 133)
                                     (QREFELT $ 141))
                                 -1)
                            (SPADCALL (QREFELT $ 99)))
                           ('T
                            (SPADCALL (QREFELT $ 133) (QREFELT $ 141))))
                         . #3=(|FLOAT;fixed|))
                   (LETT |g|
                         (|FLOAT;convert10|
                             (SPADCALL |f| (QREFELT $ 51)) |d| $) . #3#)
                   (LETT |m| (QCAR |g|) . #3#)
                   (LETT |e| (QCDR |g|) . #3#)
                   (COND
                     ((NULL (EQL (SPADCALL (QREFELT $ 133)
                                     (QREFELT $ 141))
                                 -1))
                      (SEQ (LETT |l| (|FLOAT;length10| |m| $) . #3#)
                           (EXIT (COND
                                   ((<
                                     (SPADCALL (QREFELT $ 133)
                                      (QREFELT $ 141))
                                     (- |e|))
                                    (COND
                                      ((< (- |e|)
                                        (SPADCALL 2
                                         (SPADCALL (QREFELT $ 99))
                                         (QREFELT $ 59)))
                                       (SEQ
                                        (LETT |g|
                                         (|FLOAT;normalize10| |g|
                                          (+ (+ |l| |e|)
                                           (SPADCALL (QREFELT $ 133)
                                            (QREFELT $ 141)))
                                          $) . #3#)
                                        (LETT |m| (QCAR |g|) . #3#)
                                        (EXIT
                                         (LETT |e| (QCDR |g|) . #3#)))))))))))
                   (LETT |s| (STRINGIMAGE |m|) . #3#)
                   (LETT |n| (QCSIZE |s|) . #3#)
                   (LETT |o| (+ |e| |n|) . #3#)
                   (LETT |p|
                         (COND
                           ((EQL (SPADCALL (QREFELT $ 133)
                                     (QREFELT $ 141))
                                 -1)
                            |n|)
                           ('T
                            (SPADCALL (QREFELT $ 133) (QREFELT $ 141)))) . #3#)
                   (COND
                     ((< |e| 0)
                      (COND
                        ((< 0 |o|)
                         (SEQ (LETT |t|
                                    (SPADCALL |s|
                                     (SPADCALL
                                      (+ |o|
                                       (SPADCALL |s| (QREFELT $ 137)))
                                      (-
                                       (+ |n|
                                        (SPADCALL |s| (QREFELT $ 137)))
                                       1)
                                      (QREFELT $ 143))
                                     (QREFELT $ 144)) . #3#)
                              (EXIT (LETT |s|
                                     (SPADCALL |s|
                                      (SPADCALL
                                       (SPADCALL |s| (QREFELT $ 137))
                                       (-
                                        (+ |o|
                                         (SPADCALL |s| (QREFELT $ 137)))
                                        1)
                                       (QREFELT $ 143))
                                      (QREFELT $ 144)) . #3#))))
                        ('T
                         (SEQ (LETT |t|
                                    (STRCONC
                                     (MAKE-FULL-CVEC
                                      (PROG1 (LETT #0# (- |o|) . #3#)
                                        (|check-subtype| (>= #0# 0)
                                         '(|NonNegativeInteger|) #0#))
                                      (SPADCALL "0" (QREFELT $ 145)))
                                     |s|) . #3#)
                              (EXIT (LETT |s| "0" . #3#))))))
                     ('T
                      (SEQ (LETT |s|
                                 (STRCONC |s|
                                          (MAKE-FULL-CVEC
                                           (PROG1 (LETT #1# |e| . #3#)
                                             (|check-subtype|
                                              (>= #1# 0)
                                              '(|NonNegativeInteger|)
                                              #1#))
                                           (SPADCALL "0"
                                            (QREFELT $ 145)))) . #3#)
                           (EXIT (LETT |t| "" . #3#)))))
                   (LETT |n| (QCSIZE |t|) . #3#)
                   (COND
                     ((EQL (SPADCALL (QREFELT $ 133) (QREFELT $ 141))
                           -1)
                      (SEQ (LETT |t|
                                 (SPADCALL |t|
                                     (SPADCALL "0" (QREFELT $ 145))
                                     (QREFELT $ 146)) . #3#)
                           (EXIT (COND
                                   ((EQUAL |t| "")
                                    (LETT |t| "0" . #3#))))))
                     ((< |p| |n|)
                      (LETT |t|
                            (SPADCALL |t|
                                (SPADCALL
                                    (SPADCALL |t| (QREFELT $ 137))
                                    (-
                                     (+ |p|
                                      (SPADCALL |t| (QREFELT $ 137)))
                                     1)
                                    (QREFELT $ 143))
                                (QREFELT $ 144)) . #3#))
                     ('T
                      (LETT |t|
                            (STRCONC |t|
                                     (MAKE-FULL-CVEC
                                      (PROG1
                                       (LETT #2# (- |p| |n|) . #3#)
                                        (|check-subtype| (>= #2# 0)
                                         '(|NonNegativeInteger|) #2#))
                                      (SPADCALL "0" (QREFELT $ 145)))) . #3#)))
                   (EXIT (STRCONC (|FLOAT;padFromRight| |s| $)
                                  (STRCONC "."
                                           (|FLOAT;padFromLeft| |t| $))))))))))) 

(DEFUN |FLOAT;floating| (|f| $)
  (PROG (|t| |d| |g| |m| |e| |n| |o| |s|)
    (RETURN
      (SEQ (COND
             ((SPADCALL |f| (QREFELT $ 33)) "0.0")
             ((SPADCALL |f| (QREFELT $ 35))
              (STRCONC "-"
                       (|FLOAT;floating| (SPADCALL |f| (QREFELT $ 51))
                           $)))
             ('T
              (SEQ (LETT |t|
                         (COND
                           ((ZEROP (SPADCALL (QREFELT $ 127)
                                    (QREFELT $ 134)))
                            "E")
                           ('T " E "))
                         . #0=(|FLOAT;floating|))
                   (EXIT (COND
                           ((ZEROP (SPADCALL |f| (QREFELT $ 19)))
                            (SEQ (LETT |s|
                                       (STRINGIMAGE
                                        (SPADCALL |f| (QREFELT $ 17))) . #0#)
                                 (EXIT (SPADCALL
                                        (LIST "0."
                                         (|FLOAT;padFromLeft| |s| $)
                                         |t|
                                         (STRINGIMAGE (QCSIZE |s|)))
                                        (QREFELT $ 148)))))
                           ('T
                            (SEQ (LETT |d|
                                       (COND
                                         ((EQL
                                           (SPADCALL (QREFELT $ 133)
                                            (QREFELT $ 141))
                                           -1)
                                          (SPADCALL (QREFELT $ 99)))
                                         ('T
                                          (SPADCALL (QREFELT $ 133)
                                           (QREFELT $ 141)))) . #0#)
                                 (LETT |g|
                                       (|FLOAT;convert10| |f| |d| $) . #0#)
                                 (LETT |m| (QCAR |g|) . #0#)
                                 (LETT |e| (QCDR |g|) . #0#)
                                 (LETT |s| (STRINGIMAGE |m|) . #0#)
                                 (LETT |n| (QCSIZE |s|) . #0#)
                                 (LETT |o| (+ |e| |n|) . #0#)
                                 (LETT |s|
                                       (|FLOAT;padFromLeft| |s| $) . #0#)
                                 (EXIT (SPADCALL
                                        (LIST "0." |s| |t|
                                         (STRINGIMAGE |o|))
                                        (QREFELT $ 148)))))))))))))) 

(DEFUN |FLOAT;general| (|f| $)
  (PROG (|d| #0=#:G2333 |g| |m| |e| |n| |o| #1=#:G2338 #2=#:G2340 |t|
             |s| #3=#:G2345)
    (RETURN
      (SEQ (COND
             ((SPADCALL |f| (QREFELT $ 33)) "0.0")
             ((SPADCALL |f| (QREFELT $ 35))
              (STRCONC "-"
                       (|FLOAT;general| (SPADCALL |f| (QREFELT $ 51))
                           $)))
             ('T
              (SEQ (LETT |d|
                         (COND
                           ((EQL (SPADCALL (QREFELT $ 133)
                                     (QREFELT $ 141))
                                 -1)
                            (SPADCALL (QREFELT $ 99)))
                           ('T
                            (SPADCALL (QREFELT $ 133) (QREFELT $ 141))))
                         . #4=(|FLOAT;general|))
                   (EXIT (COND
                           ((ZEROP (SPADCALL |f| (QREFELT $ 19)))
                            (SEQ (EXIT (SEQ (LETT |d| (+ |d| 1) . #4#)
                                        (LETT |s|
                                         (STRINGIMAGE
                                          (SPADCALL |f| (QREFELT $ 17))) . #4#)
                                        (COND
                                          ((NULL
                                            (EQL
                                             (SPADCALL (QREFELT $ 133)
                                              (QREFELT $ 141))
                                             -1))
                                           (SEQ
                                            (LETT |e|
                                             (QCSIZE |s|) . #4#)
                                            (EXIT
                                             (COND
                                               ((< |d| |e|)
                                                (PROGN
                                                  (LETT #0#
                                                   (SEQ
                                                    (LETT |t|
                                                     (COND
                                                       ((ZEROP
                                                         (SPADCALL
                                                          (QREFELT $
                                                           127)
                                                          (QREFELT $
                                                           134)))
                                                        "E")
                                                       ('T " E ")) . #4#)
                                                    (EXIT
                                                     (SPADCALL
                                                      (LIST "0."
                                                       (|FLOAT;padFromLeft|
                                                        |s| $)
                                                       |t|
                                                       (STRINGIMAGE
                                                        |e|))
                                                      (QREFELT $ 148)))) . #4#)
                                                  (GO #0#))))))))
                                        (EXIT
                                         (|FLOAT;padFromRight|
                                          (STRCONC |s| ".0") $))))
                                 #0# (EXIT #0#)))
                           ('T
                            (SEQ (LETT |g|
                                       (|FLOAT;convert10| |f| |d| $) . #4#)
                                 (LETT |m| (QCAR |g|) . #4#)
                                 (LETT |e| (QCDR |g|) . #4#)
                                 (LETT |s| (STRINGIMAGE |m|) . #4#)
                                 (LETT |n| (QCSIZE |s|) . #4#)
                                 (LETT |o| (+ |n| |e|) . #4#)
                                 (EXIT (COND
                                         ((< 0 |o|)
                                          (COND
                                            ((< (MAX |n| |d|) |o|)
                                             (COND
                                               ((OR (< 0 |o|)
                                                 (< |o| -5))
                                                (SEQ
                                                 (LETT |t|
                                                  (|FLOAT;padFromLeft|
                                                   (SPADCALL |s|
                                                    (SPADCALL "0"
                                                     (QREFELT $ 145))
                                                    (QREFELT $ 146))
                                                   $) . #4#)
                                                 (LETT |s|
                                                  (COND
                                                    ((ZEROP
                                                      (SPADCALL
                                                       (QREFELT $ 127)
                                                       (QREFELT $ 134)))
                                                     "E")
                                                    ('T " E ")) . #4#)
                                                 (EXIT
                                                  (SPADCALL
                                                   (LIST "0." |t| |s|
                                                    (STRINGIMAGE
                                                     (+ |e| |n|)))
                                                   (QREFELT $ 148)))))
                                               ('T
                                                (STRCONC "0."
                                                 (|FLOAT;padFromLeft|
                                                  (STRCONC
                                                   (MAKE-FULL-CVEC
                                                    (PROG1
                                                     (LETT #1#
                                                      (- |o|) . #4#)
                                                      (|check-subtype|
                                                       (>= #1# 0)
                                                       '(|NonNegativeInteger|)
                                                       #1#))
                                                    (SPADCALL "0"
                                                     (QREFELT $ 145)))
                                                   (SPADCALL |s|
                                                    (SPADCALL "0"
                                                     (QREFELT $ 145))
                                                    (QREFELT $ 146)))
                                                  $)))))
                                            ('T
                                             (SEQ
                                              (COND
                                                ((< |n| |o|)
                                                 (LETT |s|
                                                  (STRCONC |s|
                                                   (MAKE-FULL-CVEC
                                                    (PROG1
                                                     (LETT #2#
                                                      (- |o| |n|) . #4#)
                                                      (|check-subtype|
                                                       (>= #2# 0)
                                                       '(|NonNegativeInteger|)
                                                       #2#))
                                                    (SPADCALL "0"
                                                     (QREFELT $ 145)))) . #4#)))
                                              (LETT |t|
                                               (SPADCALL
                                                (SPADCALL |s|
                                                 (SPADCALL
                                                  (+ |o|
                                                   (SPADCALL |s|
                                                    (QREFELT $ 137)))
                                                  (-
                                                   (+ |n|
                                                    (SPADCALL |s|
                                                     (QREFELT $ 137)))
                                                   1)
                                                  (QREFELT $ 143))
                                                 (QREFELT $ 144))
                                                (SPADCALL "0"
                                                 (QREFELT $ 145))
                                                (QREFELT $ 146)) . #4#)
                                              (COND
                                                ((EQUAL |t| "")
                                                 (LETT |t| "0" . #4#))
                                                ('T
                                                 (LETT |t|
                                                  (|FLOAT;padFromLeft|
                                                   |t| $) . #4#)))
                                              (LETT |s|
                                               (|FLOAT;padFromRight|
                                                (SPADCALL |s|
                                                 (SPADCALL
                                                  (SPADCALL |s|
                                                   (QREFELT $ 137))
                                                  (-
                                                   (+ |o|
                                                    (SPADCALL |s|
                                                     (QREFELT $ 137)))
                                                   1)
                                                  (QREFELT $ 143))
                                                 (QREFELT $ 144))
                                                $) . #4#)
                                              (EXIT
                                               (STRCONC |s|
                                                (STRCONC "." |t|)))))))
                                         ((< |o| -5)
                                          (SEQ
                                           (LETT |t|
                                            (|FLOAT;padFromLeft|
                                             (SPADCALL |s|
                                              (SPADCALL "0"
                                               (QREFELT $ 145))
                                              (QREFELT $ 146))
                                             $) . #4#)
                                           (LETT |s|
                                            (COND
                                              ((ZEROP
                                                (SPADCALL
                                                 (QREFELT $ 127)
                                                 (QREFELT $ 134)))
                                               "E")
                                              ('T " E ")) . #4#)
                                           (EXIT
                                            (SPADCALL
                                             (LIST "0." |t| |s|
                                              (STRINGIMAGE (+ |e| |n|)))
                                             (QREFELT $ 148)))))
                                         ('T
                                          (STRCONC "0."
                                           (|FLOAT;padFromLeft|
                                            (STRCONC
                                             (MAKE-FULL-CVEC
                                              (PROG1
                                               (LETT #3# (- |o|) . #4#)
                                                (|check-subtype|
                                                 (>= #3# 0)
                                                 '(|NonNegativeInteger|)
                                                 #3#))
                                              (SPADCALL "0"
                                               (QREFELT $ 145)))
                                             (SPADCALL |s|
                                              (SPADCALL "0"
                                               (QREFELT $ 145))
                                              (QREFELT $ 146)))
                                            $)))))))))))))))) 

(DEFUN |FLOAT;outputSpacing;NniV;106| (|n| $)
  (SPADCALL (QREFELT $ 127) |n| (QREFELT $ 149))) 

(DEFUN |FLOAT;outputFixed;V;107| ($)
  (SEQ (SPADCALL (QREFELT $ 130) "fixed" (QREFELT $ 151))
       (EXIT (SPADCALL (QREFELT $ 133) -1 (QREFELT $ 152))))) 

(DEFUN |FLOAT;outputFixed;NniV;108| (|n| $)
  (SEQ (SPADCALL (QREFELT $ 130) "fixed" (QREFELT $ 151))
       (EXIT (SPADCALL (QREFELT $ 133) |n| (QREFELT $ 152))))) 

(DEFUN |FLOAT;outputGeneral;V;109| ($)
  (SEQ (SPADCALL (QREFELT $ 130) "general" (QREFELT $ 151))
       (EXIT (SPADCALL (QREFELT $ 133) -1 (QREFELT $ 152))))) 

(DEFUN |FLOAT;outputGeneral;NniV;110| (|n| $)
  (SEQ (SPADCALL (QREFELT $ 130) "general" (QREFELT $ 151))
       (EXIT (SPADCALL (QREFELT $ 133) |n| (QREFELT $ 152))))) 

(DEFUN |FLOAT;outputFloating;V;111| ($)
  (SEQ (SPADCALL (QREFELT $ 130) "floating" (QREFELT $ 151))
       (EXIT (SPADCALL (QREFELT $ 133) -1 (QREFELT $ 152))))) 

(DEFUN |FLOAT;outputFloating;NniV;112| (|n| $)
  (SEQ (SPADCALL (QREFELT $ 130) "floating" (QREFELT $ 151))
       (EXIT (SPADCALL (QREFELT $ 133) |n| (QREFELT $ 152))))) 

(DEFUN |FLOAT;convert;$S;113| (|f| $)
  (PROG (#0=#:G2366 |b| |s| #1=#:G2370)
    (RETURN
      (SEQ (LETT |b|
                 (SEQ (COND
                        ((EQL (SPADCALL (QREFELT $ 133)
                                  (QREFELT $ 141))
                              -1)
                         (COND
                           ((NULL (SPADCALL |f| (QREFELT $ 33)))
                            (EXIT (SPADCALL
                                      (PROG1
                                       (LETT #0#
                                        (INTEGER-LENGTH
                                         (ABS
                                          (SPADCALL |f| (QREFELT $ 17))))
                                        . #2=(|FLOAT;convert;$S;113|))
                                        (|check-subtype| (> #0# 0)
                                         '(|PositiveInteger|) #0#))
                                      (QREFELT $ 65)))))))
                      (EXIT 0)) . #2#)
           (LETT |s|
                 (COND
                   ((EQUAL (SPADCALL (QREFELT $ 130) (QREFELT $ 159))
                           "fixed")
                    (|FLOAT;fixed| |f| $))
                   ((EQUAL (SPADCALL (QREFELT $ 130) (QREFELT $ 159))
                           "floating")
                    (|FLOAT;floating| |f| $))
                   ((EQUAL (SPADCALL (QREFELT $ 130) (QREFELT $ 159))
                           "general")
                    (|FLOAT;general| |f| $))
                   (#3='T (MAKE-FULL-CVEC 0))) . #2#)
           (COND
             ((< 0 |b|)
              (SPADCALL
                  (PROG1 (LETT #1# |b| . #2#)
                    (|check-subtype| (> #1# 0) '(|PositiveInteger|)
                        #1#))
                  (QREFELT $ 65))))
           (EXIT (COND
                   ((EQUAL |s| (MAKE-FULL-CVEC 0))
                    (|error| "bad output mode"))
                   (#3# |s|))))))) 

(DEFUN |FLOAT;coerce;$Of;114| (|f| $)
  (COND
    ((SPADCALL |f| (|spadConstant| $ 34) (QREFELT $ 42))
     (SPADCALL (SPADCALL (SPADCALL |f| (QREFELT $ 36)) (QREFELT $ 162))
         (QREFELT $ 163)))
    ('T (SPADCALL (SPADCALL |f| (QREFELT $ 160)) (QREFELT $ 164))))) 

(DEFUN |FLOAT;convert;$If;115| (|f| $)
  (SPADCALL (LIST (SPADCALL (SPADCALL "float" (QREFELT $ 166))
                      (QREFELT $ 168))
                  (SPADCALL (SPADCALL |f| (QREFELT $ 17))
                      (QREFELT $ 169))
                  (SPADCALL (SPADCALL |f| (QREFELT $ 19))
                      (QREFELT $ 169))
                  (SPADCALL (SPADCALL (QREFELT $ 102)) (QREFELT $ 169)))
            (QREFELT $ 170))) 

(PUT '|FLOAT;convert;2$;116| '|SPADreplace| '(XLAM (|x|) |x|)) 

(DEFUN |FLOAT;convert;2$;116| (|x| $) |x|) 

(DEFUN |FLOAT;convert;$Df;117| (|x| $)
  (|makeSF| (QCAR |x|) (QCDR |x|))) 

(DEFUN |FLOAT;coerce;$Df;118| (|x| $) (SPADCALL |x| (QREFELT $ 175))) 

(DEFUN |FLOAT;convert;Df$;119| (|sf| $)
  (SPADCALL (SPADCALL |sf| (QREFELT $ 177))
      (SPADCALL |sf| (QREFELT $ 178)) (FLOAT-RADIX 0.0)
      (QREFELT $ 107))) 

(DEFUN |FLOAT;retract;$F;120| (|f| $)
  (PROG (#0=#:G2381)
    (RETURN
      (SPADCALL |f|
          (PROG1 (LETT #0# (- (SPADCALL (QREFELT $ 54)) 1)
                       |FLOAT;retract;$F;120|)
            (|check-subtype| (>= #0# 0) '(|NonNegativeInteger|) #0#))
          2 (QREFELT $ 180))))) 

(DEFUN |FLOAT;retractIfCan;$U;121| (|f| $)
  (PROG (#0=#:G2387)
    (RETURN
      (CONS 0
            (SPADCALL |f|
                (PROG1 (LETT #0# (- (SPADCALL (QREFELT $ 54)) 1)
                             |FLOAT;retractIfCan;$U;121|)
                  (|check-subtype| (>= #0# 0) '(|NonNegativeInteger|)
                      #0#))
                2 (QREFELT $ 180)))))) 

(DEFUN |FLOAT;retract;$I;122| (|f| $)
  (PROG (|n|)
    (RETURN
      (SEQ (LETT |n| (SPADCALL |f| (QREFELT $ 55))
                 |FLOAT;retract;$I;122|)
           (EXIT (COND
                   ((SPADCALL |f| (SPADCALL |n| (QREFELT $ 184))
                        (QREFELT $ 39))
                    |n|)
                   ('T (|error| "Not an integer")))))))) 

(DEFUN |FLOAT;retractIfCan;$U;123| (|f| $)
  (PROG (|n|)
    (RETURN
      (SEQ (LETT |n| (SPADCALL |f| (QREFELT $ 55))
                 |FLOAT;retractIfCan;$U;123|)
           (EXIT (COND
                   ((SPADCALL |f| (SPADCALL |n| (QREFELT $ 184))
                        (QREFELT $ 39))
                    (CONS 0 |n|))
                   ('T (CONS 1 "failed")))))))) 

(DEFUN |FLOAT;rationalApproximation;$NniF;124| (|f| |d| $)
  (SPADCALL |f| |d| 10 (QREFELT $ 180))) 

(DEFUN |FLOAT;rationalApproximation;$2NniF;125| (|f| |d| |b| $)
  (PROG (|nu| |ex| #0=#:G2406 #1=#:G2408 |de| |tol| |#G213| |q| |r|
              |p2| |q2| #2=#:G2415 |#G214| |#G215| |p0| |p1| |#G216|
              |#G217| |q0| |q1| |#G218| |#G219| |s| |t|)
    (RETURN
      (SEQ (EXIT (SEQ (LETT |nu| (QCAR |f|)
                            . #3=(|FLOAT;rationalApproximation;$2NniF;125|))
                      (LETT |ex| (QCDR |f|) . #3#)
                      (COND
                        ((NULL (< |ex| 0))
                         (PROGN
                           (LETT #2#
                                 (SPADCALL
                                     (* |nu|
                                      (EXPT 2
                                       (PROG1 (LETT #0# |ex| . #3#)
                                         (|check-subtype| (>= #0# 0)
                                          '(|NonNegativeInteger|) #0#))))
                                     1 (QREFELT $ 189)) . #3#)
                           (GO #2#))))
                      (LETT |de|
                            (EXPT 2
                                  (PROG1 (LETT #1# (- |ex|) . #3#)
                                    (|check-subtype| (>= #1# 0)
                                     '(|NonNegativeInteger|) #1#))) . #3#)
                      (COND ((< |b| 2) (|error| "base must be > 1")))
                      (LETT |tol| (EXPT |b| |d|) . #3#)
                      (LETT |s| |nu| . #3#) (LETT |t| |de| . #3#)
                      (LETT |p0| 0 . #3#) (LETT |p1| 1 . #3#)
                      (LETT |q0| 1 . #3#) (LETT |q1| 0 . #3#)
                      (EXIT (SEQ G190 NIL
                                 (SEQ (PROGN
                                        (LETT |#G213|
                                         (DIVIDE2 |s| |t|) . #3#)
                                        (LETT |q| (QCAR |#G213|) . #3#)
                                        (LETT |r| (QCDR |#G213|) . #3#)
                                        |#G213|)
                                      (LETT |p2|
                                       (+ (* |q| |p1|) |p0|) . #3#)
                                      (LETT |q2|
                                       (+ (* |q| |q1|) |q0|) . #3#)
                                      (COND
                                        ((OR (EQL |r| 0)
                                          (<
                                           (SPADCALL |tol|
                                            (ABS
                                             (- (* |nu| |q2|)
                                              (SPADCALL |de| |p2|
                                               (QREFELT $ 59))))
                                            (QREFELT $ 75))
                                           (SPADCALL |de| (ABS |p2|)
                                            (QREFELT $ 59))))
                                         (PROGN
                                           (LETT #2#
                                            (SPADCALL |p2| |q2|
                                             (QREFELT $ 189)) . #3#)
                                           (GO #2#))))
                                      (PROGN
                                        (LETT |#G214| |p1| . #3#)
                                        (LETT |#G215| |p2| . #3#)
                                        (LETT |p0| |#G214| . #3#)
                                        (LETT |p1| |#G215| . #3#))
                                      (PROGN
                                        (LETT |#G216| |q1| . #3#)
                                        (LETT |#G217| |q2| . #3#)
                                        (LETT |q0| |#G216| . #3#)
                                        (LETT |q1| |#G217| . #3#))
                                      (EXIT
                                       (PROGN
                                         (LETT |#G218| |t| . #3#)
                                         (LETT |#G219| |r| . #3#)
                                         (LETT |s| |#G218| . #3#)
                                         (LETT |t| |#G219| . #3#))))
                                 NIL (GO G190) G191 (EXIT NIL)))))
           #2# (EXIT #2#))))) 

(DEFUN |Float| ()
  (PROG ()
    (RETURN
      (PROG (#0=#:G2428)
        (RETURN
          (COND
            ((LETT #0# (HGET |$ConstructorCache| '|Float|)
                   . #1=(|Float|))
             (|CDRwithIncrement| (CDAR #0#)))
            ('T
             (UNWIND-PROTECT
               (PROG1 (CDDAR (HPUT |$ConstructorCache| '|Float|
                                   (LIST
                                    (CONS NIL (CONS 1 (|Float;|))))))
                 (LETT #0# T . #1#))
               (COND ((NOT #0#) (HREM |$ConstructorCache| '|Float|))))))))))) 

(DEFUN |Float;| ()
  (PROG (|dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT |dv$| '(|Float|) . #0=(|Float|))
        (LETT $ (GETREFV 202) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
        (|haddProp| |$ConstructorCache| '|Float| NIL (CONS 1 $))
        (|stuffDomainSlots| $)
        (AND (|HasCategory| $ '(|arbitraryPrecision|))
             (|augmentPredVector| $ 1))
        (AND (|not| (|HasCategory| $ '(|arbitraryExponent|)))
             (|not| (|HasCategory| $ '(|arbitraryPrecision|)))
             (|augmentPredVector| $ 2))
        (QSETREFV $ 9 (SPADCALL 68 (QREFELT $ 8)))
        (QSETREFV $ 10
            (|Record| (|:| |mantissa| (|Integer|))
                (|:| |exponent| (|Integer|))))
        (QSETREFV $ 71 (CONS 1 (CONS 1 2)))
        (QSETREFV $ 88 (CONS 1 (|spadConstant| $ 38)))
        (QSETREFV $ 89 (CONS 1 (CONS 1 1)))
        (QSETREFV $ 94 (CONS 1 (CONS 1 1)))
        (QSETREFV $ 127 (SPADCALL 10 (QREFELT $ 126)))
        (QSETREFV $ 130 (SPADCALL "general" (QREFELT $ 129)))
        (QSETREFV $ 133 (SPADCALL -1 (QREFELT $ 132)))
        $)))) 

(MAKEPROP '|Float| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL (|PositiveInteger|)
             (|Reference| 6) (0 . |ref|) 'BITS '|Rep| (|Void|)
             (|OpenMathDevice|) (5 . |OMputApp|) (|String|)
             (10 . |OMputSymbol|) (|Integer|) |FLOAT;mantissa;$I;51|
             (17 . |OMputInteger|) |FLOAT;exponent;$I;52|
             (23 . |OMputEndApp|) (|OpenMathEncoding|)
             (28 . |OMencodingXML|) (32 . |OMopenString|)
             (38 . |OMputObject|) (43 . |OMputEndObject|)
             (48 . |OMclose|) |FLOAT;OMwrite;$S;2| (|Boolean|)
             |FLOAT;OMwrite;$BS;3| |FLOAT;OMwrite;Omd$V;4|
             |FLOAT;OMwrite;Omd$BV;5| (53 . |sign|) |FLOAT;zero?;$B;54|
             (CONS IDENTITY
                   (FUNCALL (|dispatchFunction| |FLOAT;Zero;$;48|) $))
             |FLOAT;negative?;$B;55| |FLOAT;-;2$;73| |FLOAT;asin;2$;7|
             (CONS IDENTITY
                   (FUNCALL (|dispatchFunction| |FLOAT;One;$;49|) $))
             |FLOAT;=;2$B;62| |FLOAT;pi;$;18| |FLOAT;/;$I$;82|
             |FLOAT;<;2$B;63| |FLOAT;increasePrecision;IPi;41|
             |FLOAT;sqrt;2$;36| |FLOAT;/;3$;81| |FLOAT;atan;2$;10|
             |FLOAT;decreasePrecision;IPi;42| |FLOAT;normalize;2$;60|
             |FLOAT;acos;2$;8| |FLOAT;-;3$;76| |FLOAT;abs;2$;64|
             |FLOAT;atan;3$;9| (58 . |fractionPart|) |FLOAT;bits;Pi;37|
             |FLOAT;wholePart;$I;66| (|IntegerRoots| 16)
             (63 . |approxSqrt|) |FLOAT;order;$I;46| (68 . *)
             |FLOAT;*;3$;79| |FLOAT;+;3$;75| |FLOAT;shift;$I$;61|
             |FLOAT;sign;$I;69| (74 . *) |FLOAT;bits;2Pi;38| (80 . **)
             |FLOAT;*;I2$;80| |FLOAT;sin;2$;13| |FLOAT;cos;2$;15|
             |FLOAT;tan;2$;17| 'P |FLOAT;precision;Pi;39| (86 . **)
             (|NonNegativeInteger|) (92 . *) (98 . *) (104 . **)
             |FLOAT;exp;2$;32| |FLOAT;sinh;2$;20| |FLOAT;cosh;2$;21|
             |FLOAT;tanh;2$;22| |FLOAT;log;2$;26| |FLOAT;asinh;2$;23|
             |FLOAT;acosh;2$;24| |FLOAT;atanh;2$;25| |FLOAT;log2;$;28|
             |FLOAT;**;$I$;91| 'L2 'L10 |FLOAT;log10;$;29|
             |FLOAT;log2;2$;30| |FLOAT;log10;2$;31| |FLOAT;exp1;$;35|
             'E (110 . |elt|) (115 . |setelt|) |FLOAT;precision;2Pi;40|
             (121 . |max|) |FLOAT;digits;Pi;44| |FLOAT;digits;2Pi;45|
             |FLOAT;relerror;2$I;47| |FLOAT;base;Pi;50|
             |FLOAT;one?;$B;53| (125 . |positive?|)
             |FLOAT;positive?;$B;56| |FLOAT;float;2I$;58|
             |FLOAT;float;2IPi$;59| |FLOAT;floor;2$;67|
             |FLOAT;truncate;2$;70| |FLOAT;ceiling;2$;65|
             |FLOAT;round;2$;68| (|Union| $ '"failed")
             |FLOAT;recip;$U;71| |FLOAT;differentiate;2$;72|
             |FLOAT;inv;2$;83| |FLOAT;**;3$;89| (|Fraction| 16)
             (130 . |Zero|) (134 . =) (140 . <) (146 . |One|)
             (150 . |numer|) (155 . |denom|) |FLOAT;**;$F$;90|
             (|Reference| 74) (160 . |ref|) 'SPACING (|Reference| 14)
             (165 . |ref|) 'OUTMODE (|Reference| 16) (170 . |ref|)
             'OUTPREC (175 . |elt|) (|Character|) (180 . |space|)
             (184 . |minIndex|) (189 . |elt|) (195 . |setelt|)
             (202 . |maxIndex|) (207 . |elt|) (|UniversalSegment| 16)
             (212 . SEGMENT) (218 . |elt|) (224 . |char|)
             (229 . |rightTrim|) (|List| $) (235 . |concat|)
             (240 . |setelt|) |FLOAT;outputSpacing;NniV;106|
             (246 . |setelt|) (252 . |setelt|)
             |FLOAT;outputFixed;V;107| |FLOAT;outputFixed;NniV;108|
             |FLOAT;outputGeneral;V;109| |FLOAT;outputGeneral;NniV;110|
             |FLOAT;outputFloating;V;111|
             |FLOAT;outputFloating;NniV;112| (258 . |elt|)
             |FLOAT;convert;$S;113| (|OutputForm|)
             |FLOAT;coerce;$Of;114| (263 . -) (268 . |message|)
             (|Symbol|) (273 . |coerce|) (|InputForm|)
             (278 . |convert|) (283 . |convert|) (288 . |convert|)
             |FLOAT;convert;$If;115| (|Float|) |FLOAT;convert;2$;116|
             (|DoubleFloat|) |FLOAT;convert;$Df;117|
             |FLOAT;coerce;$Df;118| (293 . |mantissa|)
             (298 . |exponent|) |FLOAT;convert;Df$;119|
             |FLOAT;rationalApproximation;$2NniF;125|
             |FLOAT;retract;$F;120| (|Union| 117 '"failed")
             |FLOAT;retractIfCan;$U;121| (303 . |coerce|)
             |FLOAT;retract;$I;122| (|Union| 16 '"failed")
             |FLOAT;retractIfCan;$U;123|
             |FLOAT;rationalApproximation;$NniF;124| (308 . /)
             (|PatternMatchResult| 172 $) (|Pattern| 172)
             (|Factored| $) (|Record| (|:| |coef1| $) (|:| |coef2| $))
             (|Union| 193 '"failed") (|Union| 147 '"failed")
             (|Record| (|:| |coef1| $) (|:| |coef2| $)
                 (|:| |generator| $))
             (|Record| (|:| |quotient| $) (|:| |remainder| $))
             (|Record| (|:| |coef| 147) (|:| |generator| $))
             (|SparseUnivariatePolynomial| $)
             (|Record| (|:| |unit| $) (|:| |canonical| $)
                 (|:| |associate| $))
             (|SingleInteger|))
          '#(~= 314 |zero?| 320 |wholePart| 325 |unitNormal| 330
             |unitCanonical| 335 |unit?| 340 |truncate| 345 |tanh| 350
             |tan| 355 |subtractIfCan| 360 |squareFreePart| 366
             |squareFree| 371 |sqrt| 376 |sizeLess?| 381 |sinh| 387
             |sin| 392 |sign| 397 |shift| 402 |sech| 408 |sec| 413
             |sample| 418 |round| 422 |retractIfCan| 427 |retract| 437
             |rem| 447 |relerror| 453 |recip| 459
             |rationalApproximation| 464 |quo| 477 |principalIdeal| 483
             |prime?| 488 |precision| 493 |positive?| 502 |pi| 507
             |patternMatch| 511 |outputSpacing| 518 |outputGeneral| 523
             |outputFloating| 532 |outputFixed| 541 |order| 550 |one?|
             555 |nthRoot| 560 |normalize| 566 |norm| 571 |negative?|
             576 |multiEuclidean| 581 |min| 587 |max| 597 |mantissa|
             607 |log2| 612 |log10| 621 |log| 630 |lcm| 635 |latex| 646
             |inv| 651 |increasePrecision| 656 |hash| 661
             |gcdPolynomial| 666 |gcd| 672 |fractionPart| 683 |floor|
             688 |float| 693 |factor| 706 |extendedEuclidean| 711
             |exquo| 724 |expressIdealMember| 730 |exponent| 736 |exp1|
             741 |exp| 745 |euclideanSize| 750 |divide| 755 |digits|
             761 |differentiate| 770 |decreasePrecision| 781 |csch| 786
             |csc| 791 |coth| 796 |cot| 801 |cosh| 806 |cos| 811
             |convert| 816 |coerce| 846 |characteristic| 881 |ceiling|
             885 |bits| 890 |base| 899 |atanh| 903 |atan| 908
             |associates?| 919 |asinh| 925 |asin| 930 |asech| 935
             |asec| 940 |acsch| 945 |acsc| 950 |acoth| 955 |acot| 960
             |acosh| 965 |acos| 970 |abs| 975 ^ 980 |Zero| 998 |One|
             1002 |OMwrite| 1006 D 1030 >= 1041 > 1047 = 1053 <= 1059 <
             1065 / 1071 - 1083 + 1094 ** 1100 * 1130)
          'NIL
          (CONS (|makeByteWordVec2| 1
                    '(0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
                      0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
                      0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0))
                (CONS '#(|FloatingPointSystem&| |RealNumberSystem&|
                         |Field&| |EuclideanDomain&| NIL
                         |UniqueFactorizationDomain&| |GcdDomain&|
                         |DivisionRing&| |IntegralDomain&| |Algebra&|
                         |Algebra&| |DifferentialRing&| NIL
                         |OrderedRing&| |Module&| NIL NIL |Module&| NIL
                         NIL |Ring&| NIL NIL NIL NIL NIL NIL NIL
                         |AbelianGroup&| NIL NIL NIL NIL
                         |AbelianMonoid&| |Monoid&| NIL NIL
                         |OrderedSet&| |SemiGroup&| |AbelianSemiGroup&|
                         |TranscendentalFunctionCategory&| NIL
                         |SetCategory&| NIL NIL NIL
                         |ElementaryFunctionCategory&| NIL
                         |HyperbolicFunctionCategory&|
                         |ArcTrigonometricFunctionCategory&|
                         |TrigonometricFunctionCategory&| NIL NIL NIL
                         NIL NIL |RadicalCategory&| |RetractableTo&|
                         |RetractableTo&| NIL NIL NIL NIL NIL NIL NIL
                         |BasicType&| NIL)
                      (CONS '#((|FloatingPointSystem|)
                               (|RealNumberSystem|) (|Field|)
                               (|EuclideanDomain|)
                               (|PrincipalIdealDomain|)
                               (|UniqueFactorizationDomain|)
                               (|GcdDomain|) (|DivisionRing|)
                               (|IntegralDomain|) (|Algebra| 117)
                               (|Algebra| $$) (|DifferentialRing|)
                               (|CharacteristicZero|) (|OrderedRing|)
                               (|Module| 117) (|EntireRing|)
                               (|CommutativeRing|) (|Module| $$)
                               (|BiModule| 117 117) (|BiModule| $$ $$)
                               (|Ring|) (|OrderedAbelianGroup|)
                               (|RightModule| 117) (|LeftModule| 117)
                               (|LeftModule| $$) (|Rng|)
                               (|RightModule| $$)
                               (|OrderedCancellationAbelianMonoid|)
                               (|AbelianGroup|)
                               (|OrderedAbelianMonoid|)
                               (|CancellationAbelianMonoid|)
                               (|SemiRing|) (|OrderedAbelianSemiGroup|)
                               (|AbelianMonoid|) (|Monoid|) (|SemiRng|)
                               (|PatternMatchable| 172) (|OrderedSet|)
                               (|SemiGroup|) (|AbelianSemiGroup|)
                               (|TranscendentalFunctionCategory|)
                               (|RealConstant|) (|SetCategory|)
                               (|arbitraryExponent|)
                               (|arbitraryPrecision|)
                               (|ConvertibleTo| 167)
                               (|ElementaryFunctionCategory|)
                               (|ArcHyperbolicFunctionCategory|)
                               (|HyperbolicFunctionCategory|)
                               (|ArcTrigonometricFunctionCategory|)
                               (|TrigonometricFunctionCategory|)
                               (|CoercibleTo| 174) (|OpenMath|)
                               (|ConvertibleTo| 14) (|Approximate|)
                               (|ConvertibleTo| 191)
                               (|RadicalCategory|)
                               (|RetractableTo| 117)
                               (|RetractableTo| 16)
                               (|ConvertibleTo| 172)
                               (|ConvertibleTo| 174)
                               (|canonicalsClosed|)
                               (|canonicalUnitNormal|)
                               (|noZeroDivisors|) (|CommutativeStar|)
                               (|unitsKnown|) (|BasicType|)
                               (|CoercibleTo| 161))
                            (|makeByteWordVec2| 201
                                '(1 7 0 6 8 1 12 11 0 13 3 12 11 0 14
                                  14 15 2 12 11 0 16 18 1 12 11 0 20 0
                                  21 0 22 2 12 0 14 21 23 1 12 11 0 24
                                  1 12 11 0 25 1 12 11 0 26 1 16 16 0
                                  32 1 0 0 0 53 1 56 16 16 57 2 16 0 6
                                  0 59 2 0 0 6 0 64 2 0 0 0 6 66 2 6 0
                                  0 6 73 2 16 0 74 0 75 2 74 0 6 0 76 2
                                  74 0 0 6 77 1 7 6 0 95 2 7 6 0 6 96 0
                                  0 0 98 1 16 28 0 104 0 117 0 118 2
                                  117 28 0 0 119 2 117 28 0 0 120 0 117
                                  0 121 1 117 16 0 122 1 117 16 0 123 1
                                  125 0 74 126 1 128 0 14 129 1 131 0
                                  16 132 1 125 74 0 134 0 135 0 136 1
                                  14 16 0 137 2 14 135 0 16 138 3 14
                                  135 0 16 135 139 1 14 16 0 140 1 131
                                  16 0 141 2 142 0 16 16 143 2 14 0 0
                                  142 144 1 135 0 14 145 2 14 0 0 135
                                  146 1 14 0 147 148 2 125 74 0 74 149
                                  2 128 14 0 14 151 2 131 16 0 16 152 1
                                  128 14 0 159 1 161 0 0 163 1 161 0 14
                                  164 1 165 0 14 166 1 167 0 165 168 1
                                  16 167 0 169 1 167 0 147 170 1 174 16
                                  0 177 1 174 16 0 178 1 0 0 16 184 2
                                  117 0 16 16 189 2 0 28 0 0 1 1 0 28 0
                                  33 1 0 16 0 55 1 0 200 0 1 1 0 0 0 1
                                  1 0 28 0 1 1 0 0 0 109 1 0 0 0 81 1 0
                                  0 0 70 2 0 112 0 0 1 1 0 0 0 1 1 0
                                  192 0 1 1 0 0 0 44 2 0 28 0 0 1 1 0 0
                                  0 79 1 0 0 0 68 1 0 16 0 63 2 0 0 0
                                  16 62 1 0 0 0 1 1 0 0 0 1 0 0 0 1 1 0
                                  0 0 111 1 0 182 0 183 1 0 186 0 187 1
                                  0 117 0 181 1 0 16 0 185 2 0 0 0 0 1
                                  2 0 16 0 0 101 1 0 112 0 113 3 0 117
                                  0 74 74 180 2 0 117 0 74 188 2 0 0 0
                                  0 1 1 0 198 147 1 1 0 28 0 1 1 1 6 6
                                  97 0 0 6 72 1 0 28 0 105 0 0 0 40 3 0
                                  190 0 191 190 1 1 0 11 74 150 1 0 11
                                  74 156 0 0 11 155 0 0 11 157 1 0 11
                                  74 158 0 0 11 153 1 0 11 74 154 1 0
                                  16 0 58 1 0 28 0 103 2 0 0 0 16 1 1 0
                                  0 0 48 1 0 0 0 1 1 0 28 0 35 2 0 195
                                  147 0 1 0 2 0 1 2 0 0 0 0 1 0 2 0 98
                                  2 0 0 0 0 1 1 0 16 0 17 1 0 0 0 91 0
                                  0 0 86 1 0 0 0 92 0 0 0 90 1 0 0 0 82
                                  1 0 0 147 1 2 0 0 0 0 1 1 0 14 0 1 1
                                  0 0 0 115 1 1 6 16 43 1 0 201 0 1 2 0
                                  199 199 199 1 2 0 0 0 0 1 1 0 0 147 1
                                  1 0 0 0 53 1 0 0 0 108 2 0 0 16 16
                                  106 3 0 0 16 16 6 107 1 0 192 0 1 3 0
                                  194 0 0 0 1 2 0 196 0 0 1 2 0 112 0 0
                                  1 2 0 195 147 0 1 1 0 16 0 19 0 0 0
                                  93 1 0 0 0 78 1 0 74 0 1 2 0 197 0 0
                                  1 1 1 6 6 100 0 0 6 99 1 0 0 0 114 2
                                  0 0 0 74 1 1 1 6 16 47 1 0 0 0 1 1 0
                                  0 0 1 1 0 0 0 1 1 0 0 0 1 1 0 0 0 80
                                  1 0 0 0 69 1 0 0 174 179 1 0 167 0
                                  171 1 0 14 0 160 1 0 191 0 1 1 0 174
                                  0 175 1 0 172 0 173 1 0 174 0 176 1 0
                                  0 117 1 1 0 0 16 184 1 0 0 117 1 1 0
                                  0 16 184 1 0 0 0 1 1 0 161 0 162 0 0
                                  74 1 1 0 0 0 110 1 1 6 6 65 0 0 6 54
                                  0 0 6 102 1 0 0 0 85 2 0 0 0 0 52 1 0
                                  0 0 46 2 0 28 0 0 1 1 0 0 0 83 1 0 0
                                  0 37 1 0 0 0 1 1 0 0 0 1 1 0 0 0 1 1
                                  0 0 0 1 1 0 0 0 1 1 0 0 0 1 1 0 0 0
                                  84 1 0 0 0 49 1 0 0 0 51 2 0 0 0 16 1
                                  2 0 0 0 74 1 2 0 0 0 6 1 0 0 0 34 0 0
                                  0 38 2 0 11 12 0 30 3 0 11 12 0 28 31
                                  2 0 14 0 28 29 1 0 14 0 27 1 0 0 0 1
                                  2 0 0 0 74 1 2 0 28 0 0 1 2 0 28 0 0
                                  1 2 0 28 0 0 39 2 0 28 0 0 1 2 0 28 0
                                  0 42 2 0 0 0 16 41 2 0 0 0 0 45 2 0 0
                                  0 0 50 1 0 0 0 36 2 0 0 0 0 61 2 0 0
                                  0 0 116 2 0 0 0 117 124 2 0 0 0 16 87
                                  2 0 0 0 74 1 2 0 0 0 6 66 2 0 0 117 0
                                  1 2 0 0 0 117 1 2 0 0 16 0 67 2 0 0 0
                                  0 60 2 0 0 74 0 1 2 0 0 6 0 64)))))
          '|lookupComplete|)) 

(MAKEPROP '|Float| 'NILADIC T) 
