* interp/g-opt.boot ($VMsideEffectFreeOperators): Include inverse

	hyperbolic functions.
	* interp/lisp-backend.boot: Expand them.
	* algebra/sf.spad.pamphlet: Use them.

1 files changed, 381 insertions, 339 deletions

diff --git a/src/algebra/strap/DFLOAT.lsp b/src/algebra/strap/DFLOAT.lsp
index 3f9d2dcb..21ed3bb1 100644
--- a/src/algebra/strap/DFLOAT.lsp
+++ b/src/algebra/strap/DFLOAT.lsp
@@ -15,356 +15,377 @@
                     |%Void|)
                 |DFLOAT;OMwrite;Omd$BV;4|)) 
 
-(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;checkComplex|)) 
-
-(PUT '|DFLOAT;checkComplex| '|SPADreplace| 'C-TO-R) 
-
 (DECLAIM (FTYPE (FUNCTION (|%Shell|) (|%IntegerSection| 1))
-                |DFLOAT;base;Pi;6|)) 
+                |DFLOAT;base;Pi;5|)) 
 
-(PUT '|DFLOAT;base;Pi;6| '|SPADreplace| '|%fbase|) 
+(PUT '|DFLOAT;base;Pi;5| '|SPADreplace| '|%fbase|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Integer|)
-                |DFLOAT;mantissa;$I;7|)) 
+                |DFLOAT;mantissa;$I;6|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Integer|)
-                |DFLOAT;exponent;$I;8|)) 
+                |DFLOAT;exponent;$I;7|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%Shell|) (|%IntegerSection| 1))
-                |DFLOAT;precision;Pi;9|)) 
+                |DFLOAT;precision;Pi;8|)) 
 
-(PUT '|DFLOAT;precision;Pi;9| '|SPADreplace| '|%fprec|) 
+(PUT '|DFLOAT;precision;Pi;8| '|SPADreplace| '|%fprec|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%Shell|) (|%IntegerSection| 1))
-                |DFLOAT;bits;Pi;10|)) 
+                |DFLOAT;bits;Pi;9|)) 
 
-(DECLAIM (FTYPE (FUNCTION (|%Shell|) |%DoubleFloat|) |DFLOAT;max;$;11|)) 
+(DECLAIM (FTYPE (FUNCTION (|%Shell|) |%DoubleFloat|) |DFLOAT;max;$;10|)) 
 
-(PUT '|DFLOAT;max;$;11| '|SPADreplace| '|%fmaxval|) 
+(PUT '|DFLOAT;max;$;10| '|SPADreplace| '|%fmaxval|) 
 
-(DECLAIM (FTYPE (FUNCTION (|%Shell|) |%DoubleFloat|) |DFLOAT;min;$;12|)) 
+(DECLAIM (FTYPE (FUNCTION (|%Shell|) |%DoubleFloat|) |DFLOAT;min;$;11|)) 
 
-(PUT '|DFLOAT;min;$;12| '|SPADreplace| '|%fminval|) 
+(PUT '|DFLOAT;min;$;11| '|SPADreplace| '|%fminval|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Integer|)
-                |DFLOAT;order;$I;13|)) 
+                |DFLOAT;order;$I;12|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%Shell|) |%DoubleFloat|)
-                |DFLOAT;Zero;$;14|)) 
+                |DFLOAT;Zero;$;13|)) 
 
-(PUT '|DFLOAT;Zero;$;14| '|SPADreplace| '(XLAM NIL (|%i2f| 0))) 
+(PUT '|DFLOAT;Zero;$;13| '|SPADreplace| '(XLAM NIL (|%i2f| 0))) 
 
-(DECLAIM (FTYPE (FUNCTION (|%Shell|) |%DoubleFloat|) |DFLOAT;One;$;15|)) 
+(DECLAIM (FTYPE (FUNCTION (|%Shell|) |%DoubleFloat|) |DFLOAT;One;$;14|)) 
 
-(PUT '|DFLOAT;One;$;15| '|SPADreplace| '(XLAM NIL (|%i2f| 1))) 
+(PUT '|DFLOAT;One;$;14| '|SPADreplace| '(XLAM NIL (|%i2f| 1))) 
 
 (DECLAIM (FTYPE (FUNCTION (|%Shell|) |%DoubleFloat|)
-                |DFLOAT;exp1;$;16|)) 
+                |DFLOAT;exp1;$;15|)) 
 
-(DECLAIM (FTYPE (FUNCTION (|%Shell|) |%DoubleFloat|) |DFLOAT;pi;$;17|)) 
+(DECLAIM (FTYPE (FUNCTION (|%Shell|) |%DoubleFloat|) |DFLOAT;pi;$;16|)) 
 
-(PUT '|DFLOAT;pi;$;17| '|SPADreplace| '|%fcstpi|) 
+(PUT '|DFLOAT;pi;$;16| '|SPADreplace| '|%fcstpi|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Thing|)
-                |DFLOAT;coerce;$Of;18|)) 
+                |DFLOAT;coerce;$Of;17|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Thing|)
-                |DFLOAT;convert;$If;19|)) 
+                |DFLOAT;convert;$If;18|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
                     |%Boolean|)
-                |DFLOAT;<;2$B;20|)) 
+                |DFLOAT;<;2$B;19|)) 
 
-(PUT '|DFLOAT;<;2$B;20| '|SPADreplace| '|%flt|) 
+(PUT '|DFLOAT;<;2$B;19| '|SPADreplace| '|%flt|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
                     |%Boolean|)
-                |DFLOAT;>;2$B;21|)) 
+                |DFLOAT;>;2$B;20|)) 
 
-(PUT '|DFLOAT;>;2$B;21| '|SPADreplace| '|%fgt|) 
+(PUT '|DFLOAT;>;2$B;20| '|SPADreplace| '|%fgt|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
                     |%Boolean|)
-                |DFLOAT;<=;2$B;22|)) 
+                |DFLOAT;<=;2$B;21|)) 
 
-(PUT '|DFLOAT;<=;2$B;22| '|SPADreplace| '|%fle|) 
+(PUT '|DFLOAT;<=;2$B;21| '|SPADreplace| '|%fle|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
                     |%Boolean|)
-                |DFLOAT;>=;2$B;23|)) 
+                |DFLOAT;>=;2$B;22|)) 
 
-(PUT '|DFLOAT;>=;2$B;23| '|SPADreplace| '|%fge|) 
+(PUT '|DFLOAT;>=;2$B;22| '|SPADreplace| '|%fge|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;-;2$;24|)) 
+                |DFLOAT;-;2$;23|)) 
 
-(PUT '|DFLOAT;-;2$;24| '|SPADreplace| '|%fneg|) 
+(PUT '|DFLOAT;-;2$;23| '|SPADreplace| '|%fneg|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
                     |%DoubleFloat|)
-                |DFLOAT;+;3$;25|)) 
+                |DFLOAT;+;3$;24|)) 
 
-(PUT '|DFLOAT;+;3$;25| '|SPADreplace| '|%fadd|) 
+(PUT '|DFLOAT;+;3$;24| '|SPADreplace| '|%fadd|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
                     |%DoubleFloat|)
-                |DFLOAT;-;3$;26|)) 
+                |DFLOAT;-;3$;25|)) 
 
-(PUT '|DFLOAT;-;3$;26| '|SPADreplace| '|%fsub|) 
+(PUT '|DFLOAT;-;3$;25| '|SPADreplace| '|%fsub|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
                     |%DoubleFloat|)
-                |DFLOAT;*;3$;27|)) 
+                |DFLOAT;*;3$;26|)) 
 
-(PUT '|DFLOAT;*;3$;27| '|SPADreplace| '|%fmul|) 
+(PUT '|DFLOAT;*;3$;26| '|SPADreplace| '|%fmul|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%Integer| |%DoubleFloat| |%Shell|)
                     |%DoubleFloat|)
-                |DFLOAT;*;I2$;28|)) 
+                |DFLOAT;*;I2$;27|)) 
 
-(PUT '|DFLOAT;*;I2$;28| '|SPADreplace| '*) 
+(PUT '|DFLOAT;*;I2$;27| '|SPADreplace| '|%imulf|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
                     |%DoubleFloat|)
-                |DFLOAT;max;3$;29|)) 
+                |DFLOAT;max;3$;28|)) 
 
-(PUT '|DFLOAT;max;3$;29| '|SPADreplace| '|%fmax|) 
+(PUT '|DFLOAT;max;3$;28| '|SPADreplace| '|%fmax|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
                     |%DoubleFloat|)
-                |DFLOAT;min;3$;30|)) 
+                |DFLOAT;min;3$;29|)) 
 
