
(/VERSIONCHECK 2) 

(DEFUN |DFLOAT;doubleFloatFormat;2S;1| (|s| $)
  (PROG (|ss|)
    (RETURN
      (SEQ (LETT |ss| (QREFELT $ 6) |DFLOAT;doubleFloatFormat;2S;1|)
           (SETELT $ 6 |s|) (EXIT |ss|))))) 

(DEFUN |DFLOAT;OMwrite;$S;2| (|x| $)
  (PROG (|sp| |dev| |s|)
    (RETURN
      (SEQ (LETT |s| "" . #0=(|DFLOAT;OMwrite;$S;2|))
           (LETT |sp| (OM-STRINGTOSTRINGPTR |s|) . #0#)
           (LETT |dev|
                 (SPADCALL |sp| (SPADCALL (QREFELT $ 10))
                     (QREFELT $ 12)) . #0#)
           (SPADCALL |dev| (QREFELT $ 14))
           (SPADCALL |dev| |x| (QREFELT $ 16))
           (SPADCALL |dev| (QREFELT $ 17))
           (SPADCALL |dev| (QREFELT $ 18))
           (LETT |s| (OM-STRINGPTRTOSTRING |sp|) . #0#) (EXIT |s|))))) 

(DEFUN |DFLOAT;OMwrite;$BS;3| (|x| |wholeObj| $)
  (PROG (|sp| |dev| |s|)
    (RETURN
      (SEQ (LETT |s| "" . #0=(|DFLOAT;OMwrite;$BS;3|))
           (LETT |sp| (OM-STRINGTOSTRINGPTR |s|) . #0#)
           (LETT |dev|
                 (SPADCALL |sp| (SPADCALL (QREFELT $ 10))
                     (QREFELT $ 12)) . #0#)
           (COND (|wholeObj| (SPADCALL |dev| (QREFELT $ 14))))
           (SPADCALL |dev| |x| (QREFELT $ 16))
           (COND (|wholeObj| (SPADCALL |dev| (QREFELT $ 17))))
           (SPADCALL |dev| (QREFELT $ 18))
           (LETT |s| (OM-STRINGPTRTOSTRING |sp|) . #0#) (EXIT |s|))))) 

(DEFUN |DFLOAT;OMwrite;Omd$V;4| (|dev| |x| $)
  (SEQ (SPADCALL |dev| (QREFELT $ 14))
       (SPADCALL |dev| |x| (QREFELT $ 16))
       (EXIT (SPADCALL |dev| (QREFELT $ 17))))) 

(DEFUN |DFLOAT;OMwrite;Omd$BV;5| (|dev| |x| |wholeObj| $)
  (SEQ (COND (|wholeObj| (SPADCALL |dev| (QREFELT $ 14))))
       (SPADCALL |dev| |x| (QREFELT $ 16))
       (EXIT (COND (|wholeObj| (SPADCALL |dev| (QREFELT $ 17))))))) 

(PUT '|DFLOAT;checkComplex| '|SPADreplace| 'C-TO-R) 

(DEFUN |DFLOAT;checkComplex| (|x| $) (C-TO-R |x|)) 

(PUT '|DFLOAT;base;Pi;7| '|SPADreplace| '(XLAM NIL (FLOAT-RADIX 0.0))) 

(DEFUN |DFLOAT;base;Pi;7| ($) (FLOAT-RADIX 0.0)) 

(DEFUN |DFLOAT;mantissa;$I;8| (|x| $) (QCAR (|DFLOAT;manexp| |x| $))) 

(DEFUN |DFLOAT;exponent;$I;9| (|x| $) (QCDR (|DFLOAT;manexp| |x| $))) 

(PUT '|DFLOAT;precision;Pi;10| '|SPADreplace|
     '(XLAM NIL (FLOAT-DIGITS 0.0))) 

(DEFUN |DFLOAT;precision;Pi;10| ($) (FLOAT-DIGITS 0.0)) 

(DEFUN |DFLOAT;bits;Pi;11| ($)
  (PROG (#0=#:G1842)
    (RETURN
      (COND
        ((EQL (FLOAT-RADIX 0.0) 2) (FLOAT-DIGITS 0.0))
        ((EQL (FLOAT-RADIX 0.0) 16) (* 4 (FLOAT-DIGITS 0.0)))
        ('T
         (PROG1 (LETT #0#
                      (TRUNCATE
                          (SPADCALL (FLOAT-DIGITS 0.0)
                              (SPADCALL
                                  (FLOAT (FLOAT-RADIX 0.0)
                                         MOST-POSITIVE-DOUBLE-FLOAT)
                                  (QREFELT $ 30))
                              (QREFELT $ 31)))
                      |DFLOAT;bits;Pi;11|)
           (|check-subtype| (> #0# 0) '(|PositiveInteger|) #0#))))))) 

(PUT '|DFLOAT;max;$;12| '|SPADreplace|
     '(XLAM NIL MOST-POSITIVE-DOUBLE-FLOAT)) 

(DEFUN |DFLOAT;max;$;12| ($) MOST-POSITIVE-DOUBLE-FLOAT) 

(PUT '|DFLOAT;min;$;13| '|SPADreplace|
     '(XLAM NIL MOST-NEGATIVE-DOUBLE-FLOAT)) 

(DEFUN |DFLOAT;min;$;13| ($) MOST-NEGATIVE-DOUBLE-FLOAT) 

(DEFUN |DFLOAT;order;$I;14| (|a| $)
  (- (+ (FLOAT-DIGITS 0.0) (SPADCALL |a| (QREFELT $ 28))) 1)) 

(PUT '|DFLOAT;Zero;$;15| '|SPADreplace|
     '(XLAM NIL (FLOAT 0 MOST-POSITIVE-DOUBLE-FLOAT))) 

(DEFUN |DFLOAT;Zero;$;15| ($) (FLOAT 0 MOST-POSITIVE-DOUBLE-FLOAT)) 

(PUT '|DFLOAT;One;$;16| '|SPADreplace|
     '(XLAM NIL (FLOAT 1 MOST-POSITIVE-DOUBLE-FLOAT))) 

(DEFUN |DFLOAT;One;$;16| ($) (FLOAT 1 MOST-POSITIVE-DOUBLE-FLOAT)) 

(DEFUN |DFLOAT;exp1;$;17| ($)
  (/ (FLOAT 534625820200 MOST-POSITIVE-DOUBLE-FLOAT)
     (FLOAT 196677847971 MOST-POSITIVE-DOUBLE-FLOAT))) 

(PUT '|DFLOAT;pi;$;18| '|SPADreplace|
     '(XLAM NIL (FLOAT PI MOST-POSITIVE-DOUBLE-FLOAT))) 

(DEFUN |DFLOAT;pi;$;18| ($) (FLOAT PI MOST-POSITIVE-DOUBLE-FLOAT)) 

(DEFUN |DFLOAT;coerce;$Of;19| (|x| $)
  (COND
    ((< |x| 0.0)
     (SPADCALL
         (SPADCALL (FORMAT NIL (QREFELT $ 6) (- |x|)) (QREFELT $ 41))
         (QREFELT $ 42)))
    ('T (SPADCALL (FORMAT NIL (QREFELT $ 6) |x|) (QREFELT $ 41))))) 

(DEFUN |DFLOAT;convert;$If;20| (|x| $) (SPADCALL |x| (QREFELT $ 45))) 

(PUT '|DFLOAT;<;2$B;21| '|SPADreplace| '<) 

(DEFUN |DFLOAT;<;2$B;21| (|x| |y| $) (< |x| |y|)) 

(PUT '|DFLOAT;-;2$;22| '|SPADreplace| '-) 

(DEFUN |DFLOAT;-;2$;22| (|x| $) (- |x|)) 

(PUT '|DFLOAT;+;3$;23| '|SPADreplace| '+) 

(DEFUN |DFLOAT;+;3$;23| (|x| |y| $) (+ |x| |y|)) 

(PUT '|DFLOAT;-;3$;24| '|SPADreplace| '-) 

(DEFUN |DFLOAT;-;3$;24| (|x| |y| $) (- |x| |y|)) 

(PUT '|DFLOAT;*;3$;25| '|SPADreplace| '*) 

(DEFUN |DFLOAT;*;3$;25| (|x| |y| $) (* |x| |y|)) 

(PUT '|DFLOAT;*;I2$;26| '|SPADreplace| '*) 

(DEFUN |DFLOAT;*;I2$;26| (|i| |x| $) (* |i| |x|)) 

(PUT '|DFLOAT;max;3$;27| '|SPADreplace| 'MAX) 

(DEFUN |DFLOAT;max;3$;27| (|x| |y| $) (MAX |x| |y|)) 

(PUT '|DFLOAT;min;3$;28| '|SPADreplace| 'MIN) 

(DEFUN |DFLOAT;min;3$;28| (|x| |y| $) (MIN |x| |y|)) 

(PUT '|DFLOAT;=;2$B;29| '|SPADreplace| '=) 

(DEFUN |DFLOAT;=;2$B;29| (|x| |y| $) (= |x| |y|)) 

(PUT '|DFLOAT;/;$I$;30| '|SPADreplace| '/) 

(DEFUN |DFLOAT;/;$I$;30| (|x| |i| $) (/ |x| |i|)) 

(DEFUN |DFLOAT;sqrt;2$;31| (|x| $)
  (|DFLOAT;checkComplex| (SQRT |x|) $)) 

(DEFUN |DFLOAT;log10;2$;32| (|x| $)
  (|DFLOAT;checkComplex| (|log| |x|) $)) 

(PUT '|DFLOAT;**;$I$;33| '|SPADreplace| 'EXPT) 

(DEFUN |DFLOAT;**;$I$;33| (|x| |i| $) (EXPT |x| |i|)) 

(DEFUN |DFLOAT;**;3$;34| (|x| |y| $)
  (|DFLOAT;checkComplex| (EXPT |x| |y|) $)) 

(PUT '|DFLOAT;coerce;I$;35| '|SPADreplace|
     '(XLAM (|i|) (FLOAT |i| MOST-POSITIVE-DOUBLE-FLOAT))) 

(DEFUN |DFLOAT;coerce;I$;35| (|i| $)
  (FLOAT |i| MOST-POSITIVE-DOUBLE-FLOAT)) 

(PUT '|DFLOAT;exp;2$;36| '|SPADreplace| 'EXP) 

(DEFUN |DFLOAT;exp;2$;36| (|x| $) (EXP |x|)) 

(DEFUN |DFLOAT;log;2$;37| (|x| $) (|DFLOAT;checkComplex| (LOG |x|) $)) 

(DEFUN |DFLOAT;log2;2$;38| (|x| $)
  (|DFLOAT;checkComplex| (LOG2 |x|) $)) 

(PUT '|DFLOAT;sin;2$;39| '|SPADreplace| 'SIN) 

(DEFUN |DFLOAT;sin;2$;39| (|x| $) (SIN |x|)) 

(PUT '|DFLOAT;cos;2$;40| '|SPADreplace| 'COS) 

(DEFUN |DFLOAT;cos;2$;40| (|x| $) (COS |x|)) 

(PUT '|DFLOAT;tan;2$;41| '|SPADreplace| 'TAN) 

(DEFUN |DFLOAT;tan;2$;41| (|x| $) (TAN |x|)) 

(PUT '|DFLOAT;cot;2$;42| '|SPADreplace| 'COT) 

(DEFUN |DFLOAT;cot;2$;42| (|x| $) (COT |x|)) 

(PUT '|DFLOAT;sec;2$;43| '|SPADreplace| 'SEC) 

(DEFUN |DFLOAT;sec;2$;43| (|x| $) (SEC |x|)) 

(PUT '|DFLOAT;csc;2$;44| '|SPADreplace| 'CSC) 

(DEFUN |DFLOAT;csc;2$;44| (|x| $) (CSC |x|)) 

(DEFUN |DFLOAT;asin;2$;45| (|x| $)
  (|DFLOAT;checkComplex| (ASIN |x|) $)) 

(DEFUN |DFLOAT;acos;2$;46| (|x| $)
  (|DFLOAT;checkComplex| (ACOS |x|) $)) 

(PUT '|DFLOAT;atan;2$;47| '|SPADreplace| 'ATAN) 

(DEFUN |DFLOAT;atan;2$;47| (|x| $) (ATAN |x|)) 

(DEFUN |DFLOAT;acsc;2$;48| (|x| $)
  (|DFLOAT;checkComplex| (ACSC |x|) $)) 

(PUT '|DFLOAT;acot;2$;49| '|SPADreplace| 'ACOT) 

(DEFUN |DFLOAT;acot;2$;49| (|x| $) (ACOT |x|)) 

(DEFUN |DFLOAT;asec;2$;50| (|x| $)
  (|DFLOAT;checkComplex| (ASEC |x|) $)) 

(PUT '|DFLOAT;sinh;2$;51| '|SPADreplace| 'SINH) 

(DEFUN |DFLOAT;sinh;2$;51| (|x| $) (SINH |x|)) 

(PUT '|DFLOAT;cosh;2$;52| '|SPADreplace| 'COSH) 

(DEFUN |DFLOAT;cosh;2$;52| (|x| $) (COSH |x|)) 

(PUT '|DFLOAT;tanh;2$;53| '|SPADreplace| 'TANH) 

(DEFUN |DFLOAT;tanh;2$;53| (|x| $) (TANH |x|)) 

(PUT '|DFLOAT;csch;2$;54| '|SPADreplace| 'CSCH) 

(DEFUN |DFLOAT;csch;2$;54| (|x| $) (CSCH |x|)) 

(PUT '|DFLOAT;coth;2$;55| '|SPADreplace| 'COTH) 

(DEFUN |DFLOAT;coth;2$;55| (|x| $) (COTH |x|)) 

(PUT '|DFLOAT;sech;2$;56| '|SPADreplace| 'SECH) 

(DEFUN |DFLOAT;sech;2$;56| (|x| $) (SECH |x|)) 

(PUT '|DFLOAT;asinh;2$;57| '|SPADreplace| 'ASINH) 

(DEFUN |DFLOAT;asinh;2$;57| (|x| $) (ASINH |x|)) 

(DEFUN |DFLOAT;acosh;2$;58| (|x| $)
  (|DFLOAT;checkComplex| (ACOSH |x|) $)) 

(DEFUN |DFLOAT;atanh;2$;59| (|x| $)
  (|DFLOAT;checkComplex| (ATANH |x|) $)) 

(PUT '|DFLOAT;acsch;2$;60| '|SPADreplace| 'ACSCH) 

(DEFUN |DFLOAT;acsch;2$;60| (|x| $) (ACSCH |x|)) 

(DEFUN |DFLOAT;acoth;2$;61| (|x| $)
  (|DFLOAT;checkComplex| (ACOTH |x|) $)) 

(DEFUN |DFLOAT;asech;2$;62| (|x| $)
  (|DFLOAT;checkComplex| (ASECH |x|) $)) 

(PUT '|DFLOAT;/;3$;63| '|SPADreplace| '/) 

(DEFUN |DFLOAT;/;3$;63| (|x| |y| $) (/ |x| |y|)) 

(PUT '|DFLOAT;negative?;$B;64| '|SPADreplace| 'MINUSP) 

(DEFUN |DFLOAT;negative?;$B;64| (|x| $) (MINUSP |x|)) 

(PUT '|DFLOAT;zero?;$B;65| '|SPADreplace| 'ZEROP) 

(DEFUN |DFLOAT;zero?;$B;65| (|x| $) (ZEROP |x|)) 

(PUT '|DFLOAT;hash;$I;66| '|SPADreplace| 'HASHEQ) 

(DEFUN |DFLOAT;hash;$I;66| (|x| $) (HASHEQ |x|)) 

(DEFUN |DFLOAT;recip;$U;67| (|x| $)
  (COND ((ZEROP |x|) (CONS 1 "failed")) ('T (CONS 0 (/ 1.0 |x|))))) 

(PUT '|DFLOAT;differentiate;2$;68| '|SPADreplace| '(XLAM (|x|) 0.0)) 

(DEFUN |DFLOAT;differentiate;2$;68| (|x| $) 0.0) 

(DEFUN |DFLOAT;airyAi;2$;69| (|x| $) (SPADCALL |x| (QREFELT $ 96))) 

(DEFUN |DFLOAT;airyBi;2$;70| (|x| $) (SPADCALL |x| (QREFELT $ 98))) 

(DEFUN |DFLOAT;besselI;3$;71| (|x| |y| $)
  (SPADCALL |x| |y| (QREFELT $ 100))) 

(DEFUN |DFLOAT;besselJ;3$;72| (|x| |y| $)
  (SPADCALL |x| |y| (QREFELT $ 102))) 

(DEFUN |DFLOAT;besselK;3$;73| (|x| |y| $)
  (SPADCALL |x| |y| (QREFELT $ 104))) 

(DEFUN |DFLOAT;besselY;3$;74| (|x| |y| $)
  (SPADCALL |x| |y| (QREFELT $ 106))) 

(DEFUN |DFLOAT;Beta;3$;75| (|x| |y| $)
  (SPADCALL |x| |y| (QREFELT $ 108))) 

(DEFUN |DFLOAT;digamma;2$;76| (|x| $) (SPADCALL |x| (QREFELT $ 110))) 

(DEFUN |DFLOAT;Gamma;2$;77| (|x| $) (SPADCALL |x| (QREFELT $ 112))) 

(DEFUN |DFLOAT;polygamma;3$;78| (|x| |y| $)
  (PROG (|n| #0=#:G1924)
    (RETURN
      (SEQ (LETT |n| (SPADCALL |x| (QREFELT $ 115))
                 . #1=(|DFLOAT;polygamma;3$;78|))
           (EXIT (COND
                   ((QEQCAR |n| 0)
                    (COND
                      ((< (QCDR |n|) 0)
                       (|error| "polygamma: first argument should be a nonnegative integer"))
                      (#2='T
                       (SPADCALL
                           (PROG1 (LETT #0# (QCDR |n|) . #1#)
                             (|check-subtype| (>= #0# 0)
                                 '(|NonNegativeInteger|) #0#))
                           |y| (QREFELT $ 117)))))
                   (#2#
                    (|error| "polygamma: first argument should be a nonnegative integer")))))))) 

(PUT '|DFLOAT;wholePart;$I;79| '|SPADreplace| 'TRUNCATE) 

(DEFUN |DFLOAT;wholePart;$I;79| (|x| $) (TRUNCATE |x|)) 

(DEFUN |DFLOAT;float;2IPi$;80| (|ma| |ex| |b| $)
  (* |ma| (EXPT (FLOAT |b| MOST-POSITIVE-DOUBLE-FLOAT) |ex|))) 

(PUT '|DFLOAT;convert;2$;81| '|SPADreplace| '(XLAM (|x|) |x|)) 

(DEFUN |DFLOAT;convert;2$;81| (|x| $) |x|) 

(DEFUN |DFLOAT;convert;$F;82| (|x| $) (SPADCALL |x| (QREFELT $ 123))) 

(DEFUN |DFLOAT;rationalApproximation;$NniF;83| (|x| |d| $)
  (SPADCALL |x| |d| 10 (QREFELT $ 126))) 

(DEFUN |DFLOAT;atan;3$;84| (|x| |y| $)
  (PROG (|theta|)
    (RETURN
      (SEQ (COND
             ((= |x| 0.0)
              (COND
                ((< 0.0 |y|)
                 (/ (FLOAT PI MOST-POSITIVE-DOUBLE-FLOAT) 2))
                ((< |y| 0.0)
                 (- (/ (FLOAT PI MOST-POSITIVE-DOUBLE-FLOAT) 2)))
                (#0='T 0.0)))
             (#0#
              (SEQ (LETT |theta| (ATAN (FLOAT-SIGN 1.0 (/ |y| |x|)))
                         . #1=(|DFLOAT;atan;3$;84|))
                   (COND
                     ((< |x| 0.0)
                      (LETT |theta|
                            (- (FLOAT PI MOST-POSITIVE-DOUBLE-FLOAT)
                               |theta|) . #1#)))
                   (COND
                     ((< |y| 0.0) (LETT |theta| (- |theta|) . #1#)))
                   (EXIT |theta|)))))))) 

(DEFUN |DFLOAT;retract;$F;85| (|x| $)
  (PROG (#0=#:G1934)
    (RETURN
      (SPADCALL |x|
          (PROG1 (LETT #0# (- (FLOAT-DIGITS 0.0) 1)
                       |DFLOAT;retract;$F;85|)
            (|check-subtype| (>= #0# 0) '(|NonNegativeInteger|) #0#))
          (FLOAT-RADIX 0.0) (QREFELT $ 126))))) 

(DEFUN |DFLOAT;retractIfCan;$U;86| (|x| $)
  (PROG (#0=#:G1939)
    (RETURN
      (CONS 0
            (SPADCALL |x|
                (PROG1 (LETT #0# (- (FLOAT-DIGITS 0.0) 1)
                             |DFLOAT;retractIfCan;$U;86|)
                  (|check-subtype| (>= #0# 0) '(|NonNegativeInteger|)
                      #0#))
                (FLOAT-RADIX 0.0) (QREFELT $ 126)))))) 

(DEFUN |DFLOAT;retract;$I;87| (|x| $)
  (PROG (|n|)
    (RETURN
      (SEQ (LETT |n| (TRUNCATE |x|) |DFLOAT;retract;$I;87|)
           (EXIT (COND
                   ((= |x| (FLOAT |n| MOST-POSITIVE-DOUBLE-FLOAT)) |n|)
                   ('T (|error| "Not an integer")))))))) 

(DEFUN |DFLOAT;retractIfCan;$U;88| (|x| $)
  (PROG (|n|)
    (RETURN
      (SEQ (LETT |n| (TRUNCATE |x|) |DFLOAT;retractIfCan;$U;88|)
           (EXIT (COND
                   ((= |x| (FLOAT |n| MOST-POSITIVE-DOUBLE-FLOAT))
                    (CONS 0 |n|))
                   ('T (CONS 1 "failed")))))))) 

(DEFUN |DFLOAT;sign;$I;89| (|x| $)
  (SPADCALL (FLOAT-SIGN |x| 1.0) (QREFELT $ 132))) 

(PUT '|DFLOAT;abs;2$;90| '|SPADreplace|
     '(XLAM (|x|) (FLOAT-SIGN 1.0 |x|))) 

(DEFUN |DFLOAT;abs;2$;90| (|x| $) (FLOAT-SIGN 1.0 |x|)) 

(DEFUN |DFLOAT;manexp| (|x| $)
  (PROG (|s| #0=#:G1957 |me| |two53|)
    (RETURN
      (SEQ (EXIT (COND
                   ((ZEROP |x|) (CONS 0 0))
                   ('T
                    (SEQ (LETT |s| (SPADCALL |x| (QREFELT $ 134))
                               . #1=(|DFLOAT;manexp|))
                         (LETT |x| (FLOAT-SIGN 1.0 |x|) . #1#)
                         (COND
                           ((< MOST-POSITIVE-DOUBLE-FLOAT |x|)
                            (PROGN
                              (LETT #0#
                                    (CONS
                                     (+
                                      (* |s|
                                       (SPADCALL
                                        MOST-POSITIVE-DOUBLE-FLOAT
                                        (QREFELT $ 27)))
                                      1)
                                     (SPADCALL
                                      MOST-POSITIVE-DOUBLE-FLOAT
                                      (QREFELT $ 28))) . #1#)
                              (GO #0#))))
                         (LETT |me| (MANEXP |x|) . #1#)
                         (LETT |two53|
                               (EXPT (FLOAT-RADIX 0.0)
                                     (FLOAT-DIGITS 0.0)) . #1#)
                         (EXIT (CONS (* |s|
                                      (TRUNCATE
                                       (* |two53| (QCAR |me|))))
                                     (- (QCDR |me|) (FLOAT-DIGITS 0.0))))))))
           #0# (EXIT #0#))))) 

(DEFUN |DFLOAT;rationalApproximation;$2NniF;92| (|f| |d| |b| $)
  (PROG (|#G116| |nu| |ex| BASE #0=#:G1960 |de| |tol| |#G117| |q| |r|
                 |p2| |q2| #1=#:G1978 |#G118| |#G119| |p0| |p1| |#G120|
                 |#G121| |q0| |q1| |#G122| |#G123| |s| |t| #2=#:G1976)
    (RETURN
      (SEQ (EXIT (SEQ (PROGN
                        (LETT |#G116| (|DFLOAT;manexp| |f| $)
                              . #3=(|DFLOAT;rationalApproximation;$2NniF;92|))
                        (LETT |nu| (QCAR |#G116|) . #3#)
                        (LETT |ex| (QCDR |#G116|) . #3#)
                        |#G116|)
                      (LETT BASE (FLOAT-RADIX 0.0) . #3#)
                      (EXIT (COND
                              ((< |ex| 0)
                               (SEQ (LETT |de|
                                     (EXPT BASE
                                      (PROG1 (LETT #0# (- |ex|) . #3#)
                                        (|check-subtype| (>= #0# 0)
                                         '(|NonNegativeInteger|) #0#))) . #3#)
                                    (EXIT
                                     (COND
                                       ((< |b| 2)
                                        (|error| "base must be > 1"))
                                       (#4='T
                                        (SEQ
                                         (LETT |tol|
                                          (EXPT |b| |d|) . #3#)
                                         (LETT |s| |nu| . #3#)
                                         (LETT |t| |de| . #3#)
                                         (LETT |p0| 0 . #3#)
                                         (LETT |p1| 1 . #3#)
                                         (LETT |q0| 1 . #3#)
                                         (LETT |q1| 0 . #3#)
                                         (EXIT
                                          (SEQ G190 NIL
                                           (SEQ
                                            (PROGN
                                              (LETT |#G117|
                                               (DIVIDE2 |s| |t|) . #3#)
                                              (LETT |q|
                                               (QCAR |#G117|) . #3#)
                                              (LETT |r|
                                               (QCDR |#G117|) . #3#)
                                              |#G117|)
                                            (LETT |p2|
                                             (+ (* |q| |p1|) |p0|) . #3#)
                                            (LETT |q2|
                                             (+ (* |q| |q1|) |q0|) . #3#)
                                            (COND
                                              ((OR (EQL |r| 0)
                                                (<
                                                 (SPADCALL |tol|
                                                  (ABS
                                                   (- (* |nu| |q2|)
                                                    (* |de| |p2|)))
                                                  (QREFELT $ 138))
                                                 (* |de| (ABS |p2|))))
                                               (EXIT
                                                (PROGN
                                                  (LETT #1#
                                                   (SPADCALL |p2| |q2|
                                                    (QREFELT $ 137)) . #3#)
                                                  (GO #1#)))))
                                            (PROGN
                                              (LETT |#G118| |p1| . #3#)
                                              (LETT |#G119| |p2| . #3#)
                                              (LETT |p0| |#G118| . #3#)
                                              (LETT |p1| |#G119| . #3#))
                                            (PROGN
                                              (LETT |#G120| |q1| . #3#)
                                              (LETT |#G121| |q2| . #3#)
                                              (LETT |q0| |#G120| . #3#)
                                              (LETT |q1| |#G121| . #3#))
                                            (EXIT
                                             (PROGN
                                               (LETT |#G122| |t| . #3#)
                                               (LETT |#G123| |r| . #3#)
                                               (LETT |s| |#G122| . #3#)
                                               (LETT |t| |#G123| . #3#))))
                                           NIL (GO G190) G191
                                           (EXIT NIL)))))))))
                              (#4#
                               (SPADCALL
                                   (* |nu|
                                    (EXPT BASE
                                     (PROG1 (LETT #2# |ex| . #3#)
                                       (|check-subtype| (>= #2# 0)
                                        '(|NonNegativeInteger|) #2#))))
                                   (QREFELT $ 139)))))))
           #1# (EXIT #1#))))) 

(DEFUN |DFLOAT;**;$F$;93| (|x| |r| $)
  (PROG (|n| |d| #0=#:G1987)
    (RETURN
      (SEQ (EXIT (COND
                   ((ZEROP |x|)
                    (COND
                      ((SPADCALL |r| (QREFELT $ 140))
                       (|error| "0**0 is undefined"))
                      ((SPADCALL |r| (QREFELT $ 141))
                       (|error| "division by 0"))
                      ('T 0.0)))
                   ((OR (SPADCALL |r| (QREFELT $ 140)) (= |x| 1.0))
                    1.0)
                   ('T
                    (COND
                      ((SPADCALL |r| (|spadConstant| $ 142)
                           (QREFELT $ 143))
                       |x|)
                      ('T
                       (SEQ (LETT |n| (SPADCALL |r| (QREFELT $ 144))
                                  . #1=(|DFLOAT;**;$F$;93|))
                            (LETT |d|
                                  (SPADCALL |r| (QREFELT $ 145)) . #1#)
                            (EXIT (COND
                                    ((MINUSP |x|)
                                     (COND
                                       ((ODDP |d|)
                                        (COND
                                          ((ODDP |n|)
                                           (PROGN
                                             (LETT #0#
                                              (-
                                               (SPADCALL (- |x|) |r|
                                                (QREFELT $ 146))) . #1#)
                                             (GO #0#)))
                                          ('T
                                           (PROGN
                                             (LETT #0#
                                              (SPADCALL (- |x|) |r|
                                               (QREFELT $ 146)) . #1#)
                                             (GO #0#)))))
                                       ('T (|error| "negative root"))))
                                    ((EQL |d| 2)
                                     (EXPT
                                      (SPADCALL |x| (QREFELT $ 57))
                                      |n|))
                                    ('T
                                     (SPADCALL |x|
                                      (/
                                       (FLOAT |n|
                                        MOST-POSITIVE-DOUBLE-FLOAT)
                                       (FLOAT |d|
                                        MOST-POSITIVE-DOUBLE-FLOAT))
                                      (QREFELT $ 60)))))))))))
           #0# (EXIT #0#))))) 

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

(DEFUN |DoubleFloat;| ()
  (PROG (|dv$| $ |pv$|)
    (RETURN
      (PROGN
        (LETT |dv$| '(|DoubleFloat|) . #0=(|DoubleFloat|))
        (LETT $ (GETREFV 160) . #0#)
        (QSETREFV $ 0 |dv$|)
        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
        (|haddProp| |$ConstructorCache| '|DoubleFloat| NIL (CONS 1 $))
        (|stuffDomainSlots| $)
        (AND (|HasCategory| $ '(|arbitraryPrecision|))
             (|augmentPredVector| $ 1))
        (AND (|not| (|HasCategory| $ '(|arbitraryExponent|)))
             (|not| (|HasCategory| $ '(|arbitraryPrecision|)))
             (|augmentPredVector| $ 2))
        (QSETREFV $ 6 "~A")
        $)))) 

(MAKEPROP '|DoubleFloat| '|infovec|
    (LIST '#(NIL NIL NIL NIL NIL NIL '|format| (|String|)
             |DFLOAT;doubleFloatFormat;2S;1| (|OpenMathEncoding|)
             (0 . |OMencodingXML|) (|OpenMathDevice|)
             (4 . |OMopenString|) (|Void|) (10 . |OMputObject|)
             (|DoubleFloat|) (15 . |OMputFloat|)
             (21 . |OMputEndObject|) (26 . |OMclose|)
             |DFLOAT;OMwrite;$S;2| (|Boolean|) |DFLOAT;OMwrite;$BS;3|
             |DFLOAT;OMwrite;Omd$V;4| |DFLOAT;OMwrite;Omd$BV;5|
             (|PositiveInteger|) |DFLOAT;base;Pi;7| (|Integer|)
             |DFLOAT;mantissa;$I;8| |DFLOAT;exponent;$I;9|
             |DFLOAT;precision;Pi;10| |DFLOAT;log2;2$;38| (31 . *)
             |DFLOAT;bits;Pi;11| |DFLOAT;max;$;12| |DFLOAT;min;$;13|
             |DFLOAT;order;$I;14|
             (CONS IDENTITY
                   (FUNCALL (|dispatchFunction| |DFLOAT;Zero;$;15|) $))
             (CONS IDENTITY
                   (FUNCALL (|dispatchFunction| |DFLOAT;One;$;16|) $))
             |DFLOAT;exp1;$;17| |DFLOAT;pi;$;18| (|OutputForm|)
             (37 . |message|) (42 . -) |DFLOAT;coerce;$Of;19|
             (|InputForm|) (47 . |convert|) |DFLOAT;convert;$If;20|
             |DFLOAT;<;2$B;21| |DFLOAT;-;2$;22| |DFLOAT;+;3$;23|
             |DFLOAT;-;3$;24| |DFLOAT;*;3$;25| |DFLOAT;*;I2$;26|
             |DFLOAT;max;3$;27| |DFLOAT;min;3$;28| |DFLOAT;=;2$B;29|
             |DFLOAT;/;$I$;30| |DFLOAT;sqrt;2$;31| |DFLOAT;log10;2$;32|
             |DFLOAT;**;$I$;33| |DFLOAT;**;3$;34| |DFLOAT;coerce;I$;35|
             |DFLOAT;exp;2$;36| |DFLOAT;log;2$;37| |DFLOAT;sin;2$;39|
             |DFLOAT;cos;2$;40| |DFLOAT;tan;2$;41| |DFLOAT;cot;2$;42|
             |DFLOAT;sec;2$;43| |DFLOAT;csc;2$;44| |DFLOAT;asin;2$;45|
             |DFLOAT;acos;2$;46| |DFLOAT;atan;2$;47|
             |DFLOAT;acsc;2$;48| |DFLOAT;acot;2$;49|
             |DFLOAT;asec;2$;50| |DFLOAT;sinh;2$;51|
             |DFLOAT;cosh;2$;52| |DFLOAT;tanh;2$;53|
             |DFLOAT;csch;2$;54| |DFLOAT;coth;2$;55|
             |DFLOAT;sech;2$;56| |DFLOAT;asinh;2$;57|
             |DFLOAT;acosh;2$;58| |DFLOAT;atanh;2$;59|
             |DFLOAT;acsch;2$;60| |DFLOAT;acoth;2$;61|
             |DFLOAT;asech;2$;62| |DFLOAT;/;3$;63|
             |DFLOAT;negative?;$B;64| |DFLOAT;zero?;$B;65|
             |DFLOAT;hash;$I;66| (|Union| $ '"failed")
             |DFLOAT;recip;$U;67| |DFLOAT;differentiate;2$;68|
             (|DoubleFloatSpecialFunctions|) (52 . |airyAi|)
             |DFLOAT;airyAi;2$;69| (57 . |airyBi|)
             |DFLOAT;airyBi;2$;70| (62 . |besselI|)
             |DFLOAT;besselI;3$;71| (68 . |besselJ|)
             |DFLOAT;besselJ;3$;72| (74 . |besselK|)
             |DFLOAT;besselK;3$;73| (80 . |besselY|)
             |DFLOAT;besselY;3$;74| (86 . |Beta|) |DFLOAT;Beta;3$;75|
             (92 . |digamma|) |DFLOAT;digamma;2$;76| (97 . |Gamma|)
             |DFLOAT;Gamma;2$;77| (|Union| 26 '"failed")
             (102 . |retractIfCan|) (|NonNegativeInteger|)
             (107 . |polygamma|) |DFLOAT;polygamma;3$;78|
             |DFLOAT;wholePart;$I;79| |DFLOAT;float;2IPi$;80|
             |DFLOAT;convert;2$;81| (|Float|) (113 . |convert|)
             |DFLOAT;convert;$F;82| (|Fraction| 26)
             |DFLOAT;rationalApproximation;$2NniF;92|
             |DFLOAT;rationalApproximation;$NniF;83|
             |DFLOAT;atan;3$;84| |DFLOAT;retract;$F;85|
             (|Union| 125 '"failed") |DFLOAT;retractIfCan;$U;86|
             |DFLOAT;retract;$I;87| |DFLOAT;retractIfCan;$U;88|
             |DFLOAT;sign;$I;89| |DFLOAT;abs;2$;90| (118 . |Zero|)
             (122 . /) (128 . *) (134 . |coerce|) (139 . |zero?|)
             (144 . |negative?|) (149 . |One|) (153 . =)
             (159 . |numer|) (164 . |denom|) |DFLOAT;**;$F$;93|
             (|Pattern| 122) (|PatternMatchResult| 122 $)
             (|Factored| $) (|Union| 151 '"failed") (|List| $)
             (|Record| (|:| |coef1| $) (|:| |coef2| $)
                 (|:| |generator| $))
             (|Record| (|:| |coef1| $) (|:| |coef2| $))
             (|Union| 153 '"failed")
             (|Record| (|:| |quotient| $) (|:| |remainder| $))
             (|SparseUnivariatePolynomial| $)
             (|Record| (|:| |coef| 151) (|:| |generator| $))
             (|Record| (|:| |unit| $) (|:| |canonical| $)
                 (|:| |associate| $))
             (|SingleInteger|))
          '#(~= 169 |zero?| 175 |wholePart| 180 |unitNormal| 185
             |unitCanonical| 190 |unit?| 195 |truncate| 200 |tanh| 205
             |tan| 210 |subtractIfCan| 215 |squareFreePart| 221
             |squareFree| 226 |sqrt| 231 |sizeLess?| 236 |sinh| 242
             |sin| 247 |sign| 252 |sech| 257 |sec| 262 |sample| 267
             |round| 271 |retractIfCan| 276 |retract| 286 |rem| 296
             |recip| 302 |rationalApproximation| 307 |quo| 320
             |principalIdeal| 326 |prime?| 331 |precision| 336
             |positive?| 345 |polygamma| 350 |pi| 356 |patternMatch|
             360 |order| 367 |one?| 372 |nthRoot| 377 |norm| 383
             |negative?| 388 |multiEuclidean| 393 |min| 399 |max| 409
             |mantissa| 419 |log2| 424 |log10| 429 |log| 434 |lcm| 439
             |latex| 450 |inv| 455 |increasePrecision| 460 |hash| 465
             |gcdPolynomial| 475 |gcd| 481 |fractionPart| 492 |floor|
             497 |float| 502 |factor| 515 |extendedEuclidean| 520
             |exquo| 533 |expressIdealMember| 539 |exponent| 545 |exp1|
             550 |exp| 554 |euclideanSize| 559 |doubleFloatFormat| 564
             |divide| 569 |digits| 575 |digamma| 584 |differentiate|
             589 |decreasePrecision| 600 |csch| 605 |csc| 610 |coth|
             615 |cot| 620 |cosh| 625 |cos| 630 |convert| 635 |coerce|
             655 |characteristic| 685 |ceiling| 689 |bits| 694
             |besselY| 703 |besselK| 709 |besselJ| 715 |besselI| 721
             |base| 727 |atanh| 731 |atan| 736 |associates?| 747
             |asinh| 753 |asin| 758 |asech| 763 |asec| 768 |airyBi| 773
             |airyAi| 778 |acsch| 783 |acsc| 788 |acoth| 793 |acot| 798
             |acosh| 803 |acos| 808 |abs| 813 ^ 818 |Zero| 836 |One|
             840 |OMwrite| 844 |Gamma| 868 D 879 |Beta| 890 >= 896 >
             902 = 908 <= 914 < 920 / 926 - 938 + 949 ** 955 * 985)
          '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))
                (CONS '#(|FloatingPointSystem&| |RealNumberSystem&|
                         |Field&| |EuclideanDomain&| NIL
                         |UniqueFactorizationDomain&| |GcdDomain&|
                         |DivisionRing&| |IntegralDomain&| |Algebra&|
                         |Algebra&| |DifferentialRing&| NIL
                         |OrderedRing&| |Module&| NIL NIL |Module&| NIL
                         NIL |Ring&| NIL NIL NIL NIL NIL NIL NIL
                         |AbelianGroup&| NIL NIL NIL NIL
                         |AbelianMonoid&| |Monoid&| NIL NIL
                         |OrderedSet&| |SemiGroup&| |AbelianSemiGroup&|
                         |TranscendentalFunctionCategory&| NIL
                         |SetCategory&| NIL NIL
                         |ElementaryFunctionCategory&| NIL
                         |HyperbolicFunctionCategory&|
                         |ArcTrigonometricFunctionCategory&|
                         |TrigonometricFunctionCategory&| 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| 125)
                               (|Algebra| $$) (|DifferentialRing|)
                               (|CharacteristicZero|) (|OrderedRing|)
                               (|Module| 125) (|EntireRing|)
                               (|CommutativeRing|) (|Module| $$)
                               (|BiModule| 125 125) (|BiModule| $$ $$)
                               (|Ring|) (|OrderedAbelianGroup|)
                               (|RightModule| 125) (|LeftModule| 125)
                               (|LeftModule| $$) (|Rng|)
                               (|RightModule| $$)
                               (|OrderedCancellationAbelianMonoid|)
                               (|AbelianGroup|)
                               (|OrderedAbelianMonoid|)
                               (|CancellationAbelianMonoid|)
                               (|SemiRing|) (|OrderedAbelianSemiGroup|)
                               (|AbelianMonoid|) (|Monoid|) (|SemiRng|)
                               (|PatternMatchable| 122) (|OrderedSet|)
                               (|SemiGroup|) (|AbelianSemiGroup|)
                               (|TranscendentalFunctionCategory|)
                               (|RealConstant|) (|SetCategory|)
                               (|ConvertibleTo| 44)
                               (|SpecialFunctionCategory|)
                               (|ElementaryFunctionCategory|)
                               (|ArcHyperbolicFunctionCategory|)
                               (|HyperbolicFunctionCategory|)
                               (|ArcTrigonometricFunctionCategory|)
                               (|TrigonometricFunctionCategory|)
                               (|OpenMath|) (|Approximate|)
                               (|ConvertibleTo| 147)
                               (|RadicalCategory|)
                               (|RetractableTo| 125)
                               (|RetractableTo| 26)
                               (|ConvertibleTo| 122)
                               (|ConvertibleTo| 15)
                               (|canonicalsClosed|)
                               (|canonicalUnitNormal|)
                               (|noZeroDivisors|) (|CommutativeStar|)
                               (|unitsKnown|) (|BasicType|)
                               (|CoercibleTo| 40))
                            (|makeByteWordVec2| 159
                                '(0 9 0 10 2 11 0 7 9 12 1 11 13 0 14 2
                                  11 13 0 15 16 1 11 13 0 17 1 11 13 0
                                  18 2 0 0 24 0 31 1 40 0 7 41 1 40 0 0
                                  42 1 44 0 15 45 1 95 15 15 96 1 95 15
                                  15 98 2 95 15 15 15 100 2 95 15 15 15
                                  102 2 95 15 15 15 104 2 95 15 15 15
                                  106 2 95 15 15 15 108 1 95 15 15 110
                                  1 95 15 15 112 1 15 114 0 115 2 95 15
                                  116 15 117 1 122 0 15 123 0 125 0 136
                                  2 125 0 26 26 137 2 26 0 116 0 138 1
                                  125 0 26 139 1 125 20 0 140 1 125 20
                                  0 141 0 125 0 142 2 125 20 0 0 143 1
                                  125 26 0 144 1 125 26 0 145 2 0 20 0
                                  0 1 1 0 20 0 90 1 0 26 0 119 1 0 158
                                  0 1 1 0 0 0 1 1 0 20 0 1 1 0 0 0 1 1
                                  0 0 0 78 1 0 0 0 66 2 0 92 0 0 1 1 0
                                  0 0 1 1 0 149 0 1 1 0 0 0 57 2 0 20 0
                                  0 1 1 0 0 0 76 1 0 0 0 64 1 0 26 0
                                  134 1 0 0 0 81 1 0 0 0 68 0 0 0 1 1 0
                                  0 0 1 1 0 130 0 131 1 0 114 0 133 1 0
                                  125 0 129 1 0 26 0 132 2 0 0 0 0 1 1
                                  0 92 0 93 2 0 125 0 116 127 3 0 125 0
                                  116 116 126 2 0 0 0 0 1 1 0 157 151 1
                                  1 0 20 0 1 1 1 24 24 1 0 0 24 29 1 0
                                  20 0 1 2 0 0 0 0 118 0 0 0 39 3 0 148
                                  0 147 148 1 1 0 26 0 35 1 0 20 0 1 2
                                  0 0 0 26 1 1 0 0 0 1 1 0 20 0 89 2 0
                                  150 151 0 1 0 2 0 34 2 0 0 0 0 54 0 2
                                  0 33 2 0 0 0 0 53 1 0 26 0 27 1 0 0 0
                                  30 1 0 0 0 58 1 0 0 0 63 2 0 0 0 0 1
                                  1 0 0 151 1 1 0 7 0 1 1 0 0 0 1 1 1
                                  24 26 1 1 0 26 0 91 1 0 159 0 1 2 0
                                  156 156 156 1 1 0 0 151 1 2 0 0 0 0 1
                                  1 0 0 0 1 1 0 0 0 1 3 0 0 26 26 24
                                  120 2 0 0 26 26 1 1 0 149 0 1 2 0 152
                                  0 0 1 3 0 154 0 0 0 1 2 0 92 0 0 1 2
                                  0 150 151 0 1 1 0 26 0 28 0 0 0 38 1
                                  0 0 0 62 1 0 116 0 1 1 0 7 7 8 2 0
                                  155 0 0 1 1 1 24 24 1 0 0 24 1 1 0 0
                                  0 111 1 0 0 0 94 2 0 0 0 116 1 1 1 24
                                  26 1 1 0 0 0 79 1 0 0 0 69 1 0 0 0 80
                                  1 0 0 0 67 1 0 0 0 77 1 0 0 0 65 1 0
                                  44 0 46 1 0 147 0 1 1 0 15 0 121 1 0
                                  122 0 124 1 0 0 125 1 1 0 0 26 61 1 0
                                  0 125 1 1 0 0 0 1 1 0 0 26 61 1 0 40
                                  0 43 0 0 116 1 1 0 0 0 1 1 1 24 24 1
                                  0 0 24 32 2 0 0 0 0 107 2 0 0 0 0 105
                                  2 0 0 0 0 103 2 0 0 0 0 101 0 0 24 25
                                  1 0 0 0 84 2 0 0 0 0 128 1 0 0 0 72 2
                                  0 20 0 0 1 1 0 0 0 82 1 0 0 0 70 1 0
                                  0 0 87 1 0 0 0 75 1 0 0 0 99 1 0 0 0
                                  97 1 0 0 0 85 1 0 0 0 73 1 0 0 0 86 1
                                  0 0 0 74 1 0 0 0 83 1 0 0 0 71 1 0 0
                                  0 135 2 0 0 0 26 1 2 0 0 0 116 1 2 0
                                  0 0 24 1 0 0 0 36 0 0 0 37 3 0 13 11
                                  0 20 23 2 0 7 0 20 21 2 0 13 11 0 22
                                  1 0 7 0 19 2 0 0 0 0 1 1 0 0 0 113 1
                                  0 0 0 1 2 0 0 0 116 1 2 0 0 0 0 109 2
                                  0 20 0 0 1 2 0 20 0 0 1 2 0 20 0 0 55
                                  2 0 20 0 0 1 2 0 20 0 0 47 2 0 0 0 26
                                  56 2 0 0 0 0 88 2 0 0 0 0 50 1 0 0 0
                                  48 2 0 0 0 0 49 2 0 0 0 0 60 2 0 0 0
                                  125 146 2 0 0 0 26 59 2 0 0 0 116 1 2
                                  0 0 0 24 1 2 0 0 0 125 1 2 0 0 125 0
                                  1 2 0 0 0 0 51 2 0 0 26 0 52 2 0 0
                                  116 0 1 2 0 0 24 0 31)))))
          '|lookupComplete|)) 

(MAKEPROP '|DoubleFloat| 'NILADIC T) 
