
(/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 (|s| |dev| |sp|)
    (RETURN
     (SEQ (LETT |s| "" . #1=(|FLOAT;OMwrite;$S;2|))
          (LETT |sp| (OM-STRINGTOSTRINGPTR |s|) . #1#)
          (LETT |dev| (SPADCALL |sp| (SPADCALL (QREFELT $ 22)) (QREFELT $ 23))
                . #1#)
          (SPADCALL |dev| (QREFELT $ 24)) (|FLOAT;writeOMFloat| |dev| |x| $)
          (SPADCALL |dev| (QREFELT $ 25)) (SPADCALL |dev| (QREFELT $ 26))
          (LETT |s| (OM-STRINGPTRTOSTRING |sp|) . #1#) (EXIT |s|))))) 

(DEFUN |FLOAT;OMwrite;$BS;3| (|x| |wholeObj| $)
  (PROG (|s| |dev| |sp|)
    (RETURN
     (SEQ (LETT |s| "" . #1=(|FLOAT;OMwrite;$BS;3|))
          (LETT |sp| (OM-STRINGTOSTRINGPTR |s|) . #1#)
          (LETT |dev| (SPADCALL |sp| (SPADCALL (QREFELT $ 22)) (QREFELT $ 23))
                . #1#)
          (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|) . #1#) (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))
                   . #1=(|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))
                   . #1#)
             (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)))
         (#1='T (|spadConstant| $ 34))))
       (#1#
        (SEQ
         (LETT |theta|
               (SPADCALL
                (SPADCALL (SPADCALL |y| |x| (QREFELT $ 45)) (QREFELT $ 51))
                (QREFELT $ 46))
               . #2=(|FLOAT;atan;3$;9|))
         (COND
          ((SPADCALL |x| (|spadConstant| $ 34) (QREFELT $ 42))
           (LETT |theta|
                 (SPADCALL (SPADCALL (QREFELT $ 40)) |theta| (QREFELT $ 50))
                 . #2#)))
         (COND
          ((SPADCALL |y| (|spadConstant| $ 34) (QREFELT $ 42))
           (LETT |theta| (SPADCALL |theta| (QREFELT $ 36)) . #2#)))
         (EXIT |theta|)))))))) 

(DEFUN |FLOAT;atan;2$;10| (|x| $)
  (PROG (|t| |i| |k| #1=#:G790 |r|)
    (RETURN
     (SEQ
      (EXIT
       (COND ((SPADCALL |x| (QREFELT $ 33)) (|spadConstant| $ 34))
             ((SPADCALL |x| (QREFELT $ 35))
              (SPADCALL (SPADCALL (SPADCALL |x| (QREFELT $ 36)) (QREFELT $ 46))
                        (QREFELT $ 36)))
             (#2='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)) $))
                               (#2#
                                (SPADCALL
                                 (SPADCALL (|spadConstant| $ 38) |x|
                                           (QREFELT $ 45))
                                 (QREFELT $ 46)))))
                             (#2#
                              (SPADCALL
                               (SPADCALL (|spadConstant| $ 38) |x|
                                         (QREFELT $ 45))
                               (QREFELT $ 46))))
                            . #3=(|FLOAT;atan;2$;10|))
                      (LETT |r|
                            (SPADCALL
                             (SPADCALL (SPADCALL (QREFELT $ 40)) 2
                                       (QREFELT $ 41))
                             |r| (QREFELT $ 50))
                            . #3#)
                      (SPADCALL 4 (QREFELT $ 47))
                      (EXIT
                       (PROGN
                        (LETT #1# (SPADCALL |r| (QREFELT $ 48)) . #3#)
                        (GO #1#))))))
               (LETT |k|
                     (QUOTIENT2
                      (SPADCALL (- (SPADCALL (QREFELT $ 54)) 100)
                                (QREFELT $ 57))
                      5)
                     . #3#)
               (LETT |k| (MAX 0 (+ (+ 2 |k|) (SPADCALL |x| (QREFELT $ 58))))
                     . #3#)
               (SPADCALL (SPADCALL 2 |k| (QREFELT $ 59)) (QREFELT $ 43))
               (SEQ (LETT |i| 1 . #3#) 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))
                            . #3#)))
                    (LETT |i| (QSADD1 |i|) . #3#) (GO G190) G191 (EXIT NIL))
               (LETT |t| (|FLOAT;atanSeries| |x| $) . #3#)
               (SPADCALL (SPADCALL 2 |k| (QREFELT $ 59)) (QREFELT $ 47))
               (LETT |t| (SPADCALL |t| |k| (QREFELT $ 62)) . #3#)
               (EXIT (SPADCALL |t| (QREFELT $ 48)))))))
      #1# (EXIT #1#))))) 

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

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

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

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

(DEFUN |FLOAT;cos;2$;15| (|x| $)
  (PROG (|r| |i| |k| #1=#:G831 |s| |p|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |s| 1 . #2=(|FLOAT;cos;2$;15|))
            (LETT |x| (SPADCALL |x| (QREFELT $ 51)) . #2#)
            (LETT |p| (SPADCALL (QREFELT $ 54)) . #2#)
            (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))
                         . #2#)
                   (EXIT (SPADCALL |p| (QREFELT $ 47))))))
            (COND
             ((SPADCALL (CONS 3 0) |x| (QREFELT $ 42))
              (SEQ (SPADCALL |p| (QREFELT $ 43)) (LETT |s| (- |s|) . #2#)
                   (LETT |x|
                         (SPADCALL |x| (SPADCALL (QREFELT $ 40))
                                   (QREFELT $ 50))
                         . #2#)
                   (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))
                         . #2#)
                   (SPADCALL |p| (QREFELT $ 65))
                   (LETT |x| (SPADCALL |x| (QREFELT $ 48)) . #2#)
                   (EXIT
                    (PROGN
                     (LETT #1#
                           (SPADCALL |s| (SPADCALL |x| (QREFELT $ 68))
                                     (QREFELT $ 67))
                           . #2#)
                     (GO #1#))))))
            (LETT |k|
                  (QUOTIENT2
                   (SPADCALL (- (SPADCALL (QREFELT $ 54)) 100) (QREFELT $ 57))
                   3)
                  . #2#)
            (LETT |k| (MAX 0 (+ (+ 2 |k|) (SPADCALL |x| (QREFELT $ 58))))
                  . #2#)
            (COND
             ((< 0 |k|)
              (SEQ
               (SPADCALL (+ |k| (EXPT (INTEGER-LENGTH |k|) 2)) (QREFELT $ 43))
               (EXIT (LETT |x| (SPADCALL |x| (- |k|) (QREFELT $ 62)) . #2#)))))
            (LETT |r| (|FLOAT;cosSeries| |x| $) . #2#)
            (SEQ (LETT |i| 1 . #2#) 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))
                         . #2#)))
                 (LETT |i| (QSADD1 |i|) . #2#) (GO G190) G191 (EXIT NIL))
            (SPADCALL |p| (QREFELT $ 65))
            (EXIT (SPADCALL |s| |r| (QREFELT $ 67)))))
      #1# (EXIT #1#))))) 

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

(DEFUN |FLOAT;tan;2$;17| (|x| $)
  (PROG (|t| |c| |s| |p|)
    (RETURN
     (SEQ (LETT |s| (SPADCALL |x| (QREFELT $ 63)) . #1=(|FLOAT;tan;2$;17|))
          (LETT |x| (SPADCALL |x| (QREFELT $ 51)) . #1#)
          (LETT |p| (SPADCALL (QREFELT $ 54)) . #1#)
          (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))
                       . #1#)
                 (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))
                       . #1#)
                 (LETT |s| (- |s|) . #1#)
                 (EXIT (SPADCALL |p| (QREFELT $ 47))))))
          (COND
           ((SPADCALL (|spadConstant| $ 38) |x| (QREFELT $ 42))
            (SEQ (LETT |c| (SPADCALL |x| (QREFELT $ 69)) . #1#)
                 (EXIT
                  (LETT |t|
                        (SPADCALL
                         (SPADCALL
                          (SPADCALL (|spadConstant| $ 38)
                                    (SPADCALL |c| |c| (QREFELT $ 60))
                                    (QREFELT $ 50))
                          (QREFELT $ 44))
                         |c| (QREFELT $ 45))
                        . #1#))))
           ('T
            (SEQ (LETT |c| (SPADCALL |x| (QREFELT $ 68)) . #1#)
                 (EXIT
                  (LETT |t|
                        (SPADCALL |c|
                                  (SPADCALL
                                   (SPADCALL (|spadConstant| $ 38)
                                             (SPADCALL |c| |c| (QREFELT $ 60))
                                             (QREFELT $ 50))
                                   (QREFELT $ 44))
                                  (QREFELT $ 45))
                        . #1#)))))
          (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 (|t| |m| |s| |i| |j| |d| |n|)
    (RETURN
     (SEQ
      (LETT |n|
            (+
             (+ (SPADCALL (QREFELT $ 54))
                (INTEGER-LENGTH (SPADCALL (QREFELT $ 54))))
             11)
            . #1=(|FLOAT;piRamanujan|))
      (LETT |t| (QUOTIENT2 (ASH 1 |n|) 882) . #1#)
      (LETT |d| (* 4 (SPADCALL 882 2 (QREFELT $ 73))) . #1#) (LETT |s| 0 . #1#)
      (SEQ (LETT |j| 1123 . #1#) (LETT |i| 2 . #1#) G190
           (COND ((NULL (COND ((EQL |t| 0) 'NIL) ('T 'T))) (GO G191)))
           (SEQ (LETT |s| (+ |s| (SPADCALL |j| |t| (QREFELT $ 75))) . #1#)
                (LETT |m|
                      (-
                       (* (* (- |i| 1) (- (SPADCALL 2 |i| (QREFELT $ 76)) 1))
                          (- (SPADCALL 2 |i| (QREFELT $ 76)) 3)))
                      . #1#)
                (EXIT
                 (LETT |t|
                       (QUOTIENT2 (* |m| |t|)
                                  (* |d| (SPADCALL |i| 3 (QREFELT $ 77))))
                       . #1#)))
           (LETT |i| (PROG1 (QSPLUS |i| 2) (LETT |j| (QSPLUS |j| 21460) . #1#))
                 . #1#)
           (GO G190) G191 (EXIT NIL))
      (EXIT
       (SPADCALL (|spadConstant| $ 38) (CONS |s| (- (- |n|) 2))
                 (QREFELT $ 45))))))) 

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

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

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

(DEFUN |FLOAT;asinh;2$;23| (|x| $)
  (PROG (|r| #1=#:G872 |p|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (LETT |p| (MIN 0 (SPADCALL |x| (QREFELT $ 58)))
              . #2=(|FLOAT;asinh;2$;23|))
        (COND
         ((OR (SPADCALL |x| (QREFELT $ 33))
              (< (SPADCALL 2 |p| (QREFELT $ 59))
                 (- (SPADCALL (QREFELT $ 54)))))
          (PROGN (LETT #1# |x| . #2#) (GO #1#))))
        (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))
              . #2#)
        (SPADCALL (- 5 |p|) (QREFELT $ 47))
        (EXIT (SPADCALL |r| (QREFELT $ 48)))))
      #1# (EXIT #1#))))) 

(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 (|r| #1=#:G880 |p|)
    (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)))
              . #2=(|FLOAT;atanh;2$;25|))
        (COND
         ((OR (SPADCALL |x| (QREFELT $ 33))
              (< (SPADCALL 2 |p| (QREFELT $ 59))
                 (- (SPADCALL (QREFELT $ 54)))))
          (PROGN (LETT #1# |x| . #2#) (GO #1#))))
        (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))
              . #2#)
        (SPADCALL (- 5 |p|) (QREFELT $ 47))
        (EXIT (SPADCALL |r| (QREFELT $ 48)))))
      #1# (EXIT #1#))))) 

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

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

(DEFUN |FLOAT;log2;$;28| ($)
  (PROG (|t| |s| |k| |n|)
    (RETURN
     (SEQ (LETT |n| (SPADCALL (QREFELT $ 54)) . #1=(|FLOAT;log2;$;28|))
          (COND
           ((NULL (< (QCAR (QREFELT $ 88)) |n|))
            (EXIT (SPADCALL (QCDR (QREFELT $ 88)) (QREFELT $ 48)))))
          (LETT |n| (+ (+ |n| (INTEGER-LENGTH |n|)) 3) . #1#)
          (LETT |s| (QUOTIENT2 (ASH 1 (+ |n| 1)) 3) . #1#)
          (LETT |t| (QUOTIENT2 |s| 9) . #1#)
          (SEQ (LETT |k| 3 . #1#) G190
               (COND ((NULL (COND ((EQL |t| 0) 'NIL) ('T 'T))) (GO G191)))
               (SEQ (LETT |s| (+ |s| (QUOTIENT2 |t| |k|)) . #1#)
                    (EXIT (LETT |t| (QUOTIENT2 |t| 9) . #1#)))
               (LETT |k| (QSPLUS |k| 2) . #1#) (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 (|t| |s| |k| |n|)
    (RETURN
     (SEQ (LETT |n| (SPADCALL (QREFELT $ 54)) . #1=(|FLOAT;log10;$;29|))
          (COND
           ((NULL (< (QCAR (QREFELT $ 89)) |n|))
            (EXIT (SPADCALL (QCDR (QREFELT $ 89)) (QREFELT $ 48)))))
          (LETT |n| (+ (+ |n| (INTEGER-LENGTH |n|)) 5) . #1#)
          (LETT |s| (QUOTIENT2 (ASH 1 (+ |n| 1)) 9) . #1#)
          (LETT |t| (QUOTIENT2 |s| 81) . #1#)
          (SEQ (LETT |k| 3 . #1#) G190
               (COND ((NULL (COND ((EQL |t| 0) 'NIL) ('T 'T))) (GO G191)))
               (SEQ (LETT |s| (+ |s| (QUOTIENT2 |t| |k|)) . #1#)
                    (EXIT (LETT |t| (QUOTIENT2 |t| 81) . #1#)))
               (LETT |k| (QSPLUS |k| 2) . #1#) (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 (|e| |k| #1=#:G919 |e1| |n| |p|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ (LETT |p| (SPADCALL (QREFELT $ 54)) . #2=(|FLOAT;exp;2$;32|))
            (SPADCALL 5 (QREFELT $ 43)) (LETT |e1| (|spadConstant| $ 38) . #2#)
            (SEQ (LETT |n| (SPADCALL |x| (QREFELT $ 55)) . #2#)
                 (EXIT
                  (COND
                   ((NULL (EQL |n| 0))
                    (SEQ (SPADCALL (INTEGER-LENGTH |n|) (QREFELT $ 43))
                         (LETT |e1|
                               (SPADCALL (SPADCALL (QREFELT $ 93)) |n|
                                         (QREFELT $ 87))
                               . #2#)
                         (SPADCALL (INTEGER-LENGTH |n|) (QREFELT $ 47))
                         (EXIT
                          (LETT |x| (SPADCALL |x| (QREFELT $ 53)) . #2#)))))))
            (COND
             ((SPADCALL |x| (QREFELT $ 33))
              (SEQ (SPADCALL |p| (QREFELT $ 65))
                   (EXIT
                    (PROGN
                     (LETT #1# (SPADCALL |e1| (QREFELT $ 48)) . #2#)
                     (GO #1#))))))
            (LETT |k| (QUOTIENT2 (SPADCALL (- |p| 100) (QREFELT $ 57)) 3)
                  . #2#)
            (LETT |k| (MAX 0 (+ (+ 2 |k|) (SPADCALL |x| (QREFELT $ 58))))
                  . #2#)
            (COND
             ((< 0 |k|)
              (SEQ (SPADCALL |k| (QREFELT $ 43))
                   (EXIT
                    (LETT |x| (SPADCALL |x| (- |k|) (QREFELT $ 62)) . #2#)))))
            (LETT |e| (|FLOAT;expSeries| |x| $) . #2#)
            (COND ((< 0 |k|) (LETT |e| (|FLOAT;square| |e| |k| $) . #2#)))
            (SPADCALL |p| (QREFELT $ 65))
            (EXIT (SPADCALL |e| |e1| (QREFELT $ 60)))))
      #1# (EXIT #1#))))) 

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

(DEFUN |FLOAT;expInverse| (|k| $)
  (PROG (|q1| |q0| |#G64| |#G63| |p1| |p0| |#G62| |#G61| #1=#:G930 |i|)
    (RETURN
     (SEQ
      (LETT |p0| (+ (SPADCALL 2 |k| (QREFELT $ 59)) 1)
            . #2=(|FLOAT;expInverse|))
      (LETT |p1| (+ (* (SPADCALL 6 |k| (QREFELT $ 59)) |p0|) 1) . #2#)
      (LETT |q0| (- (SPADCALL 2 |k| (QREFELT $ 59)) 1) . #2#)
      (LETT |q1| (+ (* (SPADCALL 6 |k| (QREFELT $ 59)) |q0|) 1) . #2#)
      (SEQ (LETT |i| (SPADCALL 10 |k| (QREFELT $ 59)) . #2#)
           (LETT #1# (SPADCALL 4 |k| (QREFELT $ 59)) . #2#) G190
           (COND
            ((NULL (< (* 2 (INTEGER-LENGTH |p0|)) (SPADCALL (QREFELT $ 54))))
             (GO G191)))
           (SEQ
            (PROGN
             (LETT |#G61| |p1| . #2#)
             (LETT |#G62| (+ (* |i| |p1|) |p0|) . #2#)
             (LETT |p0| |#G61| . #2#)
             (LETT |p1| |#G62| . #2#))
            (EXIT
             (PROGN
              (LETT |#G63| |q1| . #2#)
              (LETT |#G64| (+ (* |i| |q1|) |q0|) . #2#)
              (LETT |q0| |#G63| . #2#)
              (LETT |q1| |#G64| . #2#))))
           (LETT |i| (+ |i| #1#) . #2#) (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 (|i| |p| |l| |e| |m|)
    (RETURN
     (SEQ
      (COND ((SPADCALL |x| (QREFELT $ 35)) (|error| "negative sqrt"))
            ('T
             (SEQ (LETT |m| (QCAR |x|) . #1=(|FLOAT;sqrt;2$;36|))
                  (LETT |e| (QCDR |x|) . #1#)
                  (LETT |l| (INTEGER-LENGTH |m|) . #1#)
                  (LETT |p| (+ (- (* 2 (SPADCALL (QREFELT $ 54))) |l|) 2)
                        . #1#)
                  (COND ((ODDP (- |e| |l|)) (LETT |p| (- |p| 1) . #1#)))
                  (LETT |i| (|FLOAT;shift2| (QCAR |x|) |p| $) . #1#)
                  (LETT |i| (SPADCALL |i| (QREFELT $ 57)) . #1#)
                  (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 (#1=#:G946 |b|)
    (RETURN
     (SEQ
      (LETT |b| (SPADCALL (QREFELT $ 54))
            . #2=(|FLOAT;increasePrecision;IPi;41|))
      (SPADCALL
       (PROG1 (LETT #1# (+ |b| |n|) . #2#)
         (|check-subtype| (> #1# 0) '(|PositiveInteger|) #1#))
       (QREFELT $ 65))
      (EXIT |b|))))) 

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

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

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

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

(DEFUN |FLOAT;<;2$B;63| (|x| |y| $)
  (SEQ
   (COND ((EQL (QCAR |y|) 0) (< (QCAR |x|) 0))
         ((EQL (QCAR |x|) 0) (< 0 (QCAR |y|)))
         (#1='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)))
             (#1#
              (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 (#1=#:G1009)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (COND
         ((SPADCALL |x| (QREFELT $ 35))
          (PROGN
           (LETT #1#
                 (SPADCALL
                  (SPADCALL (SPADCALL |x| (QREFELT $ 36)) (QREFELT $ 108))
                  (QREFELT $ 36))
                 |FLOAT;ceiling;2$;65|)
           (GO #1#))))
        (EXIT
         (COND ((SPADCALL (SPADCALL |x| (QREFELT $ 53)) (QREFELT $ 33)) |x|)
               ('T
                (SPADCALL (SPADCALL |x| (QREFELT $ 109)) (|spadConstant| $ 38)
                          (QREFELT $ 61)))))))
      #1# (EXIT #1#))))) 

(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 (#1=#:G1021)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (COND
         ((NULL (< (QCDR |x|) 0))
          (PROGN (LETT #1# |x| |FLOAT;truncate;2$;70|) (GO #1#))))
        (EXIT
         (SPADCALL (CONS (|FLOAT;shift2| (QCAR |x|) (QCDR |x|) $) 0)
                   (QREFELT $ 48)))))
      #1# (EXIT #1#))))) 

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

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

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

(DEFUN |FLOAT;^;3$;89| (|x| |y| $)
  (PROG (|r| |p|)
    (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)
               . #1=(|FLOAT;^;3$;89|))
         (SPADCALL |p| (QREFELT $ 43))
         (LETT |r|
               (SPADCALL
                (SPADCALL |y| (SPADCALL |x| (QREFELT $ 82)) (QREFELT $ 60))
                (QREFELT $ 78))
               . #1#)
         (SPADCALL |p| (QREFELT $ 47))
         (EXIT (SPADCALL |r| (QREFELT $ 48)))))))))) 

(DEFUN |FLOAT;^;$F$;90| (|x| |r| $)
  (PROG (|y| #1=#:G1075 |d| |n|)
    (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))
        (#2='T
         (SEQ (LETT |n| (SPADCALL |r| (QREFELT $ 122)) . #3=(|FLOAT;^;$F$;90|))
              (LETT |d| (SPADCALL |r| (QREFELT $ 123)) . #3#)
              (EXIT
               (COND
                ((SPADCALL |x| (QREFELT $ 35))
                 (COND
                  ((ODDP |d|)
                   (COND
                    ((ODDP |n|)
                     (PROGN
                      (LETT #1#
                            (SPADCALL
                             (SPADCALL (SPADCALL |x| (QREFELT $ 36)) |r|
                                       (QREFELT $ 124))
                             (QREFELT $ 36))
                            . #3#)
                      (GO #1#)))
                    (#2#
                     (PROGN
                      (LETT #1#
                            (SPADCALL (SPADCALL |x| (QREFELT $ 36)) |r|
                                      (QREFELT $ 124))
                            . #3#)
                      (GO #1#)))))
                  (#2# (|error| "negative root"))))
                (#2#
                 (SEQ
                  (COND
                   ((EQL |d| 2)
                    (SEQ (SPADCALL (INTEGER-LENGTH |n|) (QREFELT $ 43))
                         (LETT |y| (SPADCALL |x| (QREFELT $ 44)) . #3#)
                         (LETT |y| (SPADCALL |y| |n| (QREFELT $ 87)) . #3#)
                         (SPADCALL (INTEGER-LENGTH |n|) (QREFELT $ 47))
                         (EXIT
                          (PROGN
                           (LETT #1# (SPADCALL |y| (QREFELT $ 48)) . #3#)
                           (GO #1#))))))
                  (LETT |y| (SPADCALL (CONS |n| 0) (CONS |d| 0) (QREFELT $ 45))
                        . #3#)
                  (EXIT (SPADCALL |x| |y| (QREFELT $ 116)))))))))))
      #1# (EXIT #1#))))) 

(DEFUN |FLOAT;^;$I$;91| (|x| |n| $)
  (PROG (|y| |p|)
    (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)) . #1=(|FLOAT;^;$I$;91|))
             (SPADCALL (+ (+ |p| (INTEGER-LENGTH |n|)) 2) (QREFELT $ 65))
             (LETT |y| (|FLOAT;power| |x| (ABS |n|) $) . #1#)
             (COND
              ((< |n| 0)
               (LETT |y| (|FLOAT;dvide| (|spadConstant| $ 38) |y| $) . #1#)))
             (SPADCALL |p| (QREFELT $ 65))
             (EXIT (SPADCALL |y| (QREFELT $ 48)))))))))) 

(DEFUN |FLOAT;convert10| (|x| |d| $)
  (PROG (|h| |r| #1=#:G1082 |b| |q| |#G147| |e| |m|)
    (RETURN
     (SEQ (LETT |m| (QCAR |x|) . #2=(|FLOAT;convert10|))
          (LETT |e| (QCDR |x|) . #2#)
          (LETT |b| (SPADCALL (QREFELT $ 54)) . #2#)
          (PROGN
           (LETT |#G147| (DIVIDE2 (ABS |e|) |b|) . #2#)
           (LETT |q| (QCAR |#G147|) . #2#)
           (LETT |r| (QCDR |#G147|) . #2#)
           |#G147|)
          (LETT |b| (EXPT 2 |b|) . #2#)
          (LETT |r|
                (EXPT 2
                      (PROG1 (LETT #1# |r| . #2#)
                        (|check-subtype| (>= #1# 0) '(|NonNegativeInteger|)
                                         #1#)))
                . #2#)
          (LETT |h| (|FLOAT;power10| (CONS |b| 0) |q| (+ |d| 5) $) . #2#)
          (LETT |h|
                (|FLOAT;chop10| (CONS (* |r| (QCAR |h|)) (QCDR |h|)) (+ |d| 5)
                 $)
                . #2#)
          (EXIT
           (COND
            ((< |e| 0)
             (LETT |h| (|FLOAT;quotient10| (CONS |m| 0) |h| |d| $) . #2#))
            ('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 (|lower| #1=#:G1089 |upper| |ln|)
    (RETURN
     (SEQ
      (LETT |ln| (INTEGER-LENGTH (LETT |n| (ABS |n|) . #2=(|FLOAT;length10|)))
            . #2#)
      (LETT |upper| (QUOTIENT2 (* 76573 |ln|) 254370) . #2#)
      (LETT |lower|
            (QUOTIENT2 (SPADCALL 21306 (- |ln| 1) (QREFELT $ 59)) 70777) . #2#)
      (EXIT
       (COND ((EQL |upper| |lower|) (+ |upper| 1))
             ('T
              (SEQ
               (LETT |n|
                     (QUOTIENT2 |n|
                                (EXPT 10
                                      (PROG1 (LETT #1# |lower| . #2#)
                                        (|check-subtype| (>= #1# 0)
                                                         '(|NonNegativeInteger|)
                                                         #1#))))
                     . #2#)
               (SEQ G190
                    (COND ((NULL (COND ((< |n| 10) 'NIL) ('T 'T))) (GO G191)))
                    (SEQ (LETT |n| (QUOTIENT2 |n| 10) . #2#)
                         (EXIT (LETT |lower| (+ |lower| 1) . #2#)))
                    NIL (GO G190) G191 (EXIT NIL))
               (EXIT (+ |lower| 1)))))))))) 

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

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

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

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

(DEFUN |FLOAT;power10| (|x| |n| |d| $)
  (PROG (|z| #1=#:G1132 |e| |y| |p|)
    (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) . #2=(|FLOAT;power10|))
          (LETT |e| |n| . #2#) (LETT |y| (|spadConstant| $ 38) . #2#)
          (LETT |z| |x| . #2#)
          (EXIT
           (SEQ G190 NIL
                (SEQ
                 (COND
                  ((ODDP |e|)
                   (LETT |y| (|FLOAT;chop10| (|FLOAT;times| |y| |z| $) |p| $)
                         . #2#)))
                 (SEQ (LETT |e| (QUOTIENT2 |e| 2) . #2#)
                      (EXIT
                       (COND
                        ((EQL |e| 0) (PROGN (LETT #1# |y| . #2#) (GO #1#))))))
                 (EXIT
                  (LETT |z| (|FLOAT;chop10| (|FLOAT;times| |z| |z| $) |p| $)
                        . #2#)))
                NIL (GO G190) G191 (EXIT NIL)))))))
      #1# (EXIT #1#))))) 

(DEFUN |FLOAT;padFromLeft| (|s| $)
  (PROG (|j| |i| |t| #1=#:G1134 |n|)
    (RETURN
     (SEQ
      (COND ((ZEROP (SPADCALL (QREFELT $ 127) (QREFELT $ 134))) |s|)
            ('T
             (SEQ (LETT |n| (- (QCSIZE |s|) 1) . #2=(|FLOAT;padFromLeft|))
                  (LETT |t|
                        (MAKE-FULL-CVEC
                         (PROG1
                             (LETT #1#
                                   (+ (+ |n| 1)
                                      (QUOTIENT2 |n|
                                                 (SPADCALL (QREFELT $ 127)
                                                           (QREFELT $ 134))))
                                   . #2#)
                           (|check-subtype| (>= #1# 0) '(|NonNegativeInteger|)
                                            #1#))
                         (SPADCALL (QREFELT $ 136)))
                        . #2#)
                  (SEQ (LETT |j| (SPADCALL |t| (QREFELT $ 137)) . #2#)
                       (LETT |i| 0 . #2#) 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) . #2#)))))
                       (LETT |i|
                             (PROG1 (QSADD1 |i|) (LETT |j| (+ |j| 1) . #2#))
                             . #2#)
                       (GO G190) G191 (EXIT NIL))
                  (EXIT |t|)))))))) 

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

(DEFUN |FLOAT;fixed| (|f| $)
  (PROG (|t| #1=#:G1163 |n| |s| #2=#:G1160 #3=#:G1158 |p| |o| |e| |m| |g| |l|
         |dd| |bl| #4=#:G1150 #5=#:G1148 |d|)
    (RETURN
     (SEQ
      (LETT |d|
            (COND
             ((EQL (SPADCALL (QREFELT $ 133) (QREFELT $ 141)) -1)
              (SPADCALL (QREFELT $ 99)))
             (#6='T (SPADCALL (QREFELT $ 133) (QREFELT $ 141))))
            . #7=(|FLOAT;fixed|))
      (EXIT
       (COND
        ((SPADCALL |f| (QREFELT $ 33))
         (COND ((EQL (SPADCALL (QREFELT $ 133) (QREFELT $ 141)) -1) "0.0")
               (#6#
                (STRCONC "0"
                         (STRCONC "."
                                  (|FLOAT;padFromLeft|
                                   (MAKE-FULL-CVEC
                                    (PROG1 (LETT #5# |d| . #7#)
                                      (|check-subtype| (>= #5# 0)
                                                       '(|NonNegativeInteger|)
                                                       #5#))
                                    (SPADCALL #8="0" (QREFELT $ 142)))
                                   $))))))
        ((ZEROP (SPADCALL |f| (QREFELT $ 19)))
         (STRCONC
          (|FLOAT;padFromRight| (STRINGIMAGE (SPADCALL |f| (QREFELT $ 17))) $)
          (STRCONC "."
                   (|FLOAT;padFromLeft|
                    (MAKE-FULL-CVEC
                     (PROG1 (LETT #4# |d| . #7#)
                       (|check-subtype| (>= #4# 0) '(|NonNegativeInteger|)
                                        #4#))
                     (SPADCALL #8# (QREFELT $ 142)))
                    $))))
        ((SPADCALL |f| (QREFELT $ 35))
         (STRCONC "-" (|FLOAT;fixed| (SPADCALL |f| (QREFELT $ 51)) $)))
        (#6#
         (SEQ (LETT |bl| (+ (INTEGER-LENGTH (QCAR |f|)) (QCDR |f|)) . #7#)
              (LETT |dd|
                    (COND
                     ((OR (EQL (SPADCALL (QREFELT $ 133) (QREFELT $ 141)) -1)
                          (NULL (< 0 |bl|)))
                      |d|)
                     ('T
                      (+
                       (+ (QUOTIENT2 (SPADCALL 146 |bl| (QREFELT $ 59)) 485) 1)
                       |d|)))
                    . #7#)
              (LETT |g|
                    (|FLOAT;convert10| (SPADCALL |f| (QREFELT $ 51)) |dd| $)
                    . #7#)
              (LETT |m| (QCAR |g|) . #7#) (LETT |e| (QCDR |g|) . #7#)
              (COND
               ((NULL (EQL (SPADCALL (QREFELT $ 133) (QREFELT $ 141)) -1))
                (SEQ (LETT |l| (|FLOAT;length10| |m| $) . #7#)
                     (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)))
                                  $)
                                 . #7#)
                           (LETT |m| (QCAR |g|) . #7#)
                           (EXIT (LETT |e| (QCDR |g|) . #7#)))))))))))
              (LETT |s| (STRINGIMAGE |m|) . #7#) (LETT |n| (QCSIZE |s|) . #7#)
              (LETT |o| (+ |e| |n|) . #7#)
              (LETT |p|
                    (COND
                     ((EQL (SPADCALL (QREFELT $ 133) (QREFELT $ 141)) -1) |n|)
                     (#6# (SPADCALL (QREFELT $ 133) (QREFELT $ 141))))
                    . #7#)
              (COND
               ((< |e| 0)
                (COND
                 ((< 0 |o|)
                  (SEQ
                   (LETT |t|
                         (SPADCALL |s|
                                   (SPADCALL
                                    (+ |o| (SPADCALL |s| (QREFELT $ 137)))
                                    (- (+ |n| (SPADCALL |s| (QREFELT $ 137)))
                                       1)
                                    (QREFELT $ 144))
                                   (QREFELT $ 145))
                         . #7#)
                   (EXIT
                    (LETT |s|
                          (SPADCALL |s|
                                    (SPADCALL (SPADCALL |s| (QREFELT $ 137))
                                              (-
                                               (+ |o|
                                                  (SPADCALL |s|
                                                            (QREFELT $ 137)))
                                               1)
                                              (QREFELT $ 144))
                                    (QREFELT $ 145))
                          . #7#))))
                 (#6#
                  (SEQ
                   (LETT |t|
                         (STRCONC
                          (MAKE-FULL-CVEC
                           (PROG1 (LETT #3# (- |o|) . #7#)
                             (|check-subtype| (>= #3# 0)
                                              '(|NonNegativeInteger|) #3#))
                           (SPADCALL #8# (QREFELT $ 142)))
                          |s|)
                         . #7#)
                   (EXIT (LETT |s| "0" . #7#))))))
               (#6#
                (SEQ
                 (LETT |s|
                       (STRCONC |s|
                                (MAKE-FULL-CVEC
                                 (PROG1 (LETT #2# |e| . #7#)
                                   (|check-subtype| (>= #2# 0)
                                                    '(|NonNegativeInteger|)
                                                    #2#))
                                 (SPADCALL #8# (QREFELT $ 142))))
                       . #7#)
                 (EXIT (LETT |t| "" . #7#)))))
              (LETT |n| (QCSIZE |t|) . #7#)
              (COND
               ((EQL (SPADCALL (QREFELT $ 133) (QREFELT $ 141)) -1)
                (SEQ
                 (LETT |t|
                       (SPADCALL |t| (SPADCALL #8# (QREFELT $ 142))
                                 (QREFELT $ 146))
                       . #7#)
                 (EXIT (COND ((EQUAL |t| "") (LETT |t| "0" . #7#))))))
               ((< |p| |n|)
                (LETT |t|
                      (SPADCALL |t|
                                (SPADCALL (SPADCALL |t| (QREFELT $ 137))
                                          (-
                                           (+ |p|
                                              (SPADCALL |t| (QREFELT $ 137)))
                                           1)
                                          (QREFELT $ 144))
                                (QREFELT $ 145))
                      . #7#))
               (#6#
                (LETT |t|
                      (STRCONC |t|
                               (MAKE-FULL-CVEC
                                (PROG1 (LETT #1# (- |p| |n|) . #7#)
                                  (|check-subtype| (>= #1# 0)
                                                   '(|NonNegativeInteger|)
                                                   #1#))
                                (SPADCALL #8# (QREFELT $ 142))))
                      . #7#)))
              (EXIT
               (STRCONC (|FLOAT;padFromRight| |s| $)
                        (STRCONC "." (|FLOAT;padFromLeft| |t| $)))))))))))) 

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

(DEFUN |FLOAT;general| (|f| $)
  (PROG (#1=#:G1197 |s| |t| #2=#:G1192 #3=#:G1190 |o| |n| |e| |m| |g|
         #4=#:G1185 |d|)
    (RETURN
     (SEQ
      (COND ((SPADCALL |f| (QREFELT $ 33)) "0.0")
            ((SPADCALL |f| (QREFELT $ 35))
             (STRCONC "-" (|FLOAT;general| (SPADCALL |f| (QREFELT $ 51)) $)))
            (#5='T
             (SEQ
              (LETT |d|
                    (COND
                     ((EQL (SPADCALL (QREFELT $ 133) (QREFELT $ 141)) -1)
                      (SPADCALL (QREFELT $ 99)))
                     (#5# (SPADCALL (QREFELT $ 133) (QREFELT $ 141))))
                    . #6=(|FLOAT;general|))
              (EXIT
               (COND
                ((ZEROP (SPADCALL |f| (QREFELT $ 19)))
                 (SEQ
                  (EXIT
                   (SEQ (LETT |d| (+ |d| 1) . #6#)
                        (LETT |s| (STRINGIMAGE (SPADCALL |f| (QREFELT $ 17)))
                              . #6#)
                        (COND
                         ((NULL
                           (EQL (SPADCALL (QREFELT $ 133) (QREFELT $ 141)) -1))
                          (SEQ (LETT |e| (QCSIZE |s|) . #6#)
                               (EXIT
                                (COND
                                 ((< |d| |e|)
                                  (PROGN
                                   (LETT #4#
                                         (SEQ
                                          (LETT |t|
                                                (COND
                                                 ((ZEROP
                                                   (SPADCALL (QREFELT $ 127)
                                                             (QREFELT $ 134)))
                                                  "E")
                                                 (#5# " E "))
                                                . #6#)
                                          (EXIT
                                           (SPADCALL
                                            (LIST "0."
                                                  (|FLOAT;padFromLeft| |s| $)
                                                  |t| (STRINGIMAGE |e|))
                                            (QREFELT $ 148))))
                                         . #6#)
                                   (GO #4#))))))))
                        (EXIT (|FLOAT;padFromRight| (STRCONC |s| ".0") $))))
                  #4# (EXIT #4#)))
                (#5#
                 (SEQ (LETT |g| (|FLOAT;convert10| |f| |d| $) . #6#)
                      (LETT |m| (QCAR |g|) . #6#) (LETT |e| (QCDR |g|) . #6#)
                      (LETT |s| (STRINGIMAGE |m|) . #6#)
                      (LETT |n| (QCSIZE |s|) . #6#)
                      (LETT |o| (+ |n| |e|) . #6#)
                      (EXIT
                       (COND
                        ((< 0 |o|)
                         (COND
                          ((< (MAX |n| |d|) |o|)
                           (COND
                            ((OR (< 0 |o|) (< |o| -5))
                             (SEQ
                              (LETT |t|
                                    (|FLOAT;padFromLeft|
                                     (SPADCALL |s|
                                               (SPADCALL #7="0"
                                                         (QREFELT $ 142))
                                               (QREFELT $ 146))
                                     $)
                                    . #6#)
                              (LETT |s|
                                    (COND
                                     ((ZEROP
                                       (SPADCALL (QREFELT $ 127)
                                                 (QREFELT $ 134)))
                                      #8="E")
                                     (#5# #9=" E "))
                                    . #6#)
                              (EXIT
                               (SPADCALL
                                (LIST #10="0." |t| |s|
                                      (STRINGIMAGE (+ |e| |n|)))
                                (QREFELT $ 148)))))
                            ('T
                             (STRCONC #11="0."
                                      (|FLOAT;padFromLeft|
                                       (STRCONC
                                        (MAKE-FULL-CVEC
                                         (PROG1 (LETT #3# (- |o|) . #6#)
                                           (|check-subtype| (>= #3# 0)
                                                            '(|NonNegativeInteger|)
                                                            #3#))
                                         (SPADCALL #7# (QREFELT $ 142)))
                                        (SPADCALL |s|
                                                  (SPADCALL #7#
                                                            (QREFELT $ 142))
                                                  (QREFELT $ 146)))
                                       $)))))
                          (#5#
                           (SEQ
                            (COND
                             ((< |n| |o|)
                              (LETT |s|
                                    (STRCONC |s|
                                             (MAKE-FULL-CVEC
                                              (PROG1
                                                  (LETT #2# (- |o| |n|) . #6#)
                                                (|check-subtype| (>= #2# 0)
                                                                 '(|NonNegativeInteger|)
                                                                 #2#))
                                              (SPADCALL #7# (QREFELT $ 142))))
                                    . #6#)))
                            (LETT |t|
                                  (SPADCALL
                                   (SPADCALL |s|
                                             (SPADCALL
                                              (+ |o|
                                                 (SPADCALL |s|
                                                           (QREFELT $ 137)))
                                              (-
                                               (+ |n|
                                                  (SPADCALL |s|
                                                            (QREFELT $ 137)))
                                               1)
                                              (QREFELT $ 144))
                                             (QREFELT $ 145))
                                   (SPADCALL #7# (QREFELT $ 142))
                                   (QREFELT $ 146))
                                  . #6#)
                            (COND ((EQUAL |t| "") (LETT |t| "0" . #6#))
                                  (#5#
                                   (LETT |t| (|FLOAT;padFromLeft| |t| $)
                                         . #6#)))
                            (LETT |s|
                                  (|FLOAT;padFromRight|
                                   (SPADCALL |s|
                                             (SPADCALL
                                              (SPADCALL |s| (QREFELT $ 137))
                                              (-
                                               (+ |o|
                                                  (SPADCALL |s|
                                                            (QREFELT $ 137)))
                                               1)
                                              (QREFELT $ 144))
                                             (QREFELT $ 145))
                                   $)
                                  . #6#)
                            (EXIT (STRCONC |s| (STRCONC "." |t|)))))))
                        ((< |o| -5)
                         (SEQ
                          (LETT |t|
                                (|FLOAT;padFromLeft|
                                 (SPADCALL |s| (SPADCALL #7# (QREFELT $ 142))
                                           (QREFELT $ 146))
                                 $)
                                . #6#)
                          (LETT |s|
                                (COND
                                 ((ZEROP
                                   (SPADCALL (QREFELT $ 127) (QREFELT $ 134)))
                                  #8#)
                                 (#5# #9#))
                                . #6#)
                          (EXIT
                           (SPADCALL
                            (LIST #10# |t| |s| (STRINGIMAGE (+ |e| |n|)))
                            (QREFELT $ 148)))))
                        (#5#
                         (STRCONC #11#
                                  (|FLOAT;padFromLeft|
                                   (STRCONC
                                    (MAKE-FULL-CVEC
                                     (PROG1 (LETT #1# (- |o|) . #6#)
                                       (|check-subtype| (>= #1# 0)
                                                        '(|NonNegativeInteger|)
                                                        #1#))
                                     (SPADCALL #7# (QREFELT $ 142)))
                                    (SPADCALL |s|
                                              (SPADCALL #7# (QREFELT $ 142))
                                              (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 (#1=#:G1222 |s| |b| #2=#:G1218)
    (RETURN
     (SEQ
      (LETT |b|
            (SEQ
             (COND
              ((EQL (SPADCALL (QREFELT $ 133) (QREFELT $ 141)) -1)
               (COND
                ((NULL (SPADCALL |f| (QREFELT $ 33)))
                 (EXIT
                  (SPADCALL
                   (PROG1
                       (LETT #2#
                             (INTEGER-LENGTH
                              (ABS (SPADCALL |f| (QREFELT $ 17))))
                             . #3=(|FLOAT;convert;$S;113|))
                     (|check-subtype| (> #2# 0) '(|PositiveInteger|) #2#))
                   (QREFELT $ 65)))))))
             (EXIT 0))
            . #3#)
      (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| $))
             (#4='T (MAKE-FULL-CVEC 0)))
            . #3#)
      (COND
       ((< 0 |b|)
        (SPADCALL
         (PROG1 (LETT #1# |b| . #3#)
           (|check-subtype| (> #1# 0) '(|PositiveInteger|) #1#))
         (QREFELT $ 65))))
      (EXIT
       (COND ((EQUAL |s| (MAKE-FULL-CVEC 0)) (|error| "bad output mode"))
             (#4# |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 '|float| (QREFELT $ 167))
         (SPADCALL (SPADCALL |f| (QREFELT $ 17)) (QREFELT $ 168))
         (SPADCALL (SPADCALL |f| (QREFELT $ 19)) (QREFELT $ 168))
         (SPADCALL (SPADCALL (QREFELT $ 102)) (QREFELT $ 168)))
   (QREFELT $ 169))) 

(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 $ 174))) 

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

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

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

(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 $ 183)) (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 $ 183)) (QREFELT $ 39))
             (CONS 0 |n|))
            ('T (CONS 1 "failed")))))))) 

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

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

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

(DEFUN |Float;| ()
  (PROG (|dv$| $ |pv$|)
    (RETURN
     (PROGN
      (LETT |dv$| '(|Float|) . #1=(|Float|))
      (LETT $ (GETREFV 201) . #1#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#))
      (|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|) (212 . |char|)
              (|UniversalSegment| 16) (217 . SEGMENT) (223 . |elt|)
              (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|)
              (|InputForm|) (273 . |convert|) (278 . |convert|)
              (283 . |convert|) |FLOAT;convert;$If;115| (|Float|)
              |FLOAT;convert;2$;116| (|DoubleFloat|) |FLOAT;convert;$Df;117|
              |FLOAT;coerce;$Df;118| (288 . |mantissa|) (293 . |exponent|)
              |FLOAT;convert;Df$;119| |FLOAT;rationalApproximation;$2NniF;125|
              |FLOAT;retract;$F;120| (|Union| 117 '"failed")
              |FLOAT;retractIfCan;$U;121| (298 . |coerce|)
              |FLOAT;retract;$I;122| (|Union| 16 '"failed")
              |FLOAT;retractIfCan;$U;123|
              |FLOAT;rationalApproximation;$NniF;124| (303 . /)
              (|PatternMatchResult| 171 $) (|Pattern| 171) (|Factored| $)
              (|Union| 147 '#1="failed")
              (|Record| (|:| |coef1| $) (|:| |coef2| $)) (|Union| 193 '#1#)
              (|Record| (|:| |coef1| $) (|:| |coef2| $) (|:| |generator| $))
              (|Record| (|:| |quotient| $) (|:| |remainder| $))
              (|SparseUnivariatePolynomial| $)
              (|Record| (|:| |coef| 147) (|:| |generator| $))
              (|Record| (|:| |unit| $) (|:| |canonical| $) (|:| |associate| $))
              (|SingleInteger|))
           '#(~= 309 |zero?| 315 |wholePart| 320 |unitNormal| 325
              |unitCanonical| 330 |unit?| 335 |truncate| 340 |tanh| 345 |tan|
              350 |subtractIfCan| 355 |squareFreePart| 361 |squareFree| 366
              |sqrt| 371 |smaller?| 376 |sizeLess?| 382 |sinh| 388 |sin| 393
              |sign| 398 |shift| 403 |sech| 409 |sec| 414 |sample| 419 |round|
              423 |retractIfCan| 428 |retract| 438 |rem| 448 |relerror| 454
              |recip| 460 |rationalApproximation| 465 |quo| 478
              |principalIdeal| 484 |prime?| 489 |precision| 494 |positive?| 503
              |pi| 508 |patternMatch| 512 |outputSpacing| 519 |outputGeneral|
              524 |outputFloating| 533 |outputFixed| 542 |order| 551 |one?| 556
              |nthRoot| 561 |normalize| 567 |norm| 572 |negative?| 577
              |multiEuclidean| 582 |min| 588 |max| 598 |mantissa| 608 |log2|
              613 |log10| 622 |log| 631 |lcm| 636 |latex| 647 |inv| 652
              |increasePrecision| 657 |hash| 662 |gcdPolynomial| 667 |gcd| 673
              |fractionPart| 684 |floor| 689 |float| 694 |factor| 707
              |extendedEuclidean| 712 |exquo| 725 |expressIdealMember| 731
              |exponent| 737 |exp1| 742 |exp| 746 |euclideanSize| 751 |divide|
              756 |digits| 762 |differentiate| 771 |decreasePrecision| 782
              |csch| 787 |csc| 792 |coth| 797 |cot| 802 |cosh| 807 |cos| 812
              |convert| 817 |coerce| 847 |characteristic| 882 |ceiling| 886
              |bits| 891 |base| 900 |atanh| 904 |atan| 909 |associates?| 920
              |asinh| 926 |asin| 931 |asech| 936 |asec| 941 |acsch| 946 |acsc|
              951 |acoth| 956 |acot| 961 |acosh| 966 |acos| 971 |abs| 976 ^ 981
              |Zero| 1011 |One| 1015 |OMwrite| 1019 D 1043 >= 1054 > 1060 =
              1066 <= 1072 < 1078 / 1084 - 1096 + 1107 * 1113)
           '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
                                  0))
            (CONS
             '#(|FloatingPointSystem&| |RealNumberSystem&| |Field&|
                |EuclideanDomain&| NIL |UniqueFactorizationDomain&|
                |GcdDomain&| |DivisionRing&| |IntegralDomain&| |Algebra&|
                |Algebra&| |DifferentialRing&| NIL |OrderedRing&| |Module&| NIL
                NIL |Module&| NIL NIL NIL |Ring&| NIL NIL NIL NIL NIL NIL NIL
                |AbelianGroup&| NIL NIL NIL |OrderedSet&| |AbelianMonoid&|
                |Monoid&| NIL NIL NIL |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| $$) (|OrderedAbelianGroup|) (|BiModule| 117 117)
                 (|BiModule| $$ $$) (|Ring|)
                 (|OrderedCancellationAbelianMonoid|) (|RightModule| 117)
                 (|LeftModule| 117) (|LeftModule| $$) (|Rng|)
                 (|RightModule| $$) (|OrderedAbelianMonoid|) (|AbelianGroup|)
                 (|OrderedAbelianSemiGroup|) (|CancellationAbelianMonoid|)
                 (|SemiRing|) (|OrderedSet|) (|AbelianMonoid|) (|Monoid|)
                 (|SemiRng|) (|PatternMatchable| 171) (|Comparable|)
                 (|SemiGroup|) (|AbelianSemiGroup|)
                 (|TranscendentalFunctionCategory|) (|RealConstant|)
                 (|SetCategory|) (|arbitraryExponent|) (|arbitraryPrecision|)
                 (|ConvertibleTo| 166) (|ElementaryFunctionCategory|)
                 (|ArcHyperbolicFunctionCategory|)
                 (|HyperbolicFunctionCategory|)
                 (|ArcTrigonometricFunctionCategory|)
                 (|TrigonometricFunctionCategory|) (|CoercibleTo| 173)
                 (|OpenMath|) (|ConvertibleTo| 14) (|Approximate|)
                 (|ConvertibleTo| 190) (|RadicalCategory|)
                 (|RetractableTo| 117) (|RetractableTo| 16)
                 (|ConvertibleTo| 171) (|ConvertibleTo| 173)
                 (|canonicalsClosed|) (|canonicalUnitNormal|)
                 (|noZeroDivisors|) (|CommutativeStar|) (|unitsKnown|)
                 (|BasicType|) (|CoercibleTo| 161))
              (|makeByteWordVec2| 200
                                  '(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 1 135
                                    0 14 142 2 143 0 16 16 144 2 14 0 0 143 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 166 0 165 167 1 16 166 0 168 1 166 0 147
                                    169 1 173 16 0 176 1 173 16 0 177 1 0 0 16
                                    183 2 117 0 16 16 188 2 0 28 0 0 1 1 0 28 0
                                    33 1 0 16 0 55 1 0 199 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 191 0 1 1 0 0 0 44
                                    2 0 28 0 0 1 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 181 0 182 1
                                    0 185 0 186 1 0 117 0 180 1 0 16 0 184 2 0
                                    0 0 0 1 2 0 16 0 0 101 1 0 112 0 113 3 0
                                    117 0 74 74 179 2 0 117 0 74 187 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 189 0 190 189
                                    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 192 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
                                    200 0 1 2 0 197 197 197 1 1 0 0 147 1 2 0 0
                                    0 0 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 191 0 1 3 0 194 0
                                    0 0 1 2 0 195 0 0 1 2 0 112 0 0 1 2 0 192
                                    147 0 1 1 0 16 0 19 0 0 0 93 1 0 0 0 78 1 0
                                    74 0 1 2 0 196 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 173 178 1 0 166 0 170 1 0
                                    14 0 160 1 0 190 0 1 1 0 171 0 172 1 0 173
                                    0 174 1 0 173 0 175 1 0 0 117 1 1 0 0 16
                                    183 1 0 0 117 1 1 0 0 0 1 1 0 0 16 183 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 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 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 117 1 2 0 0 117 0 1 2 0 0 0 0 60
                                    2 0 0 16 0 67 2 0 0 74 0 1 2 0 0 6 0
                                    64)))))
           '|lookupComplete|)) 

(MAKEPROP '|Float| 'NILADIC T) 