-(PUT '|DFLOAT;min;3$;30| '|SPADreplace| '|%fmin|) 
+(PUT '|DFLOAT;min;3$;29| '|SPADreplace| '|%fmin|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
                     |%Boolean|)
-                |DFLOAT;=;2$B;31|)) 
+                |DFLOAT;=;2$B;30|)) 
 
-(PUT '|DFLOAT;=;2$B;31| '|SPADreplace| '|%feq|) 
+(PUT '|DFLOAT;=;2$B;30| '|SPADreplace| '|%feq|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Integer| |%Shell|)
                     |%DoubleFloat|)
-                |DFLOAT;/;$I$;32|)) 
+                |DFLOAT;/;$I$;31|)) 
 
-(PUT '|DFLOAT;/;$I$;32| '|SPADreplace| '/) 
+(PUT '|DFLOAT;/;$I$;31| '|SPADreplace| '|%fdivi|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;sqrt;2$;33|)) 
+                |DFLOAT;sqrt;2$;32|)) 
+
+(PUT '|DFLOAT;sqrt;2$;32| '|SPADreplace| '|%fsqrt|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;log10;2$;34|)) 
+                |DFLOAT;log10;2$;33|)) 
+
+(PUT '|DFLOAT;log10;2$;33| '|SPADreplace| '|%flog10|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Integer| |%Shell|)
                     |%DoubleFloat|)
-                |DFLOAT;**;$I$;35|)) 
+                |DFLOAT;**;$I$;34|)) 
 
-(PUT '|DFLOAT;**;$I$;35| '|SPADreplace| 'EXPT) 
+(PUT '|DFLOAT;**;$I$;34| '|SPADreplace| '|%fpowi|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
                     |%DoubleFloat|)
-                |DFLOAT;**;3$;36|)) 
+                |DFLOAT;**;3$;35|)) 
+
+(PUT '|DFLOAT;**;3$;35| '|SPADreplace| '|%fpowf|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%Integer| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;coerce;I$;37|)) 
+                |DFLOAT;coerce;I$;36|)) 
 
-(PUT '|DFLOAT;coerce;I$;37| '|SPADreplace| '|%i2f|) 
+(PUT '|DFLOAT;coerce;I$;36| '|SPADreplace| '|%i2f|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;exp;2$;38|)) 
+                |DFLOAT;exp;2$;37|)) 
 
-(PUT '|DFLOAT;exp;2$;38| '|SPADreplace| 'EXP) 
+(PUT '|DFLOAT;exp;2$;37| '|SPADreplace| '|%fexp|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;log;2$;39|)) 
+                |DFLOAT;log;2$;38|)) 
+
+(PUT '|DFLOAT;log;2$;38| '|SPADreplace| '|%flog|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;log2;2$;40|)) 
+                |DFLOAT;log2;2$;39|)) 
+
+(PUT '|DFLOAT;log2;2$;39| '|SPADreplace| '|%flog2|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;sin;2$;41|)) 
+                |DFLOAT;sin;2$;40|)) 
 
-(PUT '|DFLOAT;sin;2$;41| '|SPADreplace| '|%fsin|) 
+(PUT '|DFLOAT;sin;2$;40| '|SPADreplace| '|%fsin|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;cos;2$;42|)) 
+                |DFLOAT;cos;2$;41|)) 
 
-(PUT '|DFLOAT;cos;2$;42| '|SPADreplace| '|%fcos|) 
+(PUT '|DFLOAT;cos;2$;41| '|SPADreplace| '|%fcos|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;tan;2$;43|)) 
+                |DFLOAT;tan;2$;42|)) 
 
-(PUT '|DFLOAT;tan;2$;43| '|SPADreplace| '|%ftan|) 
+(PUT '|DFLOAT;tan;2$;42| '|SPADreplace| '|%ftan|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;cot;2$;44|)) 
+                |DFLOAT;cot;2$;43|)) 
 
-(PUT '|DFLOAT;cot;2$;44| '|SPADreplace| '|%fcot|) 
+(PUT '|DFLOAT;cot;2$;43| '|SPADreplace| '|%fcot|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;sec;2$;45|)) 
+                |DFLOAT;sec;2$;44|)) 
 
-(PUT '|DFLOAT;sec;2$;45| '|SPADreplace| '|%fsec|) 
+(PUT '|DFLOAT;sec;2$;44| '|SPADreplace| '|%fsec|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;csc;2$;46|)) 
+                |DFLOAT;csc;2$;45|)) 
 
-(PUT '|DFLOAT;csc;2$;46| '|SPADreplace| '|%fcsc|) 
+(PUT '|DFLOAT;csc;2$;45| '|SPADreplace| '|%fcsc|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;asin;2$;47|)) 
+                |DFLOAT;asin;2$;46|)) 
+
+(PUT '|DFLOAT;asin;2$;46| '|SPADreplace| '|%fasin|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;acos;2$;48|)) 
+                |DFLOAT;acos;2$;47|)) 
+
+(PUT '|DFLOAT;acos;2$;47| '|SPADreplace| '|%facos|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;atan;2$;49|)) 
+                |DFLOAT;atan;2$;48|)) 
 
-(PUT '|DFLOAT;atan;2$;49| '|SPADreplace| '|%fatan|) 
+(PUT '|DFLOAT;atan;2$;48| '|SPADreplace| '|%fatan|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;acsc;2$;50|)) 
+                |DFLOAT;acsc;2$;49|)) 
+
+(PUT '|DFLOAT;acsc;2$;49| '|SPADreplace| '|%facsc|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;acot;2$;51|)) 
+                |DFLOAT;acot;2$;50|)) 
 
-(PUT '|DFLOAT;acot;2$;51| '|SPADreplace| '|%facot|) 
+(PUT '|DFLOAT;acot;2$;50| '|SPADreplace| '|%facot|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;asec;2$;52|)) 
+                |DFLOAT;asec;2$;51|)) 
+
+(PUT '|DFLOAT;asec;2$;51| '|SPADreplace| '|%fasec|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;sinh;2$;53|)) 
+                |DFLOAT;sinh;2$;52|)) 
 
-(PUT '|DFLOAT;sinh;2$;53| '|SPADreplace| '|%fsinh|) 
+(PUT '|DFLOAT;sinh;2$;52| '|SPADreplace| '|%fsinh|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;cosh;2$;54|)) 
+                |DFLOAT;cosh;2$;53|)) 
 
-(PUT '|DFLOAT;cosh;2$;54| '|SPADreplace| '|%fcosh|) 
+(PUT '|DFLOAT;cosh;2$;53| '|SPADreplace| '|%fcosh|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;tanh;2$;55|)) 
+                |DFLOAT;tanh;2$;54|)) 
 
-(PUT '|DFLOAT;tanh;2$;55| '|SPADreplace| '|%ftanh|) 
+(PUT '|DFLOAT;tanh;2$;54| '|SPADreplace| '|%ftanh|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;csch;2$;56|)) 
+                |DFLOAT;csch;2$;55|)) 
 
-(PUT '|DFLOAT;csch;2$;56| '|SPADreplace| '|%fcsch|) 
+(PUT '|DFLOAT;csch;2$;55| '|SPADreplace| '|%fcsch|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;coth;2$;57|)) 
+                |DFLOAT;coth;2$;56|)) 
 
-(PUT '|DFLOAT;coth;2$;57| '|SPADreplace| '|%fcoth|) 
+(PUT '|DFLOAT;coth;2$;56| '|SPADreplace| '|%fcoth|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;sech;2$;58|)) 
+                |DFLOAT;sech;2$;57|)) 
 
-(PUT '|DFLOAT;sech;2$;58| '|SPADreplace| '|%fsech|) 
+(PUT '|DFLOAT;sech;2$;57| '|SPADreplace| '|%fsech|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;asinh;2$;59|)) 
+                |DFLOAT;asinh;2$;58|)) 
 
-(PUT '|DFLOAT;asinh;2$;59| '|SPADreplace| '|%fasinh|) 
+(PUT '|DFLOAT;asinh;2$;58| '|SPADreplace| '|%fasinh|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;acosh;2$;60|)) 
+                |DFLOAT;acosh;2$;59|)) 
+
+(PUT '|DFLOAT;acosh;2$;59| '|SPADreplace| '|%facosh|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;atanh;2$;61|)) 
+                |DFLOAT;atanh;2$;60|)) 
+
+(PUT '|DFLOAT;atanh;2$;60| '|SPADreplace| '|%fatanh|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;acsch;2$;62|)) 
+                |DFLOAT;acsch;2$;61|)) 
 
-(PUT '|DFLOAT;acsch;2$;62| '|SPADreplace| '|%facsch|) 
+(PUT '|DFLOAT;acsch;2$;61| '|SPADreplace| '|%facsch|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;acoth;2$;63|)) 
+                |DFLOAT;acoth;2$;62|)) 
+
+(PUT '|DFLOAT;acoth;2$;62| '|SPADreplace| '|%facoth|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;asech;2$;64|)) 
+                |DFLOAT;asech;2$;63|)) 
+
+(PUT '|DFLOAT;asech;2$;63| '|SPADreplace| '|%fasech|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
                     |%DoubleFloat|)
