
(/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 (|s| |dev| |sp|)
    (RETURN
     (SEQ (LETT |s| "" . #1=(|DFLOAT;OMwrite;$S;2|))
          (LETT |sp| (OM-STRINGTOSTRINGPTR |s|) . #1#)
          (LETT |dev| (SPADCALL |sp| (SPADCALL (QREFELT $ 10)) (QREFELT $ 12))
                . #1#)
          (SPADCALL |dev| (QREFELT $ 14)) (SPADCALL |dev| |x| (QREFELT $ 16))
          (SPADCALL |dev| (QREFELT $ 17)) (SPADCALL |dev| (QREFELT $ 18))
          (LETT |s| (OM-STRINGPTRTOSTRING |sp|) . #1#) (EXIT |s|))))) 

(DEFUN |DFLOAT;OMwrite;$BS;3| (|x| |wholeObj| $)
  (PROG (|s| |dev| |sp|)
    (RETURN
     (SEQ (LETT |s| "" . #1=(|DFLOAT;OMwrite;$BS;3|))
          (LETT |sp| (OM-STRINGTOSTRINGPTR |s|) . #1#)
          (LETT |dev| (SPADCALL |sp| (SPADCALL (QREFELT $ 10)) (QREFELT $ 12))
                . #1#)
          (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|) . #1#) (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 (#1=#:G2127)
    (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 #1#
                      (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| (> #1# 0) '(|PositiveInteger|) #1#))))))) 

(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| ($)
  (DIV-DF (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
   ((SPADCALL |x| 0.0 (QREFELT $ 40))
    (SPADCALL (FORMAT NIL (QREFELT $ 6) |x|) (QREFELT $ 42)))
   ('T
    (SPADCALL
     (SPADCALL (FORMAT NIL (QREFELT $ 6) (MINUS-DF |x|)) (QREFELT $ 42))
     (QREFELT $ 43))))) 

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

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

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

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

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

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

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

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

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

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

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

(PUT '|DFLOAT;*;I2$;26| '|SPADreplace| '(XLAM (|i| |x|) (MUL-DF-I |x| |i|))) 

(DEFUN |DFLOAT;*;I2$;26| (|i| |x| $) (MUL-DF-I |x| |i|)) 

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

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

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

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

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

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

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

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

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

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

(PUT '|DFLOAT;^;$I$;33| '|SPADreplace| 'EXPT-DF-I) 

(DEFUN |DFLOAT;^;$I$;33| (|x| |i| $) (EXPT-DF-I |x| |i|)) 

(DEFUN |DFLOAT;^;3$;34| (|x| |y| $)
  (|DFLOAT;checkComplex| (EXPT-DF-DF |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-DF) 

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

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

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

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

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

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

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

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

(DEFUN |DFLOAT;tan;2$;41| (|x| $) (TAN-DF |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-DF) 

(DEFUN |DFLOAT;atan;2$;47| (|x| $) (ATAN-DF |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-DF) 

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

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

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

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

(DEFUN |DFLOAT;tanh;2$;53| (|x| $) (TANH-DF |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| 'DIV-DF) 

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

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

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

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

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

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

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

(DEFUN |DFLOAT;recip;$U;67| (|x| $)
  (COND ((ZEROP-DF |x|) (CONS 1 "failed")) ('T (CONS 0 (DIV-DF 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 $ 97))) 

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

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

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

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

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

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

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

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

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

(DEFUN |DFLOAT;lambertW;2$;79| (|x| $) (SPADCALL |x| (QREFELT $ 121))) 

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

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

(DEFUN |DFLOAT;float;2IPi$;81| (|ma| |ex| |b| $)
  (MUL-DF-I (EXPT-DF-I (FLOAT |b| MOST-POSITIVE-DOUBLE-FLOAT) |ex|) |ma|)) 

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

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

(DEFUN |DFLOAT;convert;$F;83| (|x| $) (SPADCALL |x| (QREFELT $ 127))) 

(DEFUN |DFLOAT;rationalApproximation;$NniF;84| (|x| |d| $)
  (SPADCALL |x| |d| 10 (QREFELT $ 130))) 

(DEFUN |DFLOAT;atan;3$;85| (|x| |y| $)
  (PROG (|theta|)
    (RETURN
     (SEQ
      (COND
       ((EQL-DF |x| 0.0)
        (COND
         ((SPADCALL |y| 0.0 (QREFELT $ 132))
          (DIV-DF-I (FLOAT PI MOST-POSITIVE-DOUBLE-FLOAT) 2))
         ((LESS-DF |y| 0.0)
          (MINUS-DF (DIV-DF-I (FLOAT PI MOST-POSITIVE-DOUBLE-FLOAT) 2)))
         (#1='T 0.0)))
       (#1#
        (SEQ
         (LETT |theta| (ATAN-DF (SPADCALL (DIV-DF |y| |x|) (QREFELT $ 133)))
               . #2=(|DFLOAT;atan;3$;85|))
         (COND
          ((LESS-DF |x| 0.0)
           (LETT |theta| (SUB-DF (FLOAT PI MOST-POSITIVE-DOUBLE-FLOAT) |theta|)
                 . #2#)))
         (COND ((LESS-DF |y| 0.0) (LETT |theta| (MINUS-DF |theta|) . #2#)))
         (EXIT |theta|)))))))) 

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

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

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

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

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

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

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

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

(DEFUN |DFLOAT;rationalApproximation;$2NniF;93| (|f| |d| |b| $)
  (PROG (|t| |s| |#G124| |#G123| |q1| |q0| |#G122| |#G121| |p1| |p0| |#G120|
         |#G119| #1=#:G2279 |q2| |p2| |r| |q| |#G118| |tol| |de| #2=#:G2271
         #3=#:G2269 BASE |ex| |nu| |#G117|)
    (RETURN
     (SEQ
      (EXIT
       (SEQ
        (PROGN
         (LETT |#G117| (|DFLOAT;manexp| |f| $)
               . #4=(|DFLOAT;rationalApproximation;$2NniF;93|))
         (LETT |nu| (QCAR |#G117|) . #4#)
         (LETT |ex| (QCDR |#G117|) . #4#)
         |#G117|)
        (LETT BASE (FLOAT-RADIX 0.0) . #4#)
        (EXIT
         (COND
          ((>= |ex| 0)
           (SPADCALL
            (* |nu|
               (EXPT BASE
                     (PROG1 (LETT #3# |ex| . #4#)
                       (|check-subtype| (>= #3# 0) '(|NonNegativeInteger|)
                                        #3#))))
            (QREFELT $ 142)))
          (#5='T
           (SEQ
            (LETT |de|
                  (EXPT BASE
                        (PROG1 (LETT #2# (- |ex|) . #4#)
                          (|check-subtype| (>= #2# 0) '(|NonNegativeInteger|)
                                           #2#)))
                  . #4#)
            (EXIT
             (COND ((< |b| 2) (|error| "base must be > 1"))
                   (#5#
                    (SEQ (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 |#G118| (DIVIDE2 |s| |t|) . #4#)
                                 (LETT |q| (QCAR |#G118|) . #4#)
                                 (LETT |r| (QCDR |#G118|) . #4#)
                                 |#G118|)
                                (LETT |p2| (+ (* |q| |p1|) |p0|) . #4#)
                                (LETT |q2| (+ (* |q| |q1|) |q0|) . #4#)
                                (COND
                                 ((OR (EQL |r| 0)
                                      (<
                                       (SPADCALL |tol|
                                                 (ABS
                                                  (- (* |nu| |q2|)
                                                     (* |de| |p2|)))
                                                 (QREFELT $ 144))
                                       (* |de| (ABS |p2|))))
                                  (EXIT
                                   (PROGN
                                    (LETT #1#
                                          (SPADCALL |p2| |q2| (QREFELT $ 143))
                                          . #4#)
                                    (GO #1#)))))
                                (PROGN
                                 (LETT |#G119| |p1| . #4#)
                                 (LETT |#G120| |p2| . #4#)
                                 (LETT |p0| |#G119| . #4#)
                                 (LETT |p1| |#G120| . #4#))
                                (PROGN
                                 (LETT |#G121| |q1| . #4#)
                                 (LETT |#G122| |q2| . #4#)
                                 (LETT |q0| |#G121| . #4#)
                                 (LETT |q1| |#G122| . #4#))
                                (EXIT
                                 (PROGN
                                  (LETT |#G123| |t| . #4#)
                                  (LETT |#G124| |r| . #4#)
                                  (LETT |s| |#G123| . #4#)
                                  (LETT |t| |#G124| . #4#))))
                               NIL (GO G190) G191 (EXIT NIL)))))))))))))
      #1# (EXIT #1#))))) 

(DEFUN |DFLOAT;^;$F$;94| (|x| |r| $)
  (PROG (#1=#:G2288 |d| |n|)
    (RETURN
     (SEQ
      (EXIT
       (COND
        ((ZEROP-DF |x|)
         (COND ((SPADCALL |r| (QREFELT $ 145)) (|error| "0^0 is undefined"))
               ((SPADCALL |r| (QREFELT $ 146)) (|error| "division by 0"))
               (#2='T 0.0)))
        ((OR (SPADCALL |r| (QREFELT $ 145)) (EQL-DF |x| 1.0)) 1.0)
        ('T
         (COND ((SPADCALL |r| (|spadConstant| $ 147) (QREFELT $ 148)) |x|)
               (#2#
                (SEQ
                 (LETT |n| (SPADCALL |r| (QREFELT $ 149))
                       . #3=(|DFLOAT;^;$F$;94|))
                 (LETT |d| (SPADCALL |r| (QREFELT $ 150)) . #3#)
                 (EXIT
                  (COND
                   ((MINUSP-DF |x|)
                    (COND
                     ((ODDP |d|)
                      (COND
                       ((ODDP |n|)
                        (PROGN
                         (LETT #1#
                               (MINUS-DF
                                (SPADCALL (MINUS-DF |x|) |r| (QREFELT $ 151)))
                               . #3#)
                         (GO #1#)))
                       (#2#
                        (PROGN
                         (LETT #1#
                               (SPADCALL (MINUS-DF |x|) |r| (QREFELT $ 151))
                               . #3#)
                         (GO #1#)))))
                     (#2# (|error| "negative root"))))
                   ((EQL |d| 2) (EXPT-DF-I (SPADCALL |x| (QREFELT $ 58)) |n|))
                   (#2#
                    (SPADCALL |x|
                              (DIV-DF (FLOAT |n| MOST-POSITIVE-DOUBLE-FLOAT)
                                      (FLOAT |d| MOST-POSITIVE-DOUBLE-FLOAT))
                              (QREFELT $ 61)))))))))))
      #1# (EXIT #1#))))) 

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

(DEFUN |DoubleFloat;| ()
  (PROG (|dv$| $ |pv$|)
    (RETURN
     (PROGN
      (LETT |dv$| '(|DoubleFloat|) . #1=(|DoubleFloat|))
      (LETT $ (GETREFV 165) . #1#)
      (QSETREFV $ 0 |dv$|)
      (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#))
      (|haddProp| |$ConstructorCache| '|DoubleFloat| NIL (CONS 1 $))
      (|stuffDomainSlots| $)
      (AND (|HasCategory| $ '(|arbitraryPrecision|)) (|augmentPredVector| $ 1))
      (AND (|not| (|HasCategory| $ '(|arbitraryExponent|)))
           (|not| (|HasCategory| $ '(|arbitraryPrecision|)))
           (|augmentPredVector| $ 2))
      (AND (|HasCategory| $ '(|RetractableTo| (|Integer|)))
           (|augmentPredVector| $ 4))
      (SETF |pv$| (QREFELT $ 3))
      (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| (37 . >=) (|OutputForm|)
              (43 . |message|) (48 . -) |DFLOAT;coerce;$Of;19| (|InputForm|)
              (53 . |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|) (58 . |airyAi|)
              |DFLOAT;airyAi;2$;69| (63 . |airyBi|) |DFLOAT;airyBi;2$;70|
              (68 . |besselI|) |DFLOAT;besselI;3$;71| (74 . |besselJ|)
              |DFLOAT;besselJ;3$;72| (80 . |besselK|) |DFLOAT;besselK;3$;73|
              (86 . |besselY|) |DFLOAT;besselY;3$;74| (92 . |Beta|)
              |DFLOAT;Beta;3$;75| (98 . |digamma|) |DFLOAT;digamma;2$;76|
              (103 . |Gamma|) |DFLOAT;Gamma;2$;77| (|Union| 26 '"failed")
              (108 . |retractIfCan|) (|NonNegativeInteger|) (113 . |polygamma|)
              |DFLOAT;polygamma;3$;78| (|FloatSpecialFunctions|)
              (119 . |lambertW|) |DFLOAT;lambertW;2$;79|
              |DFLOAT;wholePart;$I;80| |DFLOAT;float;2IPi$;81|
              |DFLOAT;convert;2$;82| (|Float|) (124 . |convert|)
              |DFLOAT;convert;$F;83| (|Fraction| 26)
              |DFLOAT;rationalApproximation;$2NniF;93|
              |DFLOAT;rationalApproximation;$NniF;84| (129 . >)
              |DFLOAT;abs;2$;91| |DFLOAT;atan;3$;85| |DFLOAT;retract;$F;86|
              (|Union| 129 '"failed") |DFLOAT;retractIfCan;$U;87|
              |DFLOAT;retract;$I;88| |DFLOAT;retractIfCan;$U;89|
              |DFLOAT;sign;$I;90| (135 . |Zero|) (139 . |coerce|) (144 . /)
              (150 . *) (156 . |zero?|) (161 . |negative?|) (166 . |One|)
              (170 . =) (176 . |numer|) (181 . |denom|) |DFLOAT;^;$F$;94|
              (|List| $) (|PatternMatchResult| 126 $) (|Pattern| 126)
              (|Factored| $) (|Union| 152 '#1="failed")
              (|Record| (|:| |coef1| $) (|:| |coef2| $) (|:| |generator| $))
              (|Record| (|:| |coef1| $) (|:| |coef2| $)) (|Union| 158 '#1#)
              (|Record| (|:| |quotient| $) (|:| |remainder| $))
              (|Record| (|:| |coef| 152) (|:| |generator| $))
              (|SparseUnivariatePolynomial| $)
              (|Record| (|:| |unit| $) (|:| |canonical| $) (|:| |associate| $))
              (|SingleInteger|))
           '#(~= 186 |zero?| 192 |wholePart| 197 |whittakerW| 202 |whittakerM|
              209 |weierstrassZeta| 216 |weierstrassSigma| 223
              |weierstrassPPrime| 230 |weierstrassP| 237 |weberE| 244
              |unitNormal| 250 |unitCanonical| 255 |unit?| 260 |truncate| 265
              |toString| 270 |tanh| 276 |tan| 281 |subtractIfCan| 286 |struveL|
              292 |struveH| 298 |squareFreePart| 304 |squareFree| 309 |sqrt|
              314 |smaller?| 319 |sizeLess?| 325 |sinh| 331 |sin| 336 |sign|
              341 |sech| 346 |sec| 351 |sample| 356 |round| 360 |riemannZeta|
              365 |retractIfCan| 370 |retract| 380 |rem| 390 |recip| 396
              |rationalApproximation| 401 |quo| 414 |principalIdeal| 420
              |prime?| 425 |precision| 430 |positive?| 439 |polylog| 444
              |polygamma| 450 |pi| 456 |patternMatch| 460 |order| 467 |one?|
              472 |nthRoot| 477 |norm| 483 |negative?| 488 |multiEuclidean| 493
              |min| 499 |meijerG| 509 |max| 518 |mantissa| 528 |lommelS2| 533
              |lommelS1| 540 |log2| 547 |log10| 552 |log| 557 |lerchPhi| 562
              |legendreQ| 569 |legendreP| 576 |lcm| 583 |latex| 594 |lambertW|
              599 |kummerU| 604 |kummerM| 611 |kelvinKer| 618 |kelvinKei| 624
              |kelvinBer| 630 |kelvinBei| 636 |jacobiTheta| 642 |jacobiSn| 648
              |jacobiDn| 654 |jacobiCn| 660 |inv| 666 |increasePrecision| 671
              |hypergeometricF| 676 |hash| 683 |hankelH2| 693 |hankelH1| 699
              |gcdPolynomial| 705 |gcd| 711 |fractionPart| 722 |floor| 727
              |float| 732 |factor| 745 |extendedEuclidean| 750 |exquo| 763
              |expressIdealMember| 769 |exponent| 775 |exp1| 780 |exp| 784
              |euclideanSize| 789 |ellipticPi| 794 |ellipticK| 801 |ellipticF|
              806 |ellipticE| 812 |doubleFloatFormat| 823 |divide| 828 |digits|
              834 |digamma| 843 |differentiate| 848 |decreasePrecision| 859
              |csch| 864 |csc| 869 |coth| 874 |cot| 879 |cosh| 884 |cos| 889
              |convert| 894 |coerce| 914 |characteristic| 944 |ceiling| 948
              |bits| 953 |besselY| 962 |besselK| 968 |besselJ| 974 |besselI|
              980 |base| 986 |atanh| 990 |atan| 995 |associates?| 1006 |asinh|
              1012 |asin| 1017 |asech| 1022 |asec| 1027 |angerJ| 1032
              |airyBiPrime| 1038 |airyBi| 1043 |airyAiPrime| 1048 |airyAi| 1053
              |acsch| 1058 |acsc| 1063 |acoth| 1068 |acot| 1073 |acosh| 1078
              |acos| 1083 |abs| 1088 ^ 1093 |Zero| 1123 |One| 1127 |OMwrite|
              1131 |Gamma| 1155 D 1166 |Beta| 1177 >= 1183 > 1189 = 1195 <=
              1201 < 1207 / 1213 - 1225 + 1236 * 1242)
           '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))
            (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
                |ElementaryFunctionCategory&| NIL |HyperbolicFunctionCategory&|
                |ArcTrigonometricFunctionCategory&|
                |TrigonometricFunctionCategory&| NIL NIL NIL |RadicalCategory&|
                |RetractableTo&| |RetractableTo&| NIL NIL |PartialOrder&| NIL
                NIL NIL NIL NIL |BasicType&| NIL)
             (CONS
              '#((|FloatingPointSystem|) (|RealNumberSystem|) (|Field|)
                 (|EuclideanDomain|) (|PrincipalIdealDomain|)
                 (|UniqueFactorizationDomain|) (|GcdDomain|) (|DivisionRing|)
                 (|IntegralDomain|) (|Algebra| 129) (|Algebra| $$)
                 (|DifferentialRing|) (|CharacteristicZero|) (|OrderedRing|)
                 (|Module| 129) (|EntireRing|) (|CommutativeRing|)
                 (|Module| $$) (|OrderedAbelianGroup|) (|BiModule| 129 129)
                 (|BiModule| $$ $$) (|Ring|)
                 (|OrderedCancellationAbelianMonoid|) (|RightModule| 129)
                 (|LeftModule| 129) (|LeftModule| $$) (|Rng|)
                 (|RightModule| $$) (|OrderedAbelianMonoid|) (|AbelianGroup|)
                 (|OrderedAbelianSemiGroup|) (|CancellationAbelianMonoid|)
                 (|SemiRing|) (|OrderedSet|) (|AbelianMonoid|) (|Monoid|)
                 (|SemiRng|) (|PatternMatchable| 126) (|Comparable|)
                 (|SemiGroup|) (|AbelianSemiGroup|)
                 (|TranscendentalFunctionCategory|) (|RealConstant|)
                 (|SetCategory|) (|ConvertibleTo| 45)
                 (|SpecialFunctionCategory|) (|ElementaryFunctionCategory|)
                 (|ArcHyperbolicFunctionCategory|)
                 (|HyperbolicFunctionCategory|)
                 (|ArcTrigonometricFunctionCategory|)
                 (|TrigonometricFunctionCategory|) (|OpenMath|) (|Approximate|)
                 (|ConvertibleTo| 154) (|RadicalCategory|)
                 (|RetractableTo| 129) (|RetractableTo| 26)
                 (|ConvertibleTo| 126) (|ConvertibleTo| 15) (|PartialOrder|)
                 (|canonicalsClosed|) (|canonicalUnitNormal|)
                 (|noZeroDivisors|) (|CommutativeStar|) (|unitsKnown|)
                 (|BasicType|) (|CoercibleTo| 41))
              (|makeByteWordVec2| 164
                                  '(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 2 0 20 0 0 40 1 41 0 7 42 1 41 0 0 43
                                    1 45 0 15 46 1 96 15 15 97 1 96 15 15 99 2
                                    96 15 15 15 101 2 96 15 15 15 103 2 96 15
                                    15 15 105 2 96 15 15 15 107 2 96 15 15 15
                                    109 1 96 15 15 111 1 96 15 15 113 1 15 115
                                    0 116 2 96 15 117 15 118 1 120 15 15 121 1
                                    126 0 15 127 2 0 20 0 0 132 0 129 0 141 1
                                    129 0 26 142 2 129 0 26 26 143 2 26 0 117 0
                                    144 1 129 20 0 145 1 129 20 0 146 0 129 0
                                    147 2 129 20 0 0 148 1 129 26 0 149 1 129
                                    26 0 150 2 0 20 0 0 1 1 0 20 0 91 1 0 26 0
                                    123 3 0 0 0 0 0 1 3 0 0 0 0 0 1 3 0 0 0 0 0
                                    1 3 0 0 0 0 0 1 3 0 0 0 0 0 1 3 0 0 0 0 0 1
                                    2 0 0 0 0 1 1 0 163 0 1 1 0 0 0 1 1 0 20 0
                                    1 1 0 0 0 1 2 0 7 0 117 1 1 0 0 0 79 1 0 0
                                    0 67 2 0 93 0 0 1 2 0 0 0 0 1 2 0 0 0 0 1 1
                                    0 0 0 1 1 0 155 0 1 1 0 0 0 58 2 0 20 0 0 1
                                    2 0 20 0 0 1 1 0 0 0 77 1 0 0 0 65 1 0 26 0
                                    140 1 0 0 0 82 1 0 0 0 69 0 0 0 1 1 0 0 0 1
                                    1 0 0 0 1 1 0 136 0 137 1 0 115 0 139 1 0
                                    129 0 135 1 0 26 0 138 2 0 0 0 0 1 1 0 93 0
                                    94 3 0 129 0 117 117 130 2 0 129 0 117 131
                                    2 0 0 0 0 1 1 0 161 152 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 1 2 0 0
                                    0 0 119 0 0 0 39 3 0 153 0 154 153 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 90 2 0 156 152 0 1 0 2 0 34 2 0 0 0 0
                                    55 5 3 0 152 152 152 152 0 1 0 2 0 33 2 0 0
                                    0 0 54 1 0 26 0 27 3 0 0 0 0 0 1 3 0 0 0 0
                                    0 1 1 0 0 0 30 1 0 0 0 59 1 0 0 0 64 3 0 0
                                    0 0 0 1 3 0 0 0 0 0 1 3 0 0 0 0 0 1 1 0 0
                                    152 1 2 0 0 0 0 1 1 0 7 0 1 1 0 0 0 122 3 0
                                    0 0 0 0 1 3 0 0 0 0 0 1 2 0 0 0 0 1 2 0 0 0
                                    0 1 2 0 0 0 0 1 2 0 0 0 0 1 2 0 0 0 0 1 2 0
                                    0 0 0 1 2 0 0 0 0 1 2 0 0 0 0 1 1 0 0 0 1 1
                                    1 24 26 1 3 3 0 152 152 0 1 1 0 26 0 92 1 0
                                    164 0 1 2 0 0 0 0 1 2 0 0 0 0 1 2 0 162 162
                                    162 1 2 0 0 0 0 1 1 0 0 152 1 1 0 0 0 1 1 0
                                    0 0 1 3 0 0 26 26 24 124 2 0 0 26 26 1 1 0
                                    155 0 1 2 0 157 0 0 1 3 0 159 0 0 0 1 2 0
                                    93 0 0 1 2 0 156 152 0 1 1 0 26 0 28 0 0 0
                                    38 1 0 0 0 63 1 0 117 0 1 3 0 0 0 0 0 1 1 0
                                    0 0 1 2 0 0 0 0 1 2 0 0 0 0 1 1 0 0 0 1 1 0
                                    7 7 8 2 0 160 0 0 1 1 1 24 24 1 0 0 24 1 1
                                    0 0 0 112 1 0 0 0 95 2 0 0 0 117 1 1 1 24
                                    26 1 1 0 0 0 80 1 0 0 0 70 1 0 0 0 81 1 0 0
                                    0 68 1 0 0 0 78 1 0 0 0 66 1 0 45 0 47 1 0
                                    154 0 1 1 0 15 0 125 1 0 126 0 128 1 0 0
                                    129 1 1 0 0 26 62 1 0 0 129 1 1 0 0 26 62 1
                                    0 0 0 1 1 0 41 0 44 0 0 117 1 1 0 0 0 1 1 1
                                    24 24 1 0 0 24 32 2 0 0 0 0 108 2 0 0 0 0
                                    106 2 0 0 0 0 104 2 0 0 0 0 102 0 0 24 25 1
                                    0 0 0 85 2 0 0 0 0 134 1 0 0 0 73 2 0 20 0
                                    0 1 1 0 0 0 83 1 0 0 0 71 1 0 0 0 88 1 0 0
                                    0 76 2 0 0 0 0 1 1 0 0 0 1 1 0 0 0 100 1 0
                                    0 0 1 1 0 0 0 98 1 0 0 0 86 1 0 0 0 74 1 0
                                    0 0 87 1 0 0 0 75 1 0 0 0 84 1 0 0 0 72 1 0
                                    0 0 133 2 0 0 0 0 61 2 0 0 0 129 151 2 0 0
                                    0 26 60 2 0 0 0 117 1 2 0 0 0 24 1 0 0 0 36
                                    0 0 0 37 3 0 13 11 0 20 23 2 0 13 11 0 22 1
                                    0 7 0 19 2 0 7 0 20 21 2 0 0 0 0 1 1 0 0 0
                                    114 1 0 0 0 1 2 0 0 0 117 1 2 0 0 0 0 110 2
                                    0 20 0 0 40 2 0 20 0 0 132 2 0 20 0 0 56 2
                                    0 20 0 0 1 2 0 20 0 0 48 2 0 0 0 26 57 2 0
                                    0 0 0 89 2 0 0 0 0 51 1 0 0 0 49 2 0 0 0 0
                                    50 2 0 0 0 129 1 2 0 0 129 0 1 2 0 0 0 0 52
                                    2 0 0 26 0 53 2 0 0 117 0 1 2 0 0 24 0
                                    31)))))
           '|lookupComplete|)) 

(MAKEPROP '|DoubleFloat| 'NILADIC T) 