-                |DFLOAT;/;3$;65|)) 
+                |DFLOAT;/;3$;64|)) 
 
-(PUT '|DFLOAT;/;3$;65| '|SPADreplace| '|%fdiv|) 
+(PUT '|DFLOAT;/;3$;64| '|SPADreplace| '|%fdiv|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Boolean|)
-                |DFLOAT;negative?;$B;66|)) 
+                |DFLOAT;negative?;$B;65|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Boolean|)
-                |DFLOAT;zero?;$B;67|)) 
+                |DFLOAT;zero?;$B;66|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Boolean|)
-                |DFLOAT;one?;$B;68|)) 
+                |DFLOAT;one?;$B;67|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Short|)
-                |DFLOAT;hash;$Si;69|)) 
+                |DFLOAT;hash;$Si;68|)) 
 
-(PUT '|DFLOAT;hash;$Si;69| '|SPADreplace| '|%hash|) 
+(PUT '|DFLOAT;hash;$Si;68| '|SPADreplace| '|%hash|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Pair|)
-                |DFLOAT;recip;$U;70|)) 
+                |DFLOAT;recip;$U;69|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;differentiate;2$;71|)) 
+                |DFLOAT;differentiate;2$;70|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;Gamma;2$;72|)) 
+                |DFLOAT;Gamma;2$;71|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
                     |%DoubleFloat|)
-                |DFLOAT;Beta;3$;73|)) 
+                |DFLOAT;Beta;3$;72|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Integer|)
-                |DFLOAT;wholePart;$I;74|)) 
+                |DFLOAT;wholePart;$I;73|)) 
 
-(PUT '|DFLOAT;wholePart;$I;74| '|SPADreplace| '|%ftrunc|) 
+(PUT '|DFLOAT;wholePart;$I;73| '|SPADreplace| '|%ftrunc|) 
 
 (DECLAIM (FTYPE (FUNCTION
                     (|%Integer| |%Integer| (|%IntegerSection| 1)
                         |%Shell|)
                     |%DoubleFloat|)
-                |DFLOAT;float;2IPi$;75|)) 
+                |DFLOAT;float;2IPi$;74|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;convert;2$;76|)) 
+                |DFLOAT;convert;2$;75|)) 
 
-(PUT '|DFLOAT;convert;2$;76| '|SPADreplace| '(XLAM (|x|) |x|)) 
+(PUT '|DFLOAT;convert;2$;75| '|SPADreplace| '(XLAM (|x|) |x|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Thing|)
-                |DFLOAT;convert;$F;77|)) 
+                |DFLOAT;convert;$F;76|)) 
 
 (DECLAIM (FTYPE (FUNCTION
                     (|%DoubleFloat| (|%IntegerSection| 0) |%Shell|)
                     |%Thing|)
-                |DFLOAT;rationalApproximation;$NniF;78|)) 
+                |DFLOAT;rationalApproximation;$NniF;77|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
                     |%DoubleFloat|)
-                |DFLOAT;atan;3$;79|)) 
+                |DFLOAT;atan;3$;78|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Thing|)
-                |DFLOAT;retract;$F;80|)) 
+                |DFLOAT;retract;$F;79|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Pair|)
-                |DFLOAT;retractIfCan;$U;81|)) 
+                |DFLOAT;retractIfCan;$U;80|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Integer|)
-                |DFLOAT;retract;$I;82|)) 
+                |DFLOAT;retract;$I;81|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Pair|)
-                |DFLOAT;retractIfCan;$U;83|)) 
+                |DFLOAT;retractIfCan;$U;82|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Integer|)
-                |DFLOAT;sign;$I;84|)) 
+                |DFLOAT;sign;$I;83|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;abs;2$;85|)) 
+                |DFLOAT;abs;2$;84|)) 
 
-(PUT '|DFLOAT;abs;2$;85| '|SPADreplace| '|%fabs|) 
+(PUT '|DFLOAT;abs;2$;84| '|SPADreplace| '|%fabs|) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Pair|)
                 |DFLOAT;manexp|)) 
@@ -373,25 +394,25 @@
                     (|%DoubleFloat| (|%IntegerSection| 0)
                         (|%IntegerSection| 0) |%Shell|)
                     |%Thing|)
-                |DFLOAT;rationalApproximation;$2NniF;87|)) 
+                |DFLOAT;rationalApproximation;$2NniF;86|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Thing| |%Shell|)
                     |%DoubleFloat|)
-                |DFLOAT;**;$F$;88|)) 
+                |DFLOAT;**;$F$;87|)) 
 
-(PUT '|DFLOAT;exp1;$;16| '|SPADreplace|
+(PUT '|DFLOAT;exp1;$;15| '|SPADreplace|
      '(XLAM NIL (|%fdiv| (|%i2f| 534625820200) (|%i2f| 196677847971)))) 
 
-(PUT '|DFLOAT;negative?;$B;66| '|SPADreplace|
+(PUT '|DFLOAT;negative?;$B;65| '|SPADreplace|
      '(XLAM (|x|) (|%flt| |x| (|%i2f| 0)))) 
 
-(PUT '|DFLOAT;zero?;$B;67| '|SPADreplace|
+(PUT '|DFLOAT;zero?;$B;66| '|SPADreplace|
      '(XLAM (|x|) (|%feq| |x| (|%i2f| 0)))) 
 
-(PUT '|DFLOAT;one?;$B;68| '|SPADreplace|
+(PUT '|DFLOAT;one?;$B;67| '|SPADreplace|
      '(XLAM (|x|) (|%feq| |x| (|%i2f| 1)))) 
 
-(PUT '|DFLOAT;differentiate;2$;71| '|SPADreplace|
+(PUT '|DFLOAT;differentiate;2$;70| '|SPADreplace|
      '(XLAM (|x|) (|%i2f| 0))) 
 
 (DEFUN |DFLOAT;OMwrite;$S;1| (|x| $)
@@ -425,202 +446,222 @@
        (EXIT (COND
                (|wholeObj| (SPADCALL |dev| (|getShellEntry| $ 16))))))) 
 
-(DEFUN |DFLOAT;checkComplex| (|x| $)
-  (DECLARE (IGNORE $))
-  (C-TO-R |x|)) 
-
-(DEFUN |DFLOAT;base;Pi;6| ($) (DECLARE (IGNORE $)) 2) 
+(DEFUN |DFLOAT;base;Pi;5| ($) (DECLARE (IGNORE $)) 2) 
 
-(DEFUN |DFLOAT;mantissa;$I;7| (|x| $) (CAR (|DFLOAT;manexp| |x| $))) 
+(DEFUN |DFLOAT;mantissa;$I;6| (|x| $) (CAR (|DFLOAT;manexp| |x| $))) 
 
-(DEFUN |DFLOAT;exponent;$I;8| (|x| $) (CDR (|DFLOAT;manexp| |x| $))) 
+(DEFUN |DFLOAT;exponent;$I;7| (|x| $) (CDR (|DFLOAT;manexp| |x| $))) 
 
-(DEFUN |DFLOAT;precision;Pi;9| ($) (DECLARE (IGNORE $)) 53) 
+(DEFUN |DFLOAT;precision;Pi;8| ($) (DECLARE (IGNORE $)) 53) 
 
-(DEFUN |DFLOAT;bits;Pi;10| ($)
+(DEFUN |DFLOAT;bits;Pi;9| ($)
   (COND
     ((EQL 2 2) 53)
     ((EQL 2 16) (* 4 53))
-    (T (LET ((#0=#:G1406
+    (T (LET ((#0=#:G1405
                  (TRUNCATE
                      (SPADCALL 53
-                         (|DFLOAT;log2;2$;40|
-                             (FLOAT 2 |$DoubleFloatMaximum|) $)
+                         (C-TO-R (LOG (FLOAT 2 |$DoubleFloatMaximum|)
+                                      2))
                          (|getShellEntry| $ 32)))))
          (|check-subtype| (AND (NOT (MINUSP #0#)) (PLUSP #0#))
              '(|PositiveInteger|) #0#))))) 
 
-(DEFUN |DFLOAT;max;$;11| ($)
+(DEFUN |DFLOAT;max;$;10| ($)
   (DECLARE (IGNORE $))
   |$DoubleFloatMaximum|) 
 
-(DEFUN |DFLOAT;min;$;12| ($)
+(DEFUN |DFLOAT;min;$;11| ($)
   (DECLARE (IGNORE $))
   |$DoubleFloatMinimum|) 
 
-(DEFUN |DFLOAT;order;$I;13| (|a| $)
-  (- (+ 53 (|DFLOAT;exponent;$I;8| |a| $)) 1)) 
+(DEFUN |DFLOAT;order;$I;12| (|a| $)
+  (- (+ 53 (|DFLOAT;exponent;$I;7| |a| $)) 1)) 
 
-(DEFUN |DFLOAT;Zero;$;14| ($) (DECLARE (IGNORE $)) 0.0) 
+(DEFUN |DFLOAT;Zero;$;13| ($) (DECLARE (IGNORE $)) 0.0) 
 
-(DEFUN |DFLOAT;One;$;15| ($) (DECLARE (IGNORE $)) 1.0) 
+(DEFUN |DFLOAT;One;$;14| ($) (DECLARE (IGNORE $)) 1.0) 
 
-(DEFUN |DFLOAT;exp1;$;16| ($)
+(DEFUN |DFLOAT;exp1;$;15| ($)
   (DECLARE (IGNORE $))
   (/ (FLOAT 534625820200 |$DoubleFloatMaximum|)
      (FLOAT 196677847971 |$DoubleFloatMaximum|))) 
 
-(DEFUN |DFLOAT;pi;$;17| ($)
+(DEFUN |DFLOAT;pi;$;16| ($)
   (DECLARE (IGNORE $))
   (COERCE PI '|%DoubleFloat|)) 
 
-(DEFUN |DFLOAT;coerce;$Of;18| (|x| $)
+(DEFUN |DFLOAT;coerce;$Of;17| (|x| $)
   (SPADCALL |x| (|getShellEntry| $ 48))) 
 
-(DEFUN |DFLOAT;convert;$If;19| (|x| $)
+(DEFUN |DFLOAT;convert;$If;18| (|x| $)
   (SPADCALL |x| (|getShellEntry| $ 51))) 
 
-(DEFUN |DFLOAT;<;2$B;20| (|x| |y| $) (DECLARE (IGNORE $)) (< |x| |y|)) 
+(DEFUN |DFLOAT;<;2$B;19| (|x| |y| $) (DECLARE (IGNORE $)) (< |x| |y|)) 
 
-(DEFUN |DFLOAT;>;2$B;21| (|x| |y| $) (DECLARE (IGNORE $)) (< |y| |x|)) 
+(DEFUN |DFLOAT;>;2$B;20| (|x| |y| $) (DECLARE (IGNORE $)) (< |y| |x|)) 
 
-(DEFUN |DFLOAT;<=;2$B;22| (|x| |y| $)
+(DEFUN |DFLOAT;<=;2$B;21| (|x| |y| $)
   (DECLARE (IGNORE $))
   (<= |x| |y|)) 
 
-(DEFUN |DFLOAT;>=;2$B;23| (|x| |y| $)
+(DEFUN |DFLOAT;>=;2$B;22| (|x| |y| $)
   (DECLARE (IGNORE $))
   (>= |x| |y|)) 
 
-(DEFUN |DFLOAT;-;2$;24| (|x| $) (DECLARE (IGNORE $)) (- |x|)) 
+(DEFUN |DFLOAT;-;2$;23| (|x| $) (DECLARE (IGNORE $)) (- |x|)) 
 
-(DEFUN |DFLOAT;+;3$;25| (|x| |y| $) (DECLARE (IGNORE $)) (+ |x| |y|)) 
+(DEFUN |DFLOAT;+;3$;24| (|x| |y| $) (DECLARE (IGNORE $)) (+ |x| |y|)) 
 
-(DEFUN |DFLOAT;-;3$;26| (|x| |y| $) (DECLARE (IGNORE $)) (- |x| |y|)) 
+(DEFUN |DFLOAT;-;3$;25| (|x| |y| $) (DECLARE (IGNORE $)) (- |x| |y|)) 
 
-(DEFUN |DFLOAT;*;3$;27| (|x| |y| $) (DECLARE (IGNORE $)) (* |x| |y|)) 
+(DEFUN |DFLOAT;*;3$;26| (|x| |y| $) (DECLARE (IGNORE $)) (* |x| |y|)) 
 
-(DEFUN |DFLOAT;*;I2$;28| (|i| |x| $) (DECLARE (IGNORE $)) (* |i| |x|)) 
+(DEFUN |DFLOAT;*;I2$;27| (|i| |x| $) (DECLARE (IGNORE $)) (* |i| |x|)) 
 
-(DEFUN |DFLOAT;max;3$;29| (|x| |y| $)
+(DEFUN |DFLOAT;max;3$;28| (|x| |y| $)
   (DECLARE (IGNORE $))
   (MAX |x| |y|)) 
 
-(DEFUN |DFLOAT;min;3$;30| (|x| |y| $)
+(DEFUN |DFLOAT;min;3$;29| (|x| |y| $)
   (DECLARE (IGNORE $))
   (MIN |x| |y|)) 
 
-(DEFUN |DFLOAT;=;2$B;31| (|x| |y| $) (DECLARE (IGNORE $)) (= |x| |y|)) 
+(DEFUN |DFLOAT;=;2$B;30| (|x| |y| $) (DECLARE (IGNORE $)) (= |x| |y|)) 
 
-(DEFUN |DFLOAT;/;$I$;32| (|x| |i| $) (DECLARE (IGNORE $)) (/ |x| |i|)) 
+(DEFUN |DFLOAT;/;$I$;31| (|x| |i| $) (DECLARE (IGNORE $)) (/ |x| |i|)) 
 
-(DEFUN |DFLOAT;sqrt;2$;33| (|x| $) (C-TO-R (SQRT |x|))) 
+(DEFUN |DFLOAT;sqrt;2$;32| (|x| $)
+  (DECLARE (IGNORE $))
+  (C-TO-R (SQRT |x|))) 
 
-(DEFUN |DFLOAT;log10;2$;34| (|x| $) (C-TO-R (|log| |x|))) 
+(DEFUN |DFLOAT;log10;2$;33| (|x| $)
+  (DECLARE (IGNORE $))
+  (C-TO-R (LOG |x| 10))) 
 
-(DEFUN |DFLOAT;**;$I$;35| (|x| |i| $)
+(DEFUN |DFLOAT;**;$I$;34| (|x| |i| $)
   (DECLARE (IGNORE $))
   (EXPT |x| |i|)) 
 
-(DEFUN |DFLOAT;**;3$;36| (|x| |y| $) (C-TO-R (EXPT |x| |y|))) 
+(DEFUN |DFLOAT;**;3$;35| (|x| |y| $)
+  (DECLARE (IGNORE $))
+  (C-TO-R (EXPT |x| |y|))) 
 
-(DEFUN |DFLOAT;coerce;I$;37| (|i| $)
+(DEFUN |DFLOAT;coerce;I$;36| (|i| $)
   (DECLARE (IGNORE $))
   (FLOAT |i| |$DoubleFloatMaximum|)) 
 
-(DEFUN |DFLOAT;exp;2$;38| (|x| $) (DECLARE (IGNORE $)) (EXP |x|)) 
+(DEFUN |DFLOAT;exp;2$;37| (|x| $) (DECLARE (IGNORE $)) (EXP |x|)) 
 
-(DEFUN |DFLOAT;log;2$;39| (|x| $) (C-TO-R (LN |x|))) 
+(DEFUN |DFLOAT;log;2$;38| (|x| $)
+  (DECLARE (IGNORE $))
+  (C-TO-R (LOG |x|))) 
 
-(DEFUN |DFLOAT;log2;2$;40| (|x| $) (C-TO-R (LOG2 |x|))) 
+(DEFUN |DFLOAT;log2;2$;39| (|x| $)
+  (DECLARE (IGNORE $))
+  (C-TO-R (LOG |x| 2))) 
 
-(DEFUN |DFLOAT;sin;2$;41| (|x| $) (DECLARE (IGNORE $)) (SIN |x|)) 
+(DEFUN |DFLOAT;sin;2$;40| (|x| $) (DECLARE (IGNORE $)) (SIN |x|)) 
 
-(DEFUN |DFLOAT;cos;2$;42| (|x| $) (DECLARE (IGNORE $)) (COS |x|)) 
+(DEFUN |DFLOAT;cos;2$;41| (|x| $) (DECLARE (IGNORE $)) (COS |x|)) 
 
-(DEFUN |DFLOAT;tan;2$;43| (|x| $) (DECLARE (IGNORE $)) (TAN |x|)) 
+(DEFUN |DFLOAT;tan;2$;42| (|x| $) (DECLARE (IGNORE $)) (TAN |x|)) 
 
-(DEFUN |DFLOAT;cot;2$;44| (|x| $) (DECLARE (IGNORE $)) (COT |x|)) 
+(DEFUN |DFLOAT;cot;2$;43| (|x| $) (DECLARE (IGNORE $)) (COT |x|)) 
 
-(DEFUN |DFLOAT;sec;2$;45| (|x| $) (DECLARE (IGNORE $)) (SEC |x|)) 
+(DEFUN |DFLOAT;sec;2$;44| (|x| $) (DECLARE (IGNORE $)) (SEC |x|)) 
 
-(DEFUN |DFLOAT;csc;2$;46| (|x| $) (DECLARE (IGNORE $)) (CSC |x|)) 
+(DEFUN |DFLOAT;csc;2$;45| (|x| $) (DECLARE (IGNORE $)) (CSC |x|)) 
 
-(DEFUN |DFLOAT;asin;2$;47| (|x| $) (C-TO-R (ASIN |x|))) 
+(DEFUN |DFLOAT;asin;2$;46| (|x| $)
+  (DECLARE (IGNORE $))
+  (C-TO-R (ASIN |x|))) 
 
-(DEFUN |DFLOAT;acos;2$;48| (|x| $) (C-TO-R (ACOS |x|))) 
+(DEFUN |DFLOAT;acos;2$;47| (|x| $)
+  (DECLARE (IGNORE $))
+  (C-TO-R (ACOS |x|))) 
 
-(DEFUN |DFLOAT;atan;2$;49| (|x| $) (DECLARE (IGNORE $)) (ATAN |x|)) 
+(DEFUN |DFLOAT;atan;2$;48| (|x| $) (DECLARE (IGNORE $)) (ATAN |x|)) 
 
-(DEFUN |DFLOAT;acsc;2$;50| (|x| $) (C-TO-R (ACSC |x|))) 
+(DEFUN |DFLOAT;acsc;2$;49| (|x| $)
+  (DECLARE (IGNORE $))
+  (C-TO-R (ACSC |x|))) 
 
-(DEFUN |DFLOAT;acot;2$;51| (|x| $) (DECLARE (IGNORE $)) (ACOT |x|)) 
+(DEFUN |DFLOAT;acot;2$;50| (|x| $) (DECLARE (IGNORE $)) (ACOT |x|)) 
 
-(DEFUN |DFLOAT;asec;2$;52| (|x| $) (C-TO-R (ASEC |x|))) 
+(DEFUN |DFLOAT;asec;2$;51| (|x| $)
+  (DECLARE (IGNORE $))
+  (C-TO-R (ASEC |x|))) 
 
-(DEFUN |DFLOAT;sinh;2$;53| (|x| $) (DECLARE (IGNORE $)) (SINH |x|)) 
+(DEFUN |DFLOAT;sinh;2$;52| (|x| $) (DECLARE (IGNORE $)) (SINH |x|)) 
 
-(DEFUN |DFLOAT;cosh;2$;54| (|x| $) (DECLARE (IGNORE $)) (COSH |x|)) 
+(DEFUN |DFLOAT;cosh;2$;53| (|x| $) (DECLARE (IGNORE $)) (COSH |x|)) 
 
-(DEFUN |DFLOAT;tanh;2$;55| (|x| $) (DECLARE (IGNORE $)) (TANH |x|)) 
+(DEFUN |DFLOAT;tanh;2$;54| (|x| $) (DECLARE (IGNORE $)) (TANH |x|)) 
 
-(DEFUN |DFLOAT;csch;2$;56| (|x| $) (DECLARE (IGNORE $)) (CSCH |x|)) 
+(DEFUN |DFLOAT;csch;2$;55| (|x| $) (DECLARE (IGNORE $)) (CSCH |x|)) 
 
-(DEFUN |DFLOAT;coth;2$;57| (|x| $) (DECLARE (IGNORE $)) (COTH |x|)) 
+(DEFUN |DFLOAT;coth;2$;56| (|x| $) (DECLARE (IGNORE $)) (COTH |x|)) 
 
-(DEFUN |DFLOAT;sech;2$;58| (|x| $) (DECLARE (IGNORE $)) (SECH |x|)) 
+(DEFUN |DFLOAT;sech;2$;57| (|x| $) (DECLARE (IGNORE $)) (SECH |x|)) 
 
-(DEFUN |DFLOAT;asinh;2$;59| (|x| $) (DECLARE (IGNORE $)) (ASINH |x|)) 
+(DEFUN |DFLOAT;asinh;2$;58| (|x| $) (DECLARE (IGNORE $)) (ASINH |x|)) 
 
-(DEFUN |DFLOAT;acosh;2$;60| (|x| $) (C-TO-R (ACOSH |x|))) 
+(DEFUN |DFLOAT;acosh;2$;59| (|x| $)
+  (DECLARE (IGNORE $))
+  (C-TO-R (ACOSH |x|))) 
 
-(DEFUN |DFLOAT;atanh;2$;61| (|x| $) (C-TO-R (ATANH |x|))) 
+(DEFUN |DFLOAT;atanh;2$;60| (|x| $)
+  (DECLARE (IGNORE $))
+  (C-TO-R (ATANH |x|))) 
 
-(DEFUN |DFLOAT;acsch;2$;62| (|x| $) (DECLARE (IGNORE $)) (ACSCH |x|)) 
+(DEFUN |DFLOAT;acsch;2$;61| (|x| $) (DECLARE (IGNORE $)) (ACSCH |x|)) 
 
-(DEFUN |DFLOAT;acoth;2$;63| (|x| $) (C-TO-R (ACOTH |x|))) 
+(DEFUN |DFLOAT;acoth;2$;62| (|x| $)
+  (DECLARE (IGNORE $))
+  (C-TO-R (ACOTH |x|))) 
 
-(DEFUN |DFLOAT;asech;2$;64| (|x| $) (C-TO-R (ASECH |x|))) 
+(DEFUN |DFLOAT;asech;2$;63| (|x| $) (DECLARE (IGNORE $)) (ASECH |x|)) 
 
-(DEFUN |DFLOAT;/;3$;65| (|x| |y| $) (DECLARE (IGNORE $)) (/ |x| |y|)) 
+(DEFUN |DFLOAT;/;3$;64| (|x| |y| $) (DECLARE (IGNORE $)) (/ |x| |y|)) 
 
-(DEFUN |DFLOAT;negative?;$B;66| (|x| $)
+(DEFUN |DFLOAT;negative?;$B;65| (|x| $)
   (DECLARE (IGNORE $))
   (MINUSP |x|)) 
 
-(DEFUN |DFLOAT;zero?;$B;67| (|x| $) (DECLARE (IGNORE $)) (ZEROP |x|)) 
+(DEFUN |DFLOAT;zero?;$B;66| (|x| $) (DECLARE (IGNORE $)) (ZEROP |x|)) 
 
-(DEFUN |DFLOAT;one?;$B;68| (|x| $) (DECLARE (IGNORE $)) (= |x| 1.0)) 
+(DEFUN |DFLOAT;one?;$B;67| (|x| $) (DECLARE (IGNORE $)) (= |x| 1.0)) 
 
-(DEFUN |DFLOAT;hash;$Si;69| (|x| $) (DECLARE (IGNORE $)) (SXHASH |x|)) 
+(DEFUN |DFLOAT;hash;$Si;68| (|x| $) (DECLARE (IGNORE $)) (SXHASH |x|)) 
 
-(DEFUN |DFLOAT;recip;$U;70| (|x| $)
+(DEFUN |DFLOAT;recip;$U;69| (|x| $)
   (COND ((ZEROP |x|) (CONS 1 "failed")) (T (CONS 0 (/ 1.0 |x|))))) 
 
-(DEFUN |DFLOAT;differentiate;2$;71| (|x| $) (DECLARE (IGNORE $)) 0.0) 
+(DEFUN |DFLOAT;differentiate;2$;70| (|x| $) (DECLARE (IGNORE $)) 0.0) 
 
-(DEFUN |DFLOAT;Gamma;2$;72| (|x| $)
+(DEFUN |DFLOAT;Gamma;2$;71| (|x| $)
   (SPADCALL |x| (|getShellEntry| $ 106))) 
 
-(DEFUN |DFLOAT;Beta;3$;73| (|x| |y| $)
+(DEFUN |DFLOAT;Beta;3$;72| (|x| |y| $)
   (SPADCALL |x| |y| (|getShellEntry| $ 108))) 
 
-(DEFUN |DFLOAT;wholePart;$I;74| (|x| $)
+(DEFUN |DFLOAT;wholePart;$I;73| (|x| $)
   (DECLARE (IGNORE $))
   (TRUNCATE |x|)) 
 
-(DEFUN |DFLOAT;float;2IPi$;75| (|ma| |ex| |b| $)
+(DEFUN |DFLOAT;float;2IPi$;74| (|ma| |ex| |b| $)
   (* |ma| (EXPT (FLOAT |b| |$DoubleFloatMaximum|) |ex|))) 
 
-(DEFUN |DFLOAT;convert;2$;76| (|x| $) (DECLARE (IGNORE $)) |x|) 
+(DEFUN |DFLOAT;convert;2$;75| (|x| $) (DECLARE (IGNORE $)) |x|) 
 
-(DEFUN |DFLOAT;convert;$F;77| (|x| $)
+(DEFUN |DFLOAT;convert;$F;76| (|x| $)
   (SPADCALL |x| (|getShellEntry| $ 112))) 
 
-(DEFUN |DFLOAT;rationalApproximation;$NniF;78| (|x| |d| $)
-  (|DFLOAT;rationalApproximation;$2NniF;87| |x| |d| 10 $)) 
+(DEFUN |DFLOAT;rationalApproximation;$NniF;77| (|x| |d| $)
+  (|DFLOAT;rationalApproximation;$2NniF;86| |x| |d| 10 $)) 
 
-(DEFUN |DFLOAT;atan;3$;79| (|x| |y| $)
+(DEFUN |DFLOAT;atan;3$;78| (|x| |y| $)
   (PROG (|theta|)
     (RETURN
       (SEQ (COND
@@ -630,7 +671,7 @@
                 ((MINUSP |y|) (- (/ (COERCE PI '|%DoubleFloat|) 2)))
                 (T 0.0)))
              (T (SEQ (LETT |theta| (ATAN (ABS (/ |y| |x|)))
-                           |DFLOAT;atan;3$;79|)
+                           |DFLOAT;atan;3$;78|)
                      (COND
                        ((MINUSP |x|)
                         (SETQ |theta|
@@ -638,63 +679,63 @@
                      (COND ((MINUSP |y|) (SETQ |theta| (- |theta|))))
                      (EXIT |theta|)))))))) 
 
-(DEFUN |DFLOAT;retract;$F;80| (|x| $)
-  (|DFLOAT;rationalApproximation;$2NniF;87| |x|
-      (LET ((#0=#:G1489 (- 53 1)))
+(DEFUN |DFLOAT;retract;$F;79| (|x| $)
+  (|DFLOAT;rationalApproximation;$2NniF;86| |x|
+      (LET ((#0=#:G1488 (- 53 1)))
         (|check-subtype| (NOT (MINUSP #0#)) '(|NonNegativeInteger|)
             #0#))
       2 $)) 
 
-(DEFUN |DFLOAT;retractIfCan;$U;81| (|x| $)
+(DEFUN |DFLOAT;retractIfCan;$U;80| (|x| $)
   (CONS 0
-        (|DFLOAT;rationalApproximation;$2NniF;87| |x|
-            (LET ((#0=#:G1497 (- 53 1)))
+        (|DFLOAT;rationalApproximation;$2NniF;86| |x|
+            (LET ((#0=#:G1496 (- 53 1)))
               (|check-subtype| (NOT (MINUSP #0#))
                   '(|NonNegativeInteger|) #0#))
             2 $))) 
 
-(DEFUN |DFLOAT;retract;$I;82| (|x| $)
+(DEFUN |DFLOAT;retract;$I;81| (|x| $)
   (PROG (|n|)
     (RETURN
       (COND
         ((= |x|
-            (FLOAT (LETT |n| (TRUNCATE |x|) |DFLOAT;retract;$I;82|)
+            (FLOAT (LETT |n| (TRUNCATE |x|) |DFLOAT;retract;$I;81|)
                    |$DoubleFloatMaximum|))
          |n|)
         (T (|error| "Not an integer")))))) 
 
-(DEFUN |DFLOAT;retractIfCan;$U;83| (|x| $)
+(DEFUN |DFLOAT;retractIfCan;$U;82| (|x| $)
   (PROG (|n|)
     (RETURN
       (COND
         ((= |x|
             (FLOAT (LETT |n| (TRUNCATE |x|)
-                         |DFLOAT;retractIfCan;$U;83|)
+                         |DFLOAT;retractIfCan;$U;82|)
                    |$DoubleFloatMaximum|))
          (CONS 0 |n|))
         (T (CONS 1 "failed")))))) 
 
-(DEFUN |DFLOAT;sign;$I;84| (|x| $)
-  (|DFLOAT;retract;$I;82| (FLOAT-SIGN |x| 1.0) $)) 
+(DEFUN |DFLOAT;sign;$I;83| (|x| $)
+  (|DFLOAT;retract;$I;81| (FLOAT-SIGN |x| 1.0) $)) 
 
-(DEFUN |DFLOAT;abs;2$;85| (|x| $) (DECLARE (IGNORE $)) (ABS |x|)) 
+(DEFUN |DFLOAT;abs;2$;84| (|x| $) (DECLARE (IGNORE $)) (ABS |x|)) 
 
 (DEFUN |DFLOAT;manexp| (|x| $)
   (PROG (|s| |me| |two53|)
     (RETURN
       (SEQ (COND
              ((ZEROP |x|) (CONS 0 0))
-             (T (SEQ (LETT |s| (|DFLOAT;sign;$I;84| |x| $)
+             (T (SEQ (LETT |s| (|DFLOAT;sign;$I;83| |x| $)
                            |DFLOAT;manexp|)
                      (SETQ |x| (ABS |x|))
                      (COND
                        ((< |$DoubleFloatMaximum| |x|)
                         (RETURN-FROM |DFLOAT;manexp|
                           (CONS (+ (* |s|
-                                    (|DFLOAT;mantissa;$I;7|
+                                    (|DFLOAT;mantissa;$I;6|
                                      |$DoubleFloatMaximum| $))
                                    1)
-                                (|DFLOAT;exponent;$I;8|
+                                (|DFLOAT;exponent;$I;7|
                                     |$DoubleFloatMaximum| $)))))
                      (LETT |me| (MANEXP |x|) |DFLOAT;manexp|)
                      (LETT |two53| (EXPT 2 53) |DFLOAT;manexp|)
@@ -702,15 +743,15 @@
                                     (TRUNCATE (* |two53| (CAR |me|))))
                                  (- (CDR |me|) 53)))))))))) 
 
-(DEFUN |DFLOAT;rationalApproximation;$2NniF;87| (|f| |d| |b| $)
-  (PROG (BASE |de| |tol| |s| |t| |p0| |p1| |q0| |q1| |#G107| |q| |r|
-              |p2| |q2| |#G108| |#G109| |#G110| |#G111| |#G112|
-              |#G113|)
+(DEFUN |DFLOAT;rationalApproximation;$2NniF;86| (|f| |d| |b| $)
+  (PROG (BASE |de| |tol| |s| |t| |p0| |p1| |q0| |q1| |#G106| |q| |r|
+              |p2| |q2| |#G107| |#G108| |#G109| |#G110| |#G111|
+              |#G112|)
     (RETURN
-      (LET* ((|#G106| (|DFLOAT;manexp| |f| $)) (|nu| (CAR |#G106|))
-             (|ex| (CDR |#G106|)))
-        (SEQ |#G106|
-             (LETT BASE 2 |DFLOAT;rationalApproximation;$2NniF;87|)
+      (LET* ((|#G105| (|DFLOAT;manexp| |f| $)) (|nu| (CAR |#G105|))
+             (|ex| (CDR |#G105|)))
+        (SEQ |#G105|
+             (LETT BASE 2 |DFLOAT;rationalApproximation;$2NniF;86|)
              (EXIT (COND
                      ((NOT (MINUSP |ex|))
                       (SPADCALL
@@ -721,52 +762,52 @@
                           (|getShellEntry| $ 134)))
                      (T (SEQ (LETT |de|
                                    (EXPT BASE
-                                    (LET ((#0=#:G1525 (- |ex|)))
+                                    (LET ((#0=#:G1524 (- |ex|)))
                                       (|check-subtype|
                                        (NOT (MINUSP #0#))
                                        '(|NonNegativeInteger|) #0#)))
-                                   |DFLOAT;rationalApproximation;$2NniF;87|)
+                                   |DFLOAT;rationalApproximation;$2NniF;86|)
                              (EXIT (COND
                                      ((< |b| 2)
                                       (|error| "base must be > 1"))
                                      (T
                                       (SEQ
                                        (LETT |tol| (EXPT |b| |d|)
-                                        |DFLOAT;rationalApproximation;$2NniF;87|)
+                                        |DFLOAT;rationalApproximation;$2NniF;86|)
                                        (LETT |s| |nu|
-                                        |DFLOAT;rationalApproximation;$2NniF;87|)
+                                        |DFLOAT;rationalApproximation;$2NniF;86|)
                                        (LETT |t| |de|
-                                        |DFLOAT;rationalApproximation;$2NniF;87|)
+                                        |DFLOAT;rationalApproximation;$2NniF;86|)
                                        (LETT |p0| 0
-                                        |DFLOAT;rationalApproximation;$2NniF;87|)
+                                        |DFLOAT;rationalApproximation;$2NniF;86|)
                                        (LETT |p1| 1
-                                        |DFLOAT;rationalApproximation;$2NniF;87|)
+                                        |DFLOAT;rationalApproximation;$2NniF;86|)
                                        (LETT |q0| 1
-                                        |DFLOAT;rationalApproximation;$2NniF;87|)
+                                        |DFLOAT;rationalApproximation;$2NniF;86|)
                                        (LETT |q1| 0
-                                        |DFLOAT;rationalApproximation;$2NniF;87|)
+                                        |DFLOAT;rationalApproximation;$2NniF;86|)
                                        (EXIT
                                         (LOOP
                                           (COND
                                             (NIL (RETURN NIL))
                                             (T
                                              (SEQ
-                                              (LETT |#G107|
+                                              (LETT |#G106|
                                                (MULTIPLE-VALUE-CALL
                                                 #'CONS
                                                 (TRUNCATE |s| |t|))
-                                               |DFLOAT;rationalApproximation;$2NniF;87|)
-                                              (LETT |q| (CAR |#G107|)
-                                               |DFLOAT;rationalApproximation;$2NniF;87|)
-                                              (LETT |r| (CDR |#G107|)
-                                               |DFLOAT;rationalApproximation;$2NniF;87|)
-                                              |#G107|
+                                               |DFLOAT;rationalApproximation;$2NniF;86|)
+                                              (LETT |q| (CAR |#G106|)
+                                               |DFLOAT;rationalApproximation;$2NniF;86|)
+                                              (LETT |r| (CDR |#G106|)
+                                               |DFLOAT;rationalApproximation;$2NniF;86|)
+                                              |#G106|
                                               (LETT |p2|
                                                (+ (* |q| |p1|) |p0|)
-                                               |DFLOAT;rationalApproximation;$2NniF;87|)
+                                               |DFLOAT;rationalApproximation;$2NniF;86|)
                                               (LETT |q2|
                                                (+ (* |q| |q1|) |q0|)
-                                               |DFLOAT;rationalApproximation;$2NniF;87|)
+                                               |DFLOAT;rationalApproximation;$2NniF;86|)
                                               (COND
                                                 ((OR (ZEROP |r|)
                                                   (<
@@ -778,32 +819,32 @@
                                                      143))
                                                    (* |de| (ABS |p2|))))
                                                  (RETURN-FROM
-                                                  |DFLOAT;rationalApproximation;$2NniF;87|
+                                                  |DFLOAT;rationalApproximation;$2NniF;86|
                                                    (SPADCALL |p2| |q2|
                                                     (|getShellEntry| $
                                                      141)))))
-                                              (LETT |#G108| |p1|
-                                               |DFLOAT;rationalApproximation;$2NniF;87|)
-                                              (LETT |#G109| |p2|
-                                               |DFLOAT;rationalApproximation;$2NniF;87|)
-                                              (SETQ |p0| |#G108|)
-                                              (SETQ |p1| |#G109|)
-                                              (LETT |#G110| |q1|
-                                               |DFLOAT;rationalApproximation;$2NniF;87|)
-                                              (LETT |#G111| |q2|
-                                               |DFLOAT;rationalApproximation;$2NniF;87|)
-                                              (SETQ |q0| |#G110|)
-                                              (SETQ |q1| |#G111|)
+                                              (LETT |#G107| |p1|
+                                               |DFLOAT;rationalApproximation;$2NniF;86|)
+                                              (LETT |#G108| |p2|
+                                               |DFLOAT;rationalApproximation;$2NniF;86|)
+                                              (SETQ |p0| |#G107|)
+                                              (SETQ |p1| |#G108|)
+                                              (LETT |#G109| |q1|
+                                               |DFLOAT;rationalApproximation;$2NniF;86|)
+                                              (LETT |#G110| |q2|
+                                               |DFLOAT;rationalApproximation;$2NniF;86|)
+                                              (SETQ |q0| |#G109|)
+                                              (SETQ |q1| |#G110|)
                                               (EXIT
                                                (PROGN
-                                                 (LETT |#G112| |t|
-                                                  |DFLOAT;rationalApproximation;$2NniF;87|)
-                                                 (LETT |#G113| |r|
-                                                  |DFLOAT;rationalApproximation;$2NniF;87|)
-                                                 (SETQ |s| |#G112|)
-                                                 (SETQ |t| |#G113|))))))))))))))))))))) 
-
-(DEFUN |DFLOAT;**;$F$;88| (|x| |r| $)
+                                                 (LETT |#G111| |t|
+                                                  |DFLOAT;rationalApproximation;$2NniF;86|)
+                                                 (LETT |#G112| |r|
+                                                  |DFLOAT;rationalApproximation;$2NniF;86|)
+                                                 (SETQ |s| |#G111|)
+                                                 (SETQ |t| |#G112|))))))))))))))))))))) 
+
+(DEFUN |DFLOAT;**;$F$;87| (|x| |r| $)
   (PROG (|n| |d|)
     (RETURN
       (SEQ (COND
@@ -818,35 +859,36 @@
               1.0)
              ((SPADCALL |r| (|getShellEntry| $ 147)) |x|)
              (T (SEQ (LETT |n| (SPADCALL |r| (|getShellEntry| $ 148))
-                           |DFLOAT;**;$F$;88|)
+                           |DFLOAT;**;$F$;87|)
                      (LETT |d| (SPADCALL |r| (|getShellEntry| $ 149))
-                           |DFLOAT;**;$F$;88|)
+                           |DFLOAT;**;$F$;87|)
                      (EXIT (COND
                              ((MINUSP |x|)
                               (COND
                                 ((ODDP |d|)
                                  (COND
                                    ((ODDP |n|)
-                                    (RETURN-FROM |DFLOAT;**;$F$;88|
+                                    (RETURN-FROM |DFLOAT;**;$F$;87|
                                       (-
-                                       (|DFLOAT;**;$F$;88| (- |x|) |r|
+                                       (|DFLOAT;**;$F$;87| (- |x|) |r|
                                         $))))
                                    (T
-                                    (RETURN-FROM |DFLOAT;**;$F$;88|
-                                      (|DFLOAT;**;$F$;88| (- |x|) |r|
+                                    (RETURN-FROM |DFLOAT;**;$F$;87|
+                                      (|DFLOAT;**;$F$;87| (- |x|) |r|
                                        $)))))
                                 (T (|error| "negative root"))))
                              ((EQL |d| 2)
-                              (EXPT (|DFLOAT;sqrt;2$;33| |x| $) |n|))
-                             (T (|DFLOAT;**;3$;36| |x|
-                                    (/
-                                     (FLOAT |n| |$DoubleFloatMaximum|)
-                                     (FLOAT |d| |$DoubleFloatMaximum|))
-                                    $))))))))))) 
+                              (EXPT (C-TO-R (SQRT |x|)) |n|))
+                             (T (C-TO-R (EXPT |x|
+                                         (/
+                                          (FLOAT |n|
+                                           |$DoubleFloatMaximum|)
+                                          (FLOAT |d|
+                                           |$DoubleFloatMaximum|)))))))))))))) 
 
 (DEFUN |DoubleFloat| ()
   (DECLARE (SPECIAL |$ConstructorCache|))
-  (PROG (#0=#:G1556)
+  (PROG (#0=#:G1555)
     (RETURN
       (COND
         ((SETQ #0# (HGET |$ConstructorCache| '|DoubleFloat|))
@@ -873,63 +915,63 @@
     (LIST '#(NIL NIL NIL NIL NIL NIL (|OpenMathEncoding|)
              (0 . |OMencodingXML|) (|String|) (|OpenMathDevice|)
              (4 . |OMopenString|) (|Void|) (10 . |OMputObject|)
-             (|DoubleFloat|) |DFLOAT;convert;2$;76| (15 . |OMputFloat|)
+             (|DoubleFloat|) |DFLOAT;convert;2$;75| (15 . |OMputFloat|)
              (21 . |OMputEndObject|) (26 . |OMclose|)
              |DFLOAT;OMwrite;$S;1| (|Boolean|) |DFLOAT;OMwrite;$BS;2|
              |DFLOAT;OMwrite;Omd$V;3| |DFLOAT;OMwrite;Omd$BV;4|
-             (|PositiveInteger|) |DFLOAT;base;Pi;6| (|Integer|)
-             |DFLOAT;mantissa;$I;7| |DFLOAT;exponent;$I;8|
-             |DFLOAT;precision;Pi;9| (31 . =) (37 . *)
-             |DFLOAT;log2;2$;40| (43 . *) |DFLOAT;wholePart;$I;74|
-             |DFLOAT;bits;Pi;10| |DFLOAT;max;$;11| |DFLOAT;min;$;12|
-             (49 . +) (55 . |One|) (59 . -) |DFLOAT;order;$I;13|
+             (|PositiveInteger|) |DFLOAT;base;Pi;5| (|Integer|)
+             |DFLOAT;mantissa;$I;6| |DFLOAT;exponent;$I;7|
+             |DFLOAT;precision;Pi;8| (31 . =) (37 . *)
+             |DFLOAT;log2;2$;39| (43 . *) |DFLOAT;wholePart;$I;73|
+             |DFLOAT;bits;Pi;9| |DFLOAT;max;$;10| |DFLOAT;min;$;11|
+             (49 . +) (55 . |One|) (59 . -) |DFLOAT;order;$I;12|
              (65 . |Zero|)
              (CONS IDENTITY
-                   (FUNCALL (|dispatchFunction| |DFLOAT;Zero;$;14|) $))
+                   (FUNCALL (|dispatchFunction| |DFLOAT;Zero;$;13|) $))
              (CONS IDENTITY
-                   (FUNCALL (|dispatchFunction| |DFLOAT;One;$;15|) $))
-             |DFLOAT;/;3$;65| |DFLOAT;exp1;$;16| |DFLOAT;pi;$;17|
-             (|OutputForm|) (69 . |outputForm|) |DFLOAT;coerce;$Of;18|
-             (|InputForm|) (74 . |convert|) |DFLOAT;convert;$If;19|
-             |DFLOAT;<;2$B;20| |DFLOAT;>;2$B;21| |DFLOAT;<=;2$B;22|
-             |DFLOAT;>=;2$B;23| |DFLOAT;-;2$;24| |DFLOAT;+;3$;25|
-             |DFLOAT;-;3$;26| |DFLOAT;*;3$;27| |DFLOAT;*;I2$;28|
-             |DFLOAT;max;3$;29| |DFLOAT;min;3$;30| |DFLOAT;=;2$B;31|
-             |DFLOAT;/;$I$;32| |DFLOAT;sqrt;2$;33| |DFLOAT;log10;2$;34|
-             |DFLOAT;**;$I$;35| |DFLOAT;**;3$;36| (79 . |coerce|)
-             |DFLOAT;exp;2$;38| |DFLOAT;log;2$;39| |DFLOAT;sin;2$;41|
-             |DFLOAT;cos;2$;42| |DFLOAT;tan;2$;43| |DFLOAT;cot;2$;44|
-             |DFLOAT;sec;2$;45| |DFLOAT;csc;2$;46| |DFLOAT;asin;2$;47|
-             |DFLOAT;acos;2$;48| |DFLOAT;atan;2$;49|
-             |DFLOAT;acsc;2$;50| |DFLOAT;acot;2$;51|
-             |DFLOAT;asec;2$;52| |DFLOAT;sinh;2$;53|
-             |DFLOAT;cosh;2$;54| |DFLOAT;tanh;2$;55|
-             |DFLOAT;csch;2$;56| |DFLOAT;coth;2$;57|
-             |DFLOAT;sech;2$;58| |DFLOAT;asinh;2$;59|
-             |DFLOAT;acosh;2$;60| |DFLOAT;atanh;2$;61|
-             |DFLOAT;acsch;2$;62| |DFLOAT;acoth;2$;63|
-             |DFLOAT;asech;2$;64| |DFLOAT;negative?;$B;66|
-             |DFLOAT;zero?;$B;67| |DFLOAT;one?;$B;68| (|SingleInteger|)
-             |DFLOAT;hash;$Si;69| (|Union| $ '"failed")
-             |DFLOAT;recip;$U;70| |DFLOAT;differentiate;2$;71|
+                   (FUNCALL (|dispatchFunction| |DFLOAT;One;$;14|) $))
+             |DFLOAT;/;3$;64| |DFLOAT;exp1;$;15| |DFLOAT;pi;$;16|
+             (|OutputForm|) (69 . |outputForm|) |DFLOAT;coerce;$Of;17|
+             (|InputForm|) (74 . |convert|) |DFLOAT;convert;$If;18|
+             |DFLOAT;<;2$B;19| |DFLOAT;>;2$B;20| |DFLOAT;<=;2$B;21|
+             |DFLOAT;>=;2$B;22| |DFLOAT;-;2$;23| |DFLOAT;+;3$;24|
+             |DFLOAT;-;3$;25| |DFLOAT;*;3$;26| |DFLOAT;*;I2$;27|
+             |DFLOAT;max;3$;28| |DFLOAT;min;3$;29| |DFLOAT;=;2$B;30|
+             |DFLOAT;/;$I$;31| |DFLOAT;sqrt;2$;32| |DFLOAT;log10;2$;33|
+             |DFLOAT;**;$I$;34| |DFLOAT;**;3$;35| (79 . |coerce|)
+             |DFLOAT;exp;2$;37| |DFLOAT;log;2$;38| |DFLOAT;sin;2$;40|
+             |DFLOAT;cos;2$;41| |DFLOAT;tan;2$;42| |DFLOAT;cot;2$;43|
+             |DFLOAT;sec;2$;44| |DFLOAT;csc;2$;45| |DFLOAT;asin;2$;46|
+             |DFLOAT;acos;2$;47| |DFLOAT;atan;2$;48|
+             |DFLOAT;acsc;2$;49| |DFLOAT;acot;2$;50|
+             |DFLOAT;asec;2$;51| |DFLOAT;sinh;2$;52|
+             |DFLOAT;cosh;2$;53| |DFLOAT;tanh;2$;54|
+             |DFLOAT;csch;2$;55| |DFLOAT;coth;2$;56|
+             |DFLOAT;sech;2$;57| |DFLOAT;asinh;2$;58|
+             |DFLOAT;acosh;2$;59| |DFLOAT;atanh;2$;60|
+             |DFLOAT;acsch;2$;61| |DFLOAT;acoth;2$;62|
+             |DFLOAT;asech;2$;63| |DFLOAT;negative?;$B;65|
+             |DFLOAT;zero?;$B;66| |DFLOAT;one?;$B;67| (|SingleInteger|)
+             |DFLOAT;hash;$Si;68| (|Union| $ '"failed")
+             |DFLOAT;recip;$U;69| |DFLOAT;differentiate;2$;70|
              (|DoubleFloatSpecialFunctions|) (84 . |Gamma|)
-             |DFLOAT;Gamma;2$;72| (89 . |Beta|) |DFLOAT;Beta;3$;73|
-             |DFLOAT;float;2IPi$;75| (|Float|) (95 . |convert|)
-             |DFLOAT;convert;$F;77| (|Fraction| 25)
+             |DFLOAT;Gamma;2$;71| (89 . |Beta|) |DFLOAT;Beta;3$;72|
+             |DFLOAT;float;2IPi$;74| (|Float|) (95 . |convert|)
+             |DFLOAT;convert;$F;76| (|Fraction| 25)
              (|NonNegativeInteger|)
-             |DFLOAT;rationalApproximation;$2NniF;87|
-             |DFLOAT;rationalApproximation;$NniF;78| |DFLOAT;abs;2$;85|
-             |DFLOAT;atan;3$;79| (100 . |One|) |DFLOAT;retract;$F;80|
-             (|Union| 114 '"failed") |DFLOAT;retractIfCan;$U;81|
-             |DFLOAT;retract;$I;82| (|Union| 25 '"failed")
-             |DFLOAT;retractIfCan;$U;83| |DFLOAT;sign;$I;84| (104 . *)
+             |DFLOAT;rationalApproximation;$2NniF;86|
+             |DFLOAT;rationalApproximation;$NniF;77| |DFLOAT;abs;2$;84|
+             |DFLOAT;atan;3$;78| (100 . |One|) |DFLOAT;retract;$F;79|
+             (|Union| 114 '"failed") |DFLOAT;retractIfCan;$U;80|
+             |DFLOAT;retract;$I;81| (|Union| 25 '"failed")
+             |DFLOAT;retractIfCan;$U;82| |DFLOAT;sign;$I;83| (104 . *)
              (110 . **) (116 . |Zero|) (120 . |Zero|) (124 . >=)
              (130 . **) (136 . |coerce|) (141 . -) (146 . <) (152 . **)
              (|Record| (|:| |quotient| $) (|:| |remainder| $))
              (158 . |divide|) (164 . =) (170 . /) (176 . |abs|)
              (181 . *) (187 . <) (193 . |zero?|) (198 . |negative?|)
              (203 . |one?|) (208 . |numer|) (213 . |denom|)
-             (218 . |odd?|) |DFLOAT;**;$F$;88| |DFLOAT;coerce;I$;37|
+             (218 . |odd?|) |DFLOAT;**;$F$;87| |DFLOAT;coerce;I$;36|
              (|PatternMatchResult| 111 $) (|Pattern| 111)
              (|Factored| $) (|List| $) (|Union| 156 '"failed")
              (|Record| (|:| |coef1| $) (|:| |coef2| $)