* interp/compiler.boot (compGreaterThan): New. Compile

	greater-than expressions.
	* interp/parse.boot (parseGreaterThan): Remove.
	* algebra/data.spad.pamphlet (Byte): Implement all comparison
	functions. 
	* algebra/integer.spad.pamphlet (Integer): Likewise.
	* algebra/sf.spad.pamphlet (DoubleFloat): Likewise.
	* algebra/si.spad.pamphlet (SingleInteger): Likewise.
	* algebra/string.spad.pamphlet (Character): Likewise.

1 files changed, 424 insertions, 402 deletions

diff --git a/src/algebra/strap/DFLOAT.lsp b/src/algebra/strap/DFLOAT.lsp
index 582076db..3096aacb 100644
--- a/src/algebra/strap/DFLOAT.lsp
+++ b/src/algebra/strap/DFLOAT.lsp
@@ -83,284 +83,298 @@
 
 (PUT '|DFLOAT;<;2$B;20| '|SPADreplace| '<) 
 
+(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
+                    |%Boolean|)
+                |DFLOAT;>;2$B;21|)) 
+
+(PUT '|DFLOAT;>;2$B;21| '|SPADreplace| '>) 
+
+(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
+                    |%Boolean|)
+                |DFLOAT;<=;2$B;22|)) 
+
+(DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
+                    |%Boolean|)
+                |DFLOAT;>=;2$B;23|)) 
+
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;-;2$;21|)) 
+                |DFLOAT;-;2$;24|)) 
 
-(PUT '|DFLOAT;-;2$;21| '|SPADreplace| '-) 
+(PUT '|DFLOAT;-;2$;24| '|SPADreplace| '-) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
                     |%DoubleFloat|)
-                |DFLOAT;+;3$;22|)) 
+                |DFLOAT;+;3$;25|)) 
 
-(PUT '|DFLOAT;+;3$;22| '|SPADreplace| '+) 
+(PUT '|DFLOAT;+;3$;25| '|SPADreplace| '+) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
                     |%DoubleFloat|)
-                |DFLOAT;-;3$;23|)) 
+                |DFLOAT;-;3$;26|)) 
 
-(PUT '|DFLOAT;-;3$;23| '|SPADreplace| '-) 
+(PUT '|DFLOAT;-;3$;26| '|SPADreplace| '-) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
                     |%DoubleFloat|)
-                |DFLOAT;*;3$;24|)) 
+                |DFLOAT;*;3$;27|)) 
 
-(PUT '|DFLOAT;*;3$;24| '|SPADreplace| '*) 
+(PUT '|DFLOAT;*;3$;27| '|SPADreplace| '*) 
 
 (DECLAIM (FTYPE (FUNCTION (|%Integer| |%DoubleFloat| |%Shell|)
                     |%DoubleFloat|)
-                |DFLOAT;*;I2$;25|)) 
+                |DFLOAT;*;I2$;28|)) 
 
-(PUT '|DFLOAT;*;I2$;25| '|SPADreplace| '*) 
+(PUT '|DFLOAT;*;I2$;28| '|SPADreplace| '*) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
                     |%DoubleFloat|)
-                |DFLOAT;max;3$;26|)) 
+                |DFLOAT;max;3$;29|)) 
 
-(PUT '|DFLOAT;max;3$;26| '|SPADreplace| 'MAX) 
+(PUT '|DFLOAT;max;3$;29| '|SPADreplace| 'MAX) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
                     |%DoubleFloat|)
-                |DFLOAT;min;3$;27|)) 
+                |DFLOAT;min;3$;30|)) 
 
-(PUT '|DFLOAT;min;3$;27| '|SPADreplace| 'MIN) 
+(PUT '|DFLOAT;min;3$;30| '|SPADreplace| 'MIN) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
                     |%Boolean|)
-                |DFLOAT;=;2$B;28|)) 
+                |DFLOAT;=;2$B;31|)) 
 
-(PUT '|DFLOAT;=;2$B;28| '|SPADreplace| '=) 
+(PUT '|DFLOAT;=;2$B;31| '|SPADreplace| '=) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Integer| |%Shell|)
                     |%DoubleFloat|)
-                |DFLOAT;/;$I$;29|)) 
+                |DFLOAT;/;$I$;32|)) 
 
-(PUT '|DFLOAT;/;$I$;29| '|SPADreplace| '/) 
+(PUT '|DFLOAT;/;$I$;32| '|SPADreplace| '/) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;sqrt;2$;30|)) 
+                |DFLOAT;sqrt;2$;33|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;log10;2$;31|)) 
+                |DFLOAT;log10;2$;34|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Integer| |%Shell|)
                     |%DoubleFloat|)
-                |DFLOAT;**;$I$;32|)) 
+                |DFLOAT;**;$I$;35|)) 
 
-(PUT '|DFLOAT;**;$I$;32| '|SPADreplace| 'EXPT) 
+(PUT '|DFLOAT;**;$I$;35| '|SPADreplace| 'EXPT) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
                     |%DoubleFloat|)
-                |DFLOAT;**;3$;33|)) 
+                |DFLOAT;**;3$;36|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%Integer| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;coerce;I$;34|)) 
+                |DFLOAT;coerce;I$;37|)) 
 
-(PUT '|DFLOAT;coerce;I$;34| '|SPADreplace|
+(PUT '|DFLOAT;coerce;I$;37| '|SPADreplace|
      '(XLAM (|i|) (FLOAT |i| |$DoubleFloatMaximum|))) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;exp;2$;35|)) 
+                |DFLOAT;exp;2$;38|)) 
 
-(PUT '|DFLOAT;exp;2$;35| '|SPADreplace| 'EXP) 
+(PUT '|DFLOAT;exp;2$;38| '|SPADreplace| 'EXP) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;log;2$;36|)) 
+                |DFLOAT;log;2$;39|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;log2;2$;37|)) 
+                |DFLOAT;log2;2$;40|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;sin;2$;38|)) 
+                |DFLOAT;sin;2$;41|)) 
 
-(PUT '|DFLOAT;sin;2$;38| '|SPADreplace| 'SIN) 
+(PUT '|DFLOAT;sin;2$;41| '|SPADreplace| 'SIN) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;cos;2$;39|)) 
+                |DFLOAT;cos;2$;42|)) 
 
-(PUT '|DFLOAT;cos;2$;39| '|SPADreplace| 'COS) 
+(PUT '|DFLOAT;cos;2$;42| '|SPADreplace| 'COS) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;tan;2$;40|)) 
+                |DFLOAT;tan;2$;43|)) 
 
-(PUT '|DFLOAT;tan;2$;40| '|SPADreplace| 'TAN) 
+(PUT '|DFLOAT;tan;2$;43| '|SPADreplace| 'TAN) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;cot;2$;41|)) 
+                |DFLOAT;cot;2$;44|)) 
 
-(PUT '|DFLOAT;cot;2$;41| '|SPADreplace| 'COT) 
+(PUT '|DFLOAT;cot;2$;44| '|SPADreplace| 'COT) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;sec;2$;42|)) 
+                |DFLOAT;sec;2$;45|)) 
 
-(PUT '|DFLOAT;sec;2$;42| '|SPADreplace| 'SEC) 
+(PUT '|DFLOAT;sec;2$;45| '|SPADreplace| 'SEC) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;csc;2$;43|)) 
+                |DFLOAT;csc;2$;46|)) 
 
-(PUT '|DFLOAT;csc;2$;43| '|SPADreplace| 'CSC) 
+(PUT '|DFLOAT;csc;2$;46| '|SPADreplace| 'CSC) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;asin;2$;44|)) 
+                |DFLOAT;asin;2$;47|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;acos;2$;45|)) 
+                |DFLOAT;acos;2$;48|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;atan;2$;46|)) 
+                |DFLOAT;atan;2$;49|)) 
 
-(PUT '|DFLOAT;atan;2$;46| '|SPADreplace| 'ATAN) 
+(PUT '|DFLOAT;atan;2$;49| '|SPADreplace| 'ATAN) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;acsc;2$;47|)) 
+                |DFLOAT;acsc;2$;50|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;acot;2$;48|)) 
+                |DFLOAT;acot;2$;51|)) 
 
-(PUT '|DFLOAT;acot;2$;48| '|SPADreplace| 'ACOT) 
+(PUT '|DFLOAT;acot;2$;51| '|SPADreplace| 'ACOT) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;asec;2$;49|)) 
+                |DFLOAT;asec;2$;52|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;sinh;2$;50|)) 
+                |DFLOAT;sinh;2$;53|)) 
 
-(PUT '|DFLOAT;sinh;2$;50| '|SPADreplace| 'SINH) 
+(PUT '|DFLOAT;sinh;2$;53| '|SPADreplace| 'SINH) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;cosh;2$;51|)) 
+                |DFLOAT;cosh;2$;54|)) 
 
-(PUT '|DFLOAT;cosh;2$;51| '|SPADreplace| 'COSH) 
+(PUT '|DFLOAT;cosh;2$;54| '|SPADreplace| 'COSH) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;tanh;2$;52|)) 
+                |DFLOAT;tanh;2$;55|)) 
 
-(PUT '|DFLOAT;tanh;2$;52| '|SPADreplace| 'TANH) 
+(PUT '|DFLOAT;tanh;2$;55| '|SPADreplace| 'TANH) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;csch;2$;53|)) 
+                |DFLOAT;csch;2$;56|)) 
 
-(PUT '|DFLOAT;csch;2$;53| '|SPADreplace| 'CSCH) 
+(PUT '|DFLOAT;csch;2$;56| '|SPADreplace| 'CSCH) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;coth;2$;54|)) 
+                |DFLOAT;coth;2$;57|)) 
 
-(PUT '|DFLOAT;coth;2$;54| '|SPADreplace| 'COTH) 
+(PUT '|DFLOAT;coth;2$;57| '|SPADreplace| 'COTH) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;sech;2$;55|)) 
+                |DFLOAT;sech;2$;58|)) 
 
-(PUT '|DFLOAT;sech;2$;55| '|SPADreplace| 'SECH) 
+(PUT '|DFLOAT;sech;2$;58| '|SPADreplace| 'SECH) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;asinh;2$;56|)) 
+                |DFLOAT;asinh;2$;59|)) 
 
-(PUT '|DFLOAT;asinh;2$;56| '|SPADreplace| 'ASINH) 
+(PUT '|DFLOAT;asinh;2$;59| '|SPADreplace| 'ASINH) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;acosh;2$;57|)) 
+                |DFLOAT;acosh;2$;60|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;atanh;2$;58|)) 
+                |DFLOAT;atanh;2$;61|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;acsch;2$;59|)) 
+                |DFLOAT;acsch;2$;62|)) 
 
-(PUT '|DFLOAT;acsch;2$;59| '|SPADreplace| 'ACSCH) 
+(PUT '|DFLOAT;acsch;2$;62| '|SPADreplace| 'ACSCH) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;acoth;2$;60|)) 
+                |DFLOAT;acoth;2$;63|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;asech;2$;61|)) 
+                |DFLOAT;asech;2$;64|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
                     |%DoubleFloat|)
-                |DFLOAT;/;3$;62|)) 
+                |DFLOAT;/;3$;65|)) 
 
-(PUT '|DFLOAT;/;3$;62| '|SPADreplace| '/) 
+(PUT '|DFLOAT;/;3$;65| '|SPADreplace| '/) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Boolean|)
-                |DFLOAT;negative?;$B;63|)) 
+                |DFLOAT;negative?;$B;66|)) 
 
-(PUT '|DFLOAT;negative?;$B;63| '|SPADreplace| 'MINUSP) 
+(PUT '|DFLOAT;negative?;$B;66| '|SPADreplace| 'MINUSP) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Boolean|)
-                |DFLOAT;zero?;$B;64|)) 
+                |DFLOAT;zero?;$B;67|)) 
 
-(PUT '|DFLOAT;zero?;$B;64| '|SPADreplace| 'ZEROP) 
+(PUT '|DFLOAT;zero?;$B;67| '|SPADreplace| 'ZEROP) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Boolean|)
-                |DFLOAT;one?;$B;65|)) 
+                |DFLOAT;one?;$B;68|)) 
 
-(PUT '|DFLOAT;one?;$B;65| '|SPADreplace| '(XLAM (|x|) (= |x| 1.0))) 
+(PUT '|DFLOAT;one?;$B;68| '|SPADreplace| '(XLAM (|x|) (= |x| 1.0))) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Short|)
-                |DFLOAT;hash;$Si;66|)) 
+                |DFLOAT;hash;$Si;69|)) 
 
-(PUT '|DFLOAT;hash;$Si;66| '|SPADreplace| 'HASHEQ) 
+(PUT '|DFLOAT;hash;$Si;69| '|SPADreplace| 'HASHEQ) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Pair|)
-                |DFLOAT;recip;$U;67|)) 
+                |DFLOAT;recip;$U;70|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;differentiate;2$;68|)) 
+                |DFLOAT;differentiate;2$;71|)) 
 
-(PUT '|DFLOAT;differentiate;2$;68| '|SPADreplace| '(XLAM (|x|) 0.0)) 
+(PUT '|DFLOAT;differentiate;2$;71| '|SPADreplace| '(XLAM (|x|) 0.0)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;Gamma;2$;69|)) 
+                |DFLOAT;Gamma;2$;72|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
                     |%DoubleFloat|)
-                |DFLOAT;Beta;3$;70|)) 
+                |DFLOAT;Beta;3$;73|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Integer|)
-                |DFLOAT;wholePart;$I;71|)) 
+                |DFLOAT;wholePart;$I;74|)) 
 
-(PUT '|DFLOAT;wholePart;$I;71| '|SPADreplace| 'FIX) 
+(PUT '|DFLOAT;wholePart;$I;74| '|SPADreplace| 'FIX) 
 
 (DECLAIM (FTYPE (FUNCTION
                     (|%Integer| |%Integer| (|%IntegerSection| 1)
                         |%Shell|)
                     |%DoubleFloat|)
-                |DFLOAT;float;2IPi$;72|)) 
+                |DFLOAT;float;2IPi$;75|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;convert;2$;73|)) 
+                |DFLOAT;convert;2$;76|)) 
 
-(PUT '|DFLOAT;convert;2$;73| '|SPADreplace| '(XLAM (|x|) |x|)) 
+(PUT '|DFLOAT;convert;2$;76| '|SPADreplace| '(XLAM (|x|) |x|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Thing|)
-                |DFLOAT;convert;$F;74|)) 
+                |DFLOAT;convert;$F;77|)) 
 
 (DECLAIM (FTYPE (FUNCTION
                     (|%DoubleFloat| (|%IntegerSection| 0) |%Shell|)
                     |%Thing|)
-                |DFLOAT;rationalApproximation;$NniF;75|)) 
+                |DFLOAT;rationalApproximation;$NniF;78|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%DoubleFloat| |%Shell|)
                     |%DoubleFloat|)
-                |DFLOAT;atan;3$;76|)) 
+                |DFLOAT;atan;3$;79|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Thing|)
-                |DFLOAT;retract;$F;77|)) 
+                |DFLOAT;retract;$F;80|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Pair|)
-                |DFLOAT;retractIfCan;$U;78|)) 
+                |DFLOAT;retractIfCan;$U;81|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Integer|)
-                |DFLOAT;retract;$I;79|)) 
+                |DFLOAT;retract;$I;82|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Pair|)
-                |DFLOAT;retractIfCan;$U;80|)) 
+                |DFLOAT;retractIfCan;$U;83|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Integer|)
-                |DFLOAT;sign;$I;81|)) 
+                |DFLOAT;sign;$I;84|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%DoubleFloat|)
-                |DFLOAT;abs;2$;82|)) 
+                |DFLOAT;abs;2$;85|)) 
 
-(PUT '|DFLOAT;abs;2$;82| '|SPADreplace|
+(PUT '|DFLOAT;abs;2$;85| '|SPADreplace|
      '(XLAM (|x|) (FLOAT-SIGN 1.0 |x|))) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Shell|) |%Pair|)
@@ -370,11 +384,11 @@
                     (|%DoubleFloat| (|%IntegerSection| 0)
                         (|%IntegerSection| 0) |%Shell|)
                     |%Thing|)
-                |DFLOAT;rationalApproximation;$2NniF;84|)) 
+                |DFLOAT;rationalApproximation;$2NniF;87|)) 
 
 (DECLAIM (FTYPE (FUNCTION (|%DoubleFloat| |%Thing| |%Shell|)
                     |%DoubleFloat|)
-                |DFLOAT;**;$F$;85|)) 
+                |DFLOAT;**;$F$;88|)) 
 
 (DEFUN |DFLOAT;OMwrite;$S;1| (|x| $)
   (PROG (|sp| |dev| |s|)
@@ -444,7 +458,7 @@
         ('T
          (PROG1 (LETT #0#
                       (FIX (SPADCALL (FLOAT-DIGITS 0.0)
-                               (|DFLOAT;log2;2$;37|
+                               (|DFLOAT;log2;2$;40|
                                    (FLOAT (FLOAT-RADIX 0.0)
                                     |$DoubleFloatMaximum|)
                                    $)
@@ -486,211 +500,217 @@
 
 (DEFUN |DFLOAT;<;2$B;20| (|x| |y| $) (DECLARE (IGNORE $)) (< |x| |y|)) 
 
-(DEFUN |DFLOAT;-;2$;21| (|x| $) (DECLARE (IGNORE $)) (- |x|)) 
+(DEFUN |DFLOAT;>;2$B;21| (|x| |y| $) (DECLARE (IGNORE $)) (> |x| |y|)) 
+
+(DEFUN |DFLOAT;<=;2$B;22| (|x| |y| $) (NOT (> |x| |y|))) 
+
+(DEFUN |DFLOAT;>=;2$B;23| (|x| |y| $) (NOT (< |x| |y|))) 
+
+(DEFUN |DFLOAT;-;2$;24| (|x| $) (DECLARE (IGNORE $)) (- |x|)) 
 
-(DEFUN |DFLOAT;+;3$;22| (|x| |y| $) (DECLARE (IGNORE $)) (+ |x| |y|)) 
+(DEFUN |DFLOAT;+;3$;25| (|x| |y| $) (DECLARE (IGNORE $)) (+ |x| |y|)) 
 
-(DEFUN |DFLOAT;-;3$;23| (|x| |y| $) (DECLARE (IGNORE $)) (- |x| |y|)) 
+(DEFUN |DFLOAT;-;3$;26| (|x| |y| $) (DECLARE (IGNORE $)) (- |x| |y|)) 
 
-(DEFUN |DFLOAT;*;3$;24| (|x| |y| $) (DECLARE (IGNORE $)) (* |x| |y|)) 
+(DEFUN |DFLOAT;*;3$;27| (|x| |y| $) (DECLARE (IGNORE $)) (* |x| |y|)) 
 
-(DEFUN |DFLOAT;*;I2$;25| (|i| |x| $) (DECLARE (IGNORE $)) (* |i| |x|)) 
+(DEFUN |DFLOAT;*;I2$;28| (|i| |x| $) (DECLARE (IGNORE $)) (* |i| |x|)) 
 
-(DEFUN |DFLOAT;max;3$;26| (|x| |y| $)
+(DEFUN |DFLOAT;max;3$;29| (|x| |y| $)
   (DECLARE (IGNORE $))
   (MAX |x| |y|)) 
 
-(DEFUN |DFLOAT;min;3$;27| (|x| |y| $)
+(DEFUN |DFLOAT;min;3$;30| (|x| |y| $)
   (DECLARE (IGNORE $))
   (MIN |x| |y|)) 
 
-(DEFUN |DFLOAT;=;2$B;28| (|x| |y| $) (DECLARE (IGNORE $)) (= |x| |y|)) 
+(DEFUN |DFLOAT;=;2$B;31| (|x| |y| $) (DECLARE (IGNORE $)) (= |x| |y|)) 
 
-(DEFUN |DFLOAT;/;$I$;29| (|x| |i| $) (DECLARE (IGNORE $)) (/ |x| |i|)) 
+(DEFUN |DFLOAT;/;$I$;32| (|x| |i| $) (DECLARE (IGNORE $)) (/ |x| |i|)) 
 
-(DEFUN |DFLOAT;sqrt;2$;30| (|x| $) (C-TO-R (SQRT |x|))) 
+(DEFUN |DFLOAT;sqrt;2$;33| (|x| $) (C-TO-R (SQRT |x|))) 
 
-(DEFUN |DFLOAT;log10;2$;31| (|x| $) (C-TO-R (|log| |x|))) 
+(DEFUN |DFLOAT;log10;2$;34| (|x| $) (C-TO-R (|log| |x|))) 
 
-(DEFUN |DFLOAT;**;$I$;32| (|x| |i| $)
+(DEFUN |DFLOAT;**;$I$;35| (|x| |i| $)
   (DECLARE (IGNORE $))
   (EXPT |x| |i|)) 
 
-(DEFUN |DFLOAT;**;3$;33| (|x| |y| $) (C-TO-R (EXPT |x| |y|))) 
+(DEFUN |DFLOAT;**;3$;36| (|x| |y| $) (C-TO-R (EXPT |x| |y|))) 
 
-(DEFUN |DFLOAT;coerce;I$;34| (|i| $)
+(DEFUN |DFLOAT;coerce;I$;37| (|i| $)
   (DECLARE (IGNORE $))
   (FLOAT |i| |$DoubleFloatMaximum|)) 
 
-(DEFUN |DFLOAT;exp;2$;35| (|x| $) (DECLARE (IGNORE $)) (EXP |x|)) 
+(DEFUN |DFLOAT;exp;2$;38| (|x| $) (DECLARE (IGNORE $)) (EXP |x|)) 
 
-(DEFUN |DFLOAT;log;2$;36| (|x| $) (C-TO-R (LN |x|))) 
+(DEFUN |DFLOAT;log;2$;39| (|x| $) (C-TO-R (LN |x|))) 
 
-(DEFUN |DFLOAT;log2;2$;37| (|x| $) (C-TO-R (LOG2 |x|))) 
+(DEFUN |DFLOAT;log2;2$;40| (|x| $) (C-TO-R (LOG2 |x|))) 
 
-(DEFUN |DFLOAT;sin;2$;38| (|x| $) (DECLARE (IGNORE $)) (SIN |x|)) 
+(DEFUN |DFLOAT;sin;2$;41| (|x| $) (DECLARE (IGNORE $)) (SIN |x|)) 
 
-(DEFUN |DFLOAT;cos;2$;39| (|x| $) (DECLARE (IGNORE $)) (COS |x|)) 
+(DEFUN |DFLOAT;cos;2$;42| (|x| $) (DECLARE (IGNORE $)) (COS |x|)) 
 
-(DEFUN |DFLOAT;tan;2$;40| (|x| $) (DECLARE (IGNORE $)) (TAN |x|)) 
+(DEFUN |DFLOAT;tan;2$;43| (|x| $) (DECLARE (IGNORE $)) (TAN |x|)) 
 
-(DEFUN |DFLOAT;cot;2$;41| (|x| $) (DECLARE (IGNORE $)) (COT |x|)) 
+(DEFUN |DFLOAT;cot;2$;44| (|x| $) (DECLARE (IGNORE $)) (COT |x|)) 
 
-(DEFUN |DFLOAT;sec;2$;42| (|x| $) (DECLARE (IGNORE $)) (SEC |x|)) 
+(DEFUN |DFLOAT;sec;2$;45| (|x| $) (DECLARE (IGNORE $)) (SEC |x|)) 
 
-(DEFUN |DFLOAT;csc;2$;43| (|x| $) (DECLARE (IGNORE $)) (CSC |x|)) 
+(DEFUN |DFLOAT;csc;2$;46| (|x| $) (DECLARE (IGNORE $)) (CSC |x|)) 
 
-(DEFUN |DFLOAT;asin;2$;44| (|x| $) (C-TO-R (ASIN |x|))) 
+(DEFUN |DFLOAT;asin;2$;47| (|x| $) (C-TO-R (ASIN |x|))) 
 
-(DEFUN |DFLOAT;acos;2$;45| (|x| $) (C-TO-R (ACOS |x|))) 
+(DEFUN |DFLOAT;acos;2$;48| (|x| $) (C-TO-R (ACOS |x|))) 
 
-(DEFUN |DFLOAT;atan;2$;46| (|x| $) (DECLARE (IGNORE $)) (ATAN |x|)) 
+(DEFUN |DFLOAT;atan;2$;49| (|x| $) (DECLARE (IGNORE $)) (ATAN |x|)) 
 
-(DEFUN |DFLOAT;acsc;2$;47| (|x| $) (C-TO-R (ACSC |x|))) 
+(DEFUN |DFLOAT;acsc;2$;50| (|x| $) (C-TO-R (ACSC |x|))) 
 
-(DEFUN |DFLOAT;acot;2$;48| (|x| $) (DECLARE (IGNORE $)) (ACOT |x|)) 
+(DEFUN |DFLOAT;acot;2$;51| (|x| $) (DECLARE (IGNORE $)) (ACOT |x|)) 
 
-(DEFUN |DFLOAT;asec;2$;49| (|x| $) (C-TO-R (ASEC |x|))) 
+(DEFUN |DFLOAT;asec;2$;52| (|x| $) (C-TO-R (ASEC |x|))) 
 
-(DEFUN |DFLOAT;sinh;2$;50| (|x| $) (DECLARE (IGNORE $)) (SINH |x|)) 
+(DEFUN |DFLOAT;sinh;2$;53| (|x| $) (DECLARE (IGNORE $)) (SINH |x|)) 
 
-(DEFUN |DFLOAT;cosh;2$;51| (|x| $) (DECLARE (IGNORE $)) (COSH |x|)) 
+(DEFUN |DFLOAT;cosh;2$;54| (|x| $) (DECLARE (IGNORE $)) (COSH |x|)) 
 
-(DEFUN |DFLOAT;tanh;2$;52| (|x| $) (DECLARE (IGNORE $)) (TANH |x|)) 
+(DEFUN |DFLOAT;tanh;2$;55| (|x| $) (DECLARE (IGNORE $)) (TANH |x|)) 
 
-(DEFUN |DFLOAT;csch;2$;53| (|x| $) (DECLARE (IGNORE $)) (CSCH |x|)) 
+(DEFUN |DFLOAT;csch;2$;56| (|x| $) (DECLARE (IGNORE $)) (CSCH |x|)) 
 
-(DEFUN |DFLOAT;coth;2$;54| (|x| $) (DECLARE (IGNORE $)) (COTH |x|)) 
+(DEFUN |DFLOAT;coth;2$;57| (|x| $) (DECLARE (IGNORE $)) (COTH |x|)) 
 
-(DEFUN |DFLOAT;sech;2$;55| (|x| $) (DECLARE (IGNORE $)) (SECH |x|)) 
+(DEFUN |DFLOAT;sech;2$;58| (|x| $) (DECLARE (IGNORE $)) (SECH |x|)) 
 
-(DEFUN |DFLOAT;asinh;2$;56| (|x| $) (DECLARE (IGNORE $)) (ASINH |x|)) 
+(DEFUN |DFLOAT;asinh;2$;59| (|x| $) (DECLARE (IGNORE $)) (ASINH |x|)) 
 
-(DEFUN |DFLOAT;acosh;2$;57| (|x| $) (C-TO-R (ACOSH |x|))) 
+(DEFUN |DFLOAT;acosh;2$;60| (|x| $) (C-TO-R (ACOSH |x|))) 
 
-(DEFUN |DFLOAT;atanh;2$;58| (|x| $) (C-TO-R (ATANH |x|))) 
+(DEFUN |DFLOAT;atanh;2$;61| (|x| $) (C-TO-R (ATANH |x|))) 
 
-(DEFUN |DFLOAT;acsch;2$;59| (|x| $) (DECLARE (IGNORE $)) (ACSCH |x|)) 
+(DEFUN |DFLOAT;acsch;2$;62| (|x| $) (DECLARE (IGNORE $)) (ACSCH |x|)) 
 
-(DEFUN |DFLOAT;acoth;2$;60| (|x| $) (C-TO-R (ACOTH |x|))) 
+(DEFUN |DFLOAT;acoth;2$;63| (|x| $) (C-TO-R (ACOTH |x|))) 
 
-(DEFUN |DFLOAT;asech;2$;61| (|x| $) (C-TO-R (ASECH |x|))) 
+(DEFUN |DFLOAT;asech;2$;64| (|x| $) (C-TO-R (ASECH |x|))) 
 
-(DEFUN |DFLOAT;/;3$;62| (|x| |y| $) (DECLARE (IGNORE $)) (/ |x| |y|)) 
+(DEFUN |DFLOAT;/;3$;65| (|x| |y| $) (DECLARE (IGNORE $)) (/ |x| |y|)) 
 
-(DEFUN |DFLOAT;negative?;$B;63| (|x| $)
+(DEFUN |DFLOAT;negative?;$B;66| (|x| $)
   (DECLARE (IGNORE $))
   (MINUSP |x|)) 
 
-(DEFUN |DFLOAT;zero?;$B;64| (|x| $) (DECLARE (IGNORE $)) (ZEROP |x|)) 
+(DEFUN |DFLOAT;zero?;$B;67| (|x| $) (DECLARE (IGNORE $)) (ZEROP |x|)) 
 
-(DEFUN |DFLOAT;one?;$B;65| (|x| $) (DECLARE (IGNORE $)) (= |x| 1.0)) 
+(DEFUN |DFLOAT;one?;$B;68| (|x| $) (DECLARE (IGNORE $)) (= |x| 1.0)) 
 
-(DEFUN |DFLOAT;hash;$Si;66| (|x| $) (DECLARE (IGNORE $)) (HASHEQ |x|)) 
+(DEFUN |DFLOAT;hash;$Si;69| (|x| $) (DECLARE (IGNORE $)) (HASHEQ |x|)) 
 
-(DEFUN |DFLOAT;recip;$U;67| (|x| $)
+(DEFUN |DFLOAT;recip;$U;70| (|x| $)
   (COND ((ZEROP |x|) (CONS 1 "failed")) ('T (CONS 0 (/ 1.0 |x|))))) 
 
-(DEFUN |DFLOAT;differentiate;2$;68| (|x| $) (DECLARE (IGNORE $)) 0.0) 
+(DEFUN |DFLOAT;differentiate;2$;71| (|x| $) (DECLARE (IGNORE $)) 0.0) 
 
-(DEFUN |DFLOAT;Gamma;2$;69| (|x| $)
-  (SPADCALL |x| (|getShellEntry| $ 104))) 
+(DEFUN |DFLOAT;Gamma;2$;72| (|x| $)
+  (SPADCALL |x| (|getShellEntry| $ 108))) 
 
-(DEFUN |DFLOAT;Beta;3$;70| (|x| |y| $)
-  (SPADCALL |x| |y| (|getShellEntry| $ 106))) 
+(DEFUN |DFLOAT;Beta;3$;73| (|x| |y| $)
+  (SPADCALL |x| |y| (|getShellEntry| $ 110))) 
 
-(DEFUN |DFLOAT;wholePart;$I;71| (|x| $)
+(DEFUN |DFLOAT;wholePart;$I;74| (|x| $)
   (DECLARE (IGNORE $))
   (FIX |x|)) 
 
-(DEFUN |DFLOAT;float;2IPi$;72| (|ma| |ex| |b| $)
+(DEFUN |DFLOAT;float;2IPi$;75| (|ma| |ex| |b| $)
   (* |ma| (EXPT (FLOAT |b| |$DoubleFloatMaximum|) |ex|))) 
 
-(DEFUN |DFLOAT;convert;2$;73| (|x| $) (DECLARE (IGNORE $)) |x|) 
+(DEFUN |DFLOAT;convert;2$;76| (|x| $) (DECLARE (IGNORE $)) |x|) 
 
-(DEFUN |DFLOAT;convert;$F;74| (|x| $)
-  (SPADCALL |x| (|getShellEntry| $ 110))) 
+(DEFUN |DFLOAT;convert;$F;77| (|x| $)
+  (SPADCALL |x| (|getShellEntry| $ 114))) 
 
-(DEFUN |DFLOAT;rationalApproximation;$NniF;75| (|x| |d| $)
-  (|DFLOAT;rationalApproximation;$2NniF;84| |x| |d| 10 $)) 
+(DEFUN |DFLOAT;rationalApproximation;$NniF;78| (|x| |d| $)
+  (|DFLOAT;rationalApproximation;$2NniF;87| |x| |d| 10 $)) 
 
-(DEFUN |DFLOAT;atan;3$;76| (|x| |y| $)
+(DEFUN |DFLOAT;atan;3$;79| (|x| |y| $)
   (PROG (|theta|)
     (RETURN
       (SEQ (COND
              ((= |x| 0.0)
               (COND
-                ((< 0.0 |y|) (/ PI 2))
+                ((> |y| 0.0) (/ PI 2))
                 ((< |y| 0.0) (- (/ PI 2)))
                 ('T 0.0)))
              ('T
               (SEQ (LETT |theta| (ATAN (FLOAT-SIGN 1.0 (/ |y| |x|)))
-                         |DFLOAT;atan;3$;76|)
+                         |DFLOAT;atan;3$;79|)
                    (COND
                      ((< |x| 0.0)
-                      (LETT |theta| (- PI |theta|) |DFLOAT;atan;3$;76|)))
+                      (LETT |theta| (- PI |theta|) |DFLOAT;atan;3$;79|)))
                    (COND
                      ((< |y| 0.0)
-                      (LETT |theta| (- |theta|) |DFLOAT;atan;3$;76|)))
+                      (LETT |theta| (- |theta|) |DFLOAT;atan;3$;79|)))
                    (EXIT |theta|)))))))) 
 
-(DEFUN |DFLOAT;retract;$F;77| (|x| $)
-  (PROG (#0=#:G1501)
+(DEFUN |DFLOAT;retract;$F;80| (|x| $)
+  (PROG (#0=#:G1504)
     (RETURN
-      (|DFLOAT;rationalApproximation;$2NniF;84| |x|
+      (|DFLOAT;rationalApproximation;$2NniF;87| |x|
           (PROG1 (LETT #0# (- (FLOAT-DIGITS 0.0) 1)
-                       |DFLOAT;retract;$F;77|)
+                       |DFLOAT;retract;$F;80|)
             (|check-subtype| (NOT (< #0# 0)) '(|NonNegativeInteger|)
                 #0#))
           (FLOAT-RADIX 0.0) $)))) 
 
-(DEFUN |DFLOAT;retractIfCan;$U;78| (|x| $)
-  (PROG (#0=#:G1506)
+(DEFUN |DFLOAT;retractIfCan;$U;81| (|x| $)
+  (PROG (#0=#:G1509)
     (RETURN
       (CONS 0
-            (|DFLOAT;rationalApproximation;$2NniF;84| |x|
+            (|DFLOAT;rationalApproximation;$2NniF;87| |x|
                 (PROG1 (LETT #0# (- (FLOAT-DIGITS 0.0) 1)
-                             |DFLOAT;retractIfCan;$U;78|)
+                             |DFLOAT;retractIfCan;$U;81|)
                   (|check-subtype| (NOT (< #0# 0))
                       '(|NonNegativeInteger|) #0#))
                 (FLOAT-RADIX 0.0) $))))) 
 
-(DEFUN |DFLOAT;retract;$I;79| (|x| $)
+(DEFUN |DFLOAT;retract;$I;82| (|x| $)
   (PROG (|n|)
     (RETURN
-      (SEQ (LETT |n| (FIX |x|) |DFLOAT;retract;$I;79|)
+      (SEQ (LETT |n| (FIX |x|) |DFLOAT;retract;$I;82|)
            (EXIT (COND
                    ((= |x| (FLOAT |n| |$DoubleFloatMaximum|)) |n|)
                    ('T (|error| "Not an integer")))))))) 
 
-(DEFUN |DFLOAT;retractIfCan;$U;80| (|x| $)
+(DEFUN |DFLOAT;retractIfCan;$U;83| (|x| $)
   (PROG (|n|)
     (RETURN
-      (SEQ (LETT |n| (FIX |x|) |DFLOAT;retractIfCan;$U;80|)
+      (SEQ (LETT |n| (FIX |x|) |DFLOAT;retractIfCan;$U;83|)
            (EXIT (COND
                    ((= |x| (FLOAT |n| |$DoubleFloatMaximum|))
                     (CONS 0 |n|))
                    ('T (CONS 1 "failed")))))))) 
 
-(DEFUN |DFLOAT;sign;$I;81| (|x| $)
-  (|DFLOAT;retract;$I;79| (FLOAT-SIGN |x| 1.0) $)) 
+(DEFUN |DFLOAT;sign;$I;84| (|x| $)
+  (|DFLOAT;retract;$I;82| (FLOAT-SIGN |x| 1.0) $)) 
 
-(DEFUN |DFLOAT;abs;2$;82| (|x| $)
+(DEFUN |DFLOAT;abs;2$;85| (|x| $)
   (DECLARE (IGNORE $))
   (FLOAT-SIGN 1.0 |x|)) 
 
 (DEFUN |DFLOAT;manexp| (|x| $)
-  (PROG (|s| #0=#:G1527 |me| |two53|)
+  (PROG (|s| #0=#:G1530 |me| |two53|)
     (RETURN
       (SEQ (EXIT (COND
                    ((ZEROP |x|) (CONS 0 0))
                    ('T
-                    (SEQ (LETT |s| (|DFLOAT;sign;$I;81| |x| $)
+                    (SEQ (LETT |s| (|DFLOAT;sign;$I;84| |x| $)
                                |DFLOAT;manexp|)
                          (LETT |x| (FLOAT-SIGN 1.0 |x|)
                                |DFLOAT;manexp|)
                          (COND
-                           ((< |$DoubleFloatMaximum| |x|)
+                           ((> |x| |$DoubleFloatMaximum|)
                             (PROGN
                               (LETT #0#
                                     (CONS
@@ -713,32 +733,32 @@
                                      (- (QCDR |me|) (FLOAT-DIGITS 0.0))))))))
            #0# (EXIT #0#))))) 
 
-(DEFUN |DFLOAT;rationalApproximation;$2NniF;84| (|f| |d| |b| $)
-  (PROG (|#G103| |nu| |ex| BASE #0=#:G1530 |de| |tol| |#G104| |q| |r|
-                 |p2| |q2| #1=#:G1539 |#G105| |#G106| |p0| |p1| |#G107|
-                 |#G108| |q0| |q1| |#G109| |#G110| |s| |t|)
+(DEFUN |DFLOAT;rationalApproximation;$2NniF;87| (|f| |d| |b| $)
+  (PROG (|#G109| |nu| |ex| BASE #0=#:G1533 |de| |tol| |#G110| |q| |r|
+                 |p2| |q2| #1=#:G1542 |#G111| |#G112| |p0| |p1| |#G113|
+                 |#G114| |q0| |q1| |#G115| |#G116| |s| |t|)
     (RETURN
       (SEQ (EXIT (SEQ (PROGN
-                        (LETT |#G103| (|DFLOAT;manexp| |f| $)
-                              |DFLOAT;rationalApproximation;$2NniF;84|)
-                        (LETT |nu| (QCAR |#G103|)
-                              |DFLOAT;rationalApproximation;$2NniF;84|)
-                        (LETT |ex| (QCDR |#G103|)
-                              |DFLOAT;rationalApproximation;$2NniF;84|)
-                        |#G103|)
+                        (LETT |#G109| (|DFLOAT;manexp| |f| $)
+                              |DFLOAT;rationalApproximation;$2NniF;87|)
+                        (LETT |nu| (QCAR |#G109|)
+                              |DFLOAT;rationalApproximation;$2NniF;87|)
+                        (LETT |ex| (QCDR |#G109|)
+                              |DFLOAT;rationalApproximation;$2NniF;87|)
+                        |#G109|)
                       (LETT BASE (FLOAT-RADIX 0.0)
-                            |DFLOAT;rationalApproximation;$2NniF;84|)
+                            |DFLOAT;rationalApproximation;$2NniF;87|)
                       (EXIT (COND
                               ((< |ex| 0)
                                (SEQ (LETT |de|
                                      (EXPT BASE
                                       (PROG1
                                        (LETT #0# (- |ex|)
-                                        |DFLOAT;rationalApproximation;$2NniF;84|)
+                                        |DFLOAT;rationalApproximation;$2NniF;87|)
                                         (|check-subtype|
                                          (NOT (< #0# 0))
                                          '(|NonNegativeInteger|) #0#)))
-                                     |DFLOAT;rationalApproximation;$2NniF;84|)
+                                     |DFLOAT;rationalApproximation;$2NniF;87|)
                                     (EXIT
                                      (COND
                                        ((< |b| 2)
@@ -746,37 +766,37 @@
                                        ('T
                                         (SEQ
                                          (LETT |tol| (EXPT |b| |d|)
-                                          |DFLOAT;rationalApproximation;$2NniF;84|)
+                                          |DFLOAT;rationalApproximation;$2NniF;87|)
                                          (LETT |s| |nu|
-                                          |DFLOAT;rationalApproximation;$2NniF;84|)
+                                          |DFLOAT;rationalApproximation;$2NniF;87|)
                                          (LETT |t| |de|
-                                          |DFLOAT;rationalApproximation;$2NniF;84|)
+                                          |DFLOAT;rationalApproximation;$2NniF;87|)
                                          (LETT |p0| 0
-                                          |DFLOAT;rationalApproximation;$2NniF;84|)
+                                          |DFLOAT;rationalApproximation;$2NniF;87|)
                                          (LETT |p1| 1
-                                          |DFLOAT;rationalApproximation;$2NniF;84|)
+                                          |DFLOAT;rationalApproximation;$2NniF;87|)
                                          (LETT |q0| 1
-                                          |DFLOAT;rationalApproximation;$2NniF;84|)
+                                          |DFLOAT;rationalApproximation;$2NniF;87|)
                                          (LETT |q1| 0
-                                          |DFLOAT;rationalApproximation;$2NniF;84|)
+                                          |DFLOAT;rationalApproximation;$2NniF;87|)
                                          (EXIT
                                           (SEQ G190 NIL
                                            (SEQ
                                             (PROGN
-                                              (LETT |#G104|
+                                              (LETT |#G110|
                                                (DIVIDE2 |s| |t|)
-                                               |DFLOAT;rationalApproximation;$2NniF;84|)
-                                              (LETT |q| (QCAR |#G104|)
-                                               |DFLOAT;rationalApproximation;$2NniF;84|)
-                                              (LETT |r| (QCDR |#G104|)
-                                               |DFLOAT;rationalApproximation;$2NniF;84|)
-                                              |#G104|)
+                                               |DFLOAT;rationalApproximation;$2NniF;87|)
+                                              (LETT |q| (QCAR |#G110|)
+                                               |DFLOAT;rationalApproximation;$2NniF;87|)
+                                              (LETT |r| (QCDR |#G110|)
+                                               |DFLOAT;rationalApproximation;$2NniF;87|)
+                                              |#G110|)
                                             (LETT |p2|
                                              (+ (* |q| |p1|) |p0|)
-                                             |DFLOAT;rationalApproximation;$2NniF;84|)
+                                             |DFLOAT;rationalApproximation;$2NniF;87|)
                                             (LETT |q2|
                                              (+ (* |q| |q1|) |q0|)
-                                             |DFLOAT;rationalApproximation;$2NniF;84|)
+                                             |DFLOAT;rationalApproximation;$2NniF;87|)
                                             (COND
                                               ((OR (EQL |r| 0)
                                                 (<
@@ -785,44 +805,44 @@
                                                    (- (* |nu| |q2|)
                                                     (* |de| |p2|)))
                                                   (|getShellEntry| $
-                                                   141))
+                                                   145))
                                                  (* |de| (ABS |p2|))))
                                                (EXIT
                                                 (PROGN
                                                   (LETT #1#
                                                    (SPADCALL |p2| |q2|
                                                     (|getShellEntry| $
-                                                     139))
-                                                   |DFLOAT;rationalApproximation;$2NniF;84|)
+                                                     143))
+                                                   |DFLOAT;rationalApproximation;$2NniF;87|)
                                                   (GO #1#)))))
                                             (PROGN
-                                              (LETT |#G105| |p1|
-                                               |DFLOAT;rationalApproximation;$2NniF;84|)
-                                              (LETT |#G106| |p2|
-                                               |DFLOAT;rationalApproximation;$2NniF;84|)
-                                              (LETT |p0| |#G105|
-                                               |DFLOAT;rationalApproximation;$2NniF;84|)
-                                              (LETT |p1| |#G106|
-                                               |DFLOAT;rationalApproximation;$2NniF;84|))
+                                              (LETT |#G111| |p1|
+                                               |DFLOAT;rationalApproximation;$2NniF;87|)
+                                              (LETT |#G112| |p2|
+                                               |DFLOAT;rationalApproximation;$2NniF;87|)
+                                              (LETT |p0| |#G111|
+                                               |DFLOAT;rationalApproximation;$2NniF;87|)
+                                              (LETT |p1| |#G112|
+                                               |DFLOAT;rationalApproximation;$2NniF;87|))
                                             (PROGN
-                                              (LETT |#G107| |q1|
-                                               |DFLOAT;rationalApproximation;$2NniF;84|)
-                                              (LETT |#G108| |q2|
-                                               |DFLOAT;rationalApproximation;$2NniF;84|)
-                                              (LETT |q0| |#G107|
-                                               |DFLOAT;rationalApproximation;$2NniF;84|)
-                                              (LETT |q1| |#G108|
-                                               |DFLOAT;rationalApproximation;$2NniF;84|))
+                                              (LETT |#G113| |q1|
+                                               |DFLOAT;rationalApproximation;$2NniF;87|)
+                                              (LETT |#G114| |q2|
+                                               |DFLOAT;rationalApproximation;$2NniF;87|)
+                                              (LETT |q0| |#G113|
+                                               |DFLOAT;rationalApproximation;$2NniF;87|)
+                                              (LETT |q1| |#G114|
+                                               |DFLOAT;rationalApproximation;$2NniF;87|))
                                             (EXIT
                                              (PROGN
-                                               (LETT |#G109| |t|
-                                                |DFLOAT;rationalApproximation;$2NniF;84|)
-                                               (LETT |#G110| |r|
-                                                |DFLOAT;rationalApproximation;$2NniF;84|)
-                                               (LETT |s| |#G109|
-                                                |DFLOAT;rationalApproximation;$2NniF;84|)
-                                               (LETT |t| |#G110|
-                                                |DFLOAT;rationalApproximation;$2NniF;84|))))
+                                               (LETT |#G115| |t|
+                                                |DFLOAT;rationalApproximation;$2NniF;87|)
+                                               (LETT |#G116| |r|
+                                                |DFLOAT;rationalApproximation;$2NniF;87|)
+                                               (LETT |s| |#G115|
+                                                |DFLOAT;rationalApproximation;$2NniF;87|)
+                                               (LETT |t| |#G116|
+                                                |DFLOAT;rationalApproximation;$2NniF;87|))))
                                            NIL (GO G190) G191
                                            (EXIT NIL)))))))))
                               ('T
@@ -833,35 +853,35 @@
                                        (|check-subtype|
                                         (NOT (< |ex| 0))
                                         '(|NonNegativeInteger|) |ex|))))
-                                   (|getShellEntry| $ 142)))))))
+                                   (|getShellEntry| $ 146)))))))
            #1# (EXIT #1#))))) 
 
-(DEFUN |DFLOAT;**;$F$;85| (|x| |r| $)
-  (PROG (|n| |d| #0=#:G1549)
+(DEFUN |DFLOAT;**;$F$;88| (|x| |r| $)
+  (PROG (|n| |d| #0=#:G1552)
     (RETURN
       (SEQ (EXIT (COND
                    ((ZEROP |x|)
                     (COND
-                      ((SPADCALL |r| (|getShellEntry| $ 143))
+                      ((SPADCALL |r| (|getShellEntry| $ 147))
                        (|error| "0**0 is undefined"))
-                      ((SPADCALL |r| (|getShellEntry| $ 144))
+                      ((SPADCALL |r| (|getShellEntry| $ 148))
                        (|error| "division by 0"))
                       ('T 0.0)))
-                   ((OR (SPADCALL |r| (|getShellEntry| $ 143))
+                   ((OR (SPADCALL |r| (|getShellEntry| $ 147))
                         (= |x| 1.0))
                     1.0)
                    ('T
                     (COND
-                      ((SPADCALL |r| (|getShellEntry| $ 145)) |x|)
+                      ((SPADCALL |r| (|getShellEntry| $ 149)) |x|)
                       ('T
                        (SEQ (LETT |n|
                                   (SPADCALL |r|
-                                      (|getShellEntry| $ 146))
-                                  |DFLOAT;**;$F$;85|)
+                                      (|getShellEntry| $ 150))
+                                  |DFLOAT;**;$F$;88|)
                             (LETT |d|
                                   (SPADCALL |r|
-                                      (|getShellEntry| $ 147))
-                                  |DFLOAT;**;$F$;85|)
+                                      (|getShellEntry| $ 151))
+                                  |DFLOAT;**;$F$;88|)
                             (EXIT (COND
                                     ((MINUSP |x|)
                                      (COND
@@ -871,23 +891,23 @@
                                            (PROGN
                                              (LETT #0#
                                               (-
-                                               (|DFLOAT;**;$F$;85|
+                                               (|DFLOAT;**;$F$;88|
                                                 (- |x|) |r| $))
-                                              |DFLOAT;**;$F$;85|)
+                                              |DFLOAT;**;$F$;88|)
                                              (GO #0#)))
                                           ('T
                                            (PROGN
                                              (LETT #0#
-                                              (|DFLOAT;**;$F$;85|
+                                              (|DFLOAT;**;$F$;88|
                                                (- |x|) |r| $)
-                                              |DFLOAT;**;$F$;85|)
+                                              |DFLOAT;**;$F$;88|)
                                              (GO #0#)))))
                                        ('T (|error| "negative root"))))
                                     ((EQL |d| 2)
-                                     (EXPT (|DFLOAT;sqrt;2$;30| |x| $)
+                                     (EXPT (|DFLOAT;sqrt;2$;33| |x| $)
                                       |n|))
                                     ('T
-                                     (|DFLOAT;**;3$;33| |x|
+                                     (|DFLOAT;**;3$;36| |x|
                                       (/
                                        (FLOAT |n|
                                         |$DoubleFloatMaximum|)
@@ -899,7 +919,7 @@
 (DEFUN |DoubleFloat| ()
   (PROG ()
     (RETURN
-      (PROG (#0=#:G1561)
+      (PROG (#0=#:G1564)
         (RETURN
           (COND
             ((LETT #0# (HGET |$ConstructorCache| '|DoubleFloat|)
@@ -920,7 +940,7 @@
     (RETURN
       (PROGN
         (LETT |dv$| '(|DoubleFloat|) . #0=(|DoubleFloat|))
-        (LETT $ (|newShell| 161) . #0#)
+        (LETT $ (|newShell| 165) . #0#)
         (|setShellEntry| $ 0 |dv$|)
         (|setShellEntry| $ 3
             (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
@@ -932,7 +952,7 @@
     (LIST '#(NIL NIL NIL NIL NIL NIL (|OpenMathEncoding|)
              (0 . |OMencodingXML|) (|String|) (|OpenMathDevice|)
              (4 . |OMopenString|) (|Void|) (10 . |OMputObject|)
-             (|DoubleFloat|) |DFLOAT;convert;2$;73| (15 . |OMputFloat|)
+             (|DoubleFloat|) |DFLOAT;convert;2$;76| (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|
@@ -941,89 +961,91 @@
              (|PositiveInteger|) |DFLOAT;base;Pi;6| (|Integer|)
              |DFLOAT;mantissa;$I;7| |DFLOAT;exponent;$I;8|
              |DFLOAT;precision;Pi;9| (31 . |base|) (35 . =) (41 . *)
-             (47 . |coerce|) |DFLOAT;log2;2$;37| (52 . *)
-             |DFLOAT;wholePart;$I;71| |DFLOAT;bits;Pi;10|
+             (47 . |coerce|) |DFLOAT;log2;2$;40| (52 . *)
+             |DFLOAT;wholePart;$I;74| |DFLOAT;bits;Pi;10|
              |DFLOAT;max;$;11| |DFLOAT;min;$;12| (58 . +) (64 . |One|)
              (68 . -) |DFLOAT;order;$I;13|
              (CONS IDENTITY
                    (FUNCALL (|dispatchFunction| |DFLOAT;One;$;15|) $))
-             |DFLOAT;/;3$;62| |DFLOAT;exp1;$;16| |DFLOAT;pi;$;17|
+             |DFLOAT;/;3$;65| |DFLOAT;exp1;$;16| |DFLOAT;pi;$;17|
              (|OutputForm|) (74 . |outputForm|) |DFLOAT;coerce;$Of;18|
              (|InputForm|) (79 . |convert|) |DFLOAT;convert;$If;19|
-             |DFLOAT;<;2$B;20| |DFLOAT;-;2$;21| |DFLOAT;+;3$;22|
-             |DFLOAT;-;3$;23| |DFLOAT;*;3$;24| |DFLOAT;*;I2$;25|
-             |DFLOAT;max;3$;26| |DFLOAT;min;3$;27| |DFLOAT;=;2$B;28|
-             |DFLOAT;/;$I$;29| |DFLOAT;sqrt;2$;30| |DFLOAT;log10;2$;31|
-             |DFLOAT;**;$I$;32| |DFLOAT;**;3$;33| |DFLOAT;coerce;I$;34|
-             |DFLOAT;exp;2$;35| |DFLOAT;log;2$;36| |DFLOAT;sin;2$;38|
-             |DFLOAT;cos;2$;39| |DFLOAT;tan;2$;40| |DFLOAT;cot;2$;41|
-             |DFLOAT;sec;2$;42| |DFLOAT;csc;2$;43| |DFLOAT;asin;2$;44|
-             |DFLOAT;acos;2$;45| |DFLOAT;atan;2$;46|
-             |DFLOAT;acsc;2$;47| |DFLOAT;acot;2$;48|
-             |DFLOAT;asec;2$;49| |DFLOAT;sinh;2$;50|
-             |DFLOAT;cosh;2$;51| |DFLOAT;tanh;2$;52|
-             |DFLOAT;csch;2$;53| |DFLOAT;coth;2$;54|
-             |DFLOAT;sech;2$;55| |DFLOAT;asinh;2$;56|
-             |DFLOAT;acosh;2$;57| |DFLOAT;atanh;2$;58|
-             |DFLOAT;acsch;2$;59| |DFLOAT;acoth;2$;60|
-             |DFLOAT;asech;2$;61| |DFLOAT;negative?;$B;63|
-             |DFLOAT;zero?;$B;64| |DFLOAT;one?;$B;65| (|SingleInteger|)
-             |DFLOAT;hash;$Si;66| (|Union| $ '"failed")
-             |DFLOAT;recip;$U;67| |DFLOAT;differentiate;2$;68|
-             (|DoubleFloatSpecialFunctions|) (84 . |Gamma|)
-             |DFLOAT;Gamma;2$;69| (89 . |Beta|) |DFLOAT;Beta;3$;70|
-             |DFLOAT;float;2IPi$;72| (|Float|) (95 . |convert|)
-             |DFLOAT;convert;$F;74| (|Fraction| 26)
+             |DFLOAT;<;2$B;20| |DFLOAT;>;2$B;21| (84 . |not|)
+             |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|
+             |DFLOAT;coerce;I$;37| |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|
+             (|DoubleFloatSpecialFunctions|) (89 . |Gamma|)
+             |DFLOAT;Gamma;2$;72| (94 . |Beta|) |DFLOAT;Beta;3$;73|
+             |DFLOAT;float;2IPi$;75| (|Float|) (100 . |convert|)
+             |DFLOAT;convert;$F;77| (|Fraction| 26)
              (|NonNegativeInteger|)
-             |DFLOAT;rationalApproximation;$2NniF;84|
-             |DFLOAT;rationalApproximation;$NniF;75| (100 . |Zero|)
-             |DFLOAT;abs;2$;82| |DFLOAT;atan;3$;76| (104 . |One|)
-             |DFLOAT;retract;$F;77| (|Union| 112 '"failed")
-             |DFLOAT;retractIfCan;$U;78| |DFLOAT;retract;$I;79|
-             (|Union| 26 '"failed") |DFLOAT;retractIfCan;$U;80|
-             |DFLOAT;sign;$I;81| (108 . *) (114 . **) (120 . |Zero|)
-             (124 . |Zero|) (128 . <) (134 . -) (139 . **) (145 . <)
-             (151 . **)
+             |DFLOAT;rationalApproximation;$2NniF;87|
+             |DFLOAT;rationalApproximation;$NniF;78| (105 . |Zero|)
+             |DFLOAT;abs;2$;85| |DFLOAT;atan;3$;79| (109 . |One|)
+             |DFLOAT;retract;$F;80| (|Union| 116 '"failed")
+             |DFLOAT;retractIfCan;$U;81| |DFLOAT;retract;$I;82|
+             (|Union| 26 '"failed") |DFLOAT;retractIfCan;$U;83|
+             |DFLOAT;sign;$I;84| (113 . *) (119 . **) (125 . |Zero|)
+             (129 . |Zero|) (133 . <) (139 . -) (144 . **) (150 . <)
+             (156 . **)
              (|Record| (|:| |quotient| $) (|:| |remainder| $))
-             (157 . |divide|) (163 . =) (169 . /) (175 . |abs|)
-             (180 . *) (186 . |coerce|) (191 . |zero?|)
-             (196 . |negative?|) (201 . |one?|) (206 . |numer|)
-             (211 . |denom|) (216 . |odd?|) |DFLOAT;**;$F$;85|
-             (|PatternMatchResult| 109 $) (|Pattern| 109)
-             (|Factored| $) (|List| $) (|Union| 153 '"failed")
+             (162 . |divide|) (168 . =) (174 . /) (180 . |abs|)
+             (185 . *) (191 . |coerce|) (196 . |zero?|)
+             (201 . |negative?|) (206 . |one?|) (211 . |numer|)
+             (216 . |denom|) (221 . |odd?|) |DFLOAT;**;$F$;88|
+             (|PatternMatchResult| 113 $) (|Pattern| 113)
+             (|Factored| $) (|List| $) (|Union| 157 '"failed")
              (|Record| (|:| |coef1| $) (|:| |coef2| $)
                  (|:| |generator| $))
              (|Record| (|:| |coef1| $) (|:| |coef2| $))
-             (|Union| 156 '"failed")
-             (|Record| (|:| |coef| 153) (|:| |generator| $))
+             (|Union| 160 '"failed")
+             (|Record| (|:| |coef| 157) (|:| |generator| $))
              (|SparseUnivariatePolynomial| $)
              (|Record| (|:| |unit| $) (|:| |canonical| $)
                  (|:| |associate| $)))
-          '#(~= 221 |zero?| 227 |wholePart| 232 |unitNormal| 237
-             |unitCanonical| 242 |unit?| 247 |truncate| 252 |tanh| 257
-             |tan| 262 |subtractIfCan| 267 |squareFreePart| 273
-             |squareFree| 278 |sqrt| 283 |sizeLess?| 288 |sinh| 294
-             |sin| 299 |sign| 304 |sech| 309 |sec| 314 |sample| 319
-             |round| 323 |retractIfCan| 328 |retract| 338 |rem| 348
-             |recip| 354 |rationalApproximation| 359 |quo| 372
-             |principalIdeal| 378 |prime?| 383 |precision| 388
-             |positive?| 392 |pi| 397 |patternMatch| 401 |order| 408
-             |one?| 413 |nthRoot| 418 |norm| 424 |negative?| 429
-             |multiEuclidean| 434 |min| 440 |max| 450 |mantissa| 460
-             |log2| 465 |log10| 470 |log| 475 |lcm| 480 |latex| 491
-             |inv| 496 |hash| 501 |gcdPolynomial| 506 |gcd| 512
-             |fractionPart| 523 |floor| 528 |float| 533 |factor| 546
-             |extendedEuclidean| 551 |exquo| 564 |expressIdealMember|
-             570 |exponent| 576 |exp1| 581 |exp| 585 |euclideanSize|
-             590 |divide| 595 |digits| 601 |differentiate| 605 |csch|
-             616 |csc| 621 |coth| 626 |cot| 631 |cosh| 636 |cos| 641
-             |convert| 646 |coerce| 666 |characteristic| 696 |ceiling|
-             700 |bits| 705 |before?| 709 |base| 715 |atanh| 719 |atan|
-             724 |associates?| 735 |asinh| 741 |asin| 746 |asech| 751
-             |asec| 756 |acsch| 761 |acsc| 766 |acoth| 771 |acot| 776
-             |acosh| 781 |acos| 786 |abs| 791 |Zero| 796 |One| 800
-             |OMwrite| 804 |Gamma| 828 D 833 |Beta| 844 >= 850 > 856 =
-             862 <= 868 < 874 / 880 - 892 + 903 ** 909 * 939)
+          '#(~= 226 |zero?| 232 |wholePart| 237 |unitNormal| 242
+             |unitCanonical| 247 |unit?| 252 |truncate| 257 |tanh| 262
+             |tan| 267 |subtractIfCan| 272 |squareFreePart| 278
+             |squareFree| 283 |sqrt| 288 |sizeLess?| 293 |sinh| 299
+             |sin| 304 |sign| 309 |sech| 314 |sec| 319 |sample| 324
+             |round| 328 |retractIfCan| 333 |retract| 343 |rem| 353
+             |recip| 359 |rationalApproximation| 364 |quo| 377
+             |principalIdeal| 383 |prime?| 388 |precision| 393
+             |positive?| 397 |pi| 402 |patternMatch| 406 |order| 413
+             |one?| 418 |nthRoot| 423 |norm| 429 |negative?| 434
+             |multiEuclidean| 439 |min| 445 |max| 455 |mantissa| 465
+             |log2| 470 |log10| 475 |log| 480 |lcm| 485 |latex| 496
+             |inv| 501 |hash| 506 |gcdPolynomial| 511 |gcd| 517
+             |fractionPart| 528 |floor| 533 |float| 538 |factor| 551
+             |extendedEuclidean| 556 |exquo| 569 |expressIdealMember|
+             575 |exponent| 581 |exp1| 586 |exp| 590 |euclideanSize|
+             595 |divide| 600 |digits| 606 |differentiate| 610 |csch|
+             621 |csc| 626 |coth| 631 |cot| 636 |cosh| 641 |cos| 646
+             |convert| 651 |coerce| 671 |characteristic| 701 |ceiling|
+             705 |bits| 710 |before?| 714 |base| 720 |atanh| 724 |atan|
+             729 |associates?| 740 |asinh| 746 |asin| 751 |asech| 756
+             |asec| 761 |acsch| 766 |acsc| 771 |acoth| 776 |acot| 781
+             |acosh| 786 |acos| 791 |abs| 796 |Zero| 801 |One| 805
+             |OMwrite| 809 |Gamma| 833 D 838 |Beta| 849 >= 855 > 861 =
+             867 <= 873 < 879 / 885 - 897 + 908 ** 914 * 944)
           '((|approximate| . 0) (|canonicalsClosed| . 0)
             (|canonicalUnitNormal| . 0) (|noZeroDivisors| . 0)
             ((|commutative| "*") . 0) (|rightUnitary| . 0)
@@ -1058,14 +1080,14 @@
                                (|PrincipalIdealDomain|)
                                (|UniqueFactorizationDomain|)
                                (|GcdDomain|) (|DivisionRing|)
-                               (|IntegralDomain|) (|Algebra| 112)
+                               (|IntegralDomain|) (|Algebra| 116)
                                (|Algebra| $$) (|DifferentialRing|)
                                (|CharacteristicZero|) (|OrderedRing|)
-                               (|Module| 112) (|EntireRing|)
+                               (|Module| 116) (|EntireRing|)
                                (|CommutativeRing|) (|Module| $$)
-                               (|BiModule| 112 112) (|BiModule| $$ $$)
+                               (|BiModule| 116 116) (|BiModule| $$ $$)
                                (|Ring|) (|OrderedAbelianGroup|)
-                               (|RightModule| 112) (|LeftModule| 112)
+                               (|RightModule| 116) (|LeftModule| 116)
                                (|LeftModule| $$) (|Rng|)
                                (|RightModule| $$)
                                (|OrderedCancellationAbelianMonoid|)
@@ -1073,17 +1095,17 @@
                                (|OrderedAbelianMonoid|)
                                (|CancellationAbelianMonoid|)
                                (|OrderedAbelianSemiGroup|)
-                               (|LinearSet| 112) (|LinearSet| $$)
+                               (|LinearSet| 116) (|LinearSet| $$)
                                (|AbelianMonoid|) (|Monoid|)
-                               (|PatternMatchable| 109) (|OrderedSet|)
-                               (|LeftLinearSet| 112)
-                               (|RightLinearSet| 112)
+                               (|PatternMatchable| 113) (|OrderedSet|)
+                               (|LeftLinearSet| 116)
+                               (|RightLinearSet| 116)
                                (|LeftLinearSet| $$)
                                (|RightLinearSet| $$)
                                (|AbelianSemiGroup|) (|SemiGroup|)
                                (|LeftLinearSet| 26)
                                (|TranscendentalFunctionCategory|)
-                               (|RetractableTo| 112)
+                               (|RetractableTo| 116)
                                (|RetractableTo| 26) (|RealConstant|)
                                (|SetCategory|) (|ConvertibleTo| 51)
                                (|ElementaryFunctionCategory|)
@@ -1091,79 +1113,79 @@
                                (|HyperbolicFunctionCategory|)
                                (|ArcTrigonometricFunctionCategory|)
                                (|TrigonometricFunctionCategory|)
-                               (|OpenMath|) (|ConvertibleTo| 151)
+                               (|OpenMath|) (|ConvertibleTo| 155)
                                (|RadicalCategory|)
-                               (|ConvertibleTo| 109)
+                               (|ConvertibleTo| 113)
                                (|ConvertibleTo| 13)
-                               (|CoercibleFrom| 112)
+                               (|CoercibleFrom| 116)
                                (|CoercibleFrom| $$)
                                (|CoercibleFrom| 26) (|BasicType|)
                                (|CoercibleTo| 48))
-                            (|makeByteWordVec2| 160
+                            (|makeByteWordVec2| 164
                                 '(0 6 0 7 2 9 0 8 6 10 1 9 11 0 12 2 9
                                   11 0 13 15 1 9 11 0 16 1 9 11 0 17 0
                                   26 0 30 2 24 19 0 0 31 2 24 0 24 0 32
                                   1 0 0 26 33 2 0 0 24 0 35 2 26 0 0 0
                                   40 0 26 0 41 2 26 0 0 0 42 1 48 0 13
-                                  49 1 51 0 13 52 1 103 13 13 104 2 103
-                                  13 13 13 106 1 109 0 13 110 0 26 0
-                                  116 0 24 0 119 2 26 0 26 0 127 2 26 0
-                                  0 113 128 0 112 0 129 0 113 0 130 2
-                                  26 19 0 0 131 1 26 0 0 132 2 24 0 0
-                                  113 133 2 113 19 0 0 134 2 113 0 0
-                                  113 135 2 26 136 0 0 137 2 26 19 0 0
-                                  138 2 112 0 26 26 139 1 26 0 0 140 2
-                                  26 0 113 0 141 1 112 0 26 142 1 112
-                                  19 0 143 1 112 19 0 144 1 112 19 0
-                                  145 1 112 26 0 146 1 112 26 0 147 1
-                                  26 19 0 148 2 0 19 0 0 1 1 0 19 0 96
-                                  1 0 26 0 36 1 0 160 0 1 1 0 0 0 1 1 0
-                                  19 0 1 1 0 0 0 1 1 0 0 0 85 1 0 0 0
-                                  73 2 0 100 0 0 1 1 0 0 0 1 1 0 152 0
-                                  1 1 0 0 0 64 2 0 19 0 0 1 1 0 0 0 83
-                                  1 0 0 0 71 1 0 26 0 126 1 0 0 0 88 1
-                                  0 0 0 75 0 0 0 1 1 0 0 0 1 1 0 121 0
-                                  122 1 0 124 0 125 1 0 112 0 120 1 0
-                                  26 0 123 2 0 0 0 0 1 1 0 100 0 101 2
-                                  0 112 0 113 115 3 0 112 0 113 113 114
-                                  2 0 0 0 0 1 1 0 158 153 1 1 0 19 0 1
-                                  0 0 24 29 1 0 19 0 1 0 0 0 47 3 0 150
-                                  0 151 150 1 1 0 26 0 43 1 0 19 0 97 2
-                                  0 0 0 26 1 1 0 0 0 1 1 0 19 0 95 2 0
-                                  154 153 0 1 0 0 0 39 2 0 0 0 0 61 0 0
-                                  0 38 2 0 0 0 0 60 1 0 26 0 27 1 0 0 0
-                                  34 1 0 0 0 65 1 0 0 0 70 1 0 0 153 1
-                                  2 0 0 0 0 1 1 0 8 0 1 1 0 0 0 1 1 0
-                                  98 0 99 2 0 159 159 159 1 1 0 0 153 1
-                                  2 0 0 0 0 1 1 0 0 0 1 1 0 0 0 1 3 0 0
-                                  26 26 24 108 2 0 0 26 26 1 1 0 152 0
-                                  1 2 0 155 0 0 1 3 0 157 0 0 0 1 2 0
-                                  100 0 0 1 2 0 154 153 0 1 1 0 26 0 28
-                                  0 0 0 46 1 0 0 0 69 1 0 113 0 1 2 0
-                                  136 0 0 1 0 0 24 1 1 0 0 0 102 2 0 0
-                                  0 113 1 1 0 0 0 86 1 0 0 0 76 1 0 0 0
-                                  87 1 0 0 0 74 1 0 0 0 84 1 0 0 0 72 1
-                                  0 51 0 53 1 0 151 0 1 1 0 109 0 111 1
-                                  0 13 0 14 1 0 0 112 1 1 0 0 26 68 1 0
-                                  0 112 1 1 0 0 0 1 1 0 0 26 68 1 0 48
-                                  0 50 0 0 113 1 1 0 0 0 1 0 0 24 37 2
-                                  0 19 0 0 1 0 0 24 25 1 0 0 0 91 2 0 0
-                                  0 0 118 1 0 0 0 79 2 0 19 0 0 1 1 0 0
-                                  0 89 1 0 0 0 77 1 0 0 0 94 1 0 0 0 82
-                                  1 0 0 0 92 1 0 0 0 80 1 0 0 0 93 1 0
-                                  0 0 81 1 0 0 0 90 1 0 0 0 78 1 0 0 0
-                                  117 0 0 0 23 0 0 0 44 2 0 11 9 0 21 3
-                                  0 11 9 0 19 22 1 0 8 0 18 2 0 8 0 19
-                                  20 1 0 0 0 105 1 0 0 0 1 2 0 0 0 113
-                                  1 2 0 0 0 0 107 2 0 19 0 0 1 2 0 19 0
-                                  0 1 2 0 19 0 0 62 2 0 19 0 0 1 2 0 19
-                                  0 0 54 2 0 0 0 26 63 2 0 0 0 0 45 2 0
-                                  0 0 0 57 1 0 0 0 55 2 0 0 0 0 56 2 0
-                                  0 0 0 67 2 0 0 0 112 149 2 0 0 0 26
-                                  66 2 0 0 0 113 1 2 0 0 0 24 1 2 0 0
-                                  112 0 1 2 0 0 0 112 1 2 0 0 0 0 58 2
-                                  0 0 26 0 59 2 0 0 113 0 1 2 0 0 24 0
-                                  35)))))
+                                  49 1 51 0 13 52 1 19 0 0 56 1 107 13
+                                  13 108 2 107 13 13 13 110 1 113 0 13
+                                  114 0 26 0 120 0 24 0 123 2 26 0 26 0
+                                  131 2 26 0 0 117 132 0 116 0 133 0
+                                  117 0 134 2 26 19 0 0 135 1 26 0 0
+                                  136 2 24 0 0 117 137 2 117 19 0 0 138
+                                  2 117 0 0 117 139 2 26 140 0 0 141 2
+                                  26 19 0 0 142 2 116 0 26 26 143 1 26
+                                  0 0 144 2 26 0 117 0 145 1 116 0 26
+                                  146 1 116 19 0 147 1 116 19 0 148 1
+                                  116 19 0 149 1 116 26 0 150 1 116 26
+                                  0 151 1 26 19 0 152 2 0 19 0 0 1 1 0
+                                  19 0 100 1 0 26 0 36 1 0 164 0 1 1 0
+                                  0 0 1 1 0 19 0 1 1 0 0 0 1 1 0 0 0 89
+                                  1 0 0 0 77 2 0 104 0 0 1 1 0 0 0 1 1
+                                  0 156 0 1 1 0 0 0 68 2 0 19 0 0 1 1 0
+                                  0 0 87 1 0 0 0 75 1 0 26 0 130 1 0 0
+                                  0 92 1 0 0 0 79 0 0 0 1 1 0 0 0 1 1 0
+                                  125 0 126 1 0 128 0 129 1 0 116 0 124
+                                  1 0 26 0 127 2 0 0 0 0 1 1 0 104 0
+                                  105 2 0 116 0 117 119 3 0 116 0 117
+                                  117 118 2 0 0 0 0 1 1 0 162 157 1 1 0
+                                  19 0 1 0 0 24 29 1 0 19 0 1 0 0 0 47
+                                  3 0 154 0 155 154 1 1 0 26 0 43 1 0
+                                  19 0 101 2 0 0 0 26 1 1 0 0 0 1 1 0
+                                  19 0 99 2 0 158 157 0 1 0 0 0 39 2 0
+                                  0 0 0 65 0 0 0 38 2 0 0 0 0 64 1 0 26
+                                  0 27 1 0 0 0 34 1 0 0 0 69 1 0 0 0 74
+                                  1 0 0 157 1 2 0 0 0 0 1 1 0 8 0 1 1 0
+                                  0 0 1 1 0 102 0 103 2 0 163 163 163 1
+                                  1 0 0 157 1 2 0 0 0 0 1 1 0 0 0 1 1 0
+                                  0 0 1 3 0 0 26 26 24 112 2 0 0 26 26
+                                  1 1 0 156 0 1 2 0 159 0 0 1 3 0 161 0
+                                  0 0 1 2 0 104 0 0 1 2 0 158 157 0 1 1
+                                  0 26 0 28 0 0 0 46 1 0 0 0 73 1 0 117
+                                  0 1 2 0 140 0 0 1 0 0 24 1 1 0 0 0
+                                  106 2 0 0 0 117 1 1 0 0 0 90 1 0 0 0
+                                  80 1 0 0 0 91 1 0 0 0 78 1 0 0 0 88 1
+                                  0 0 0 76 1 0 51 0 53 1 0 155 0 1 1 0
+                                  113 0 115 1 0 13 0 14 1 0 0 116 1 1 0
+                                  0 26 72 1 0 0 116 1 1 0 0 0 1 1 0 0
+                                  26 72 1 0 48 0 50 0 0 117 1 1 0 0 0 1
+                                  0 0 24 37 2 0 19 0 0 1 0 0 24 25 1 0
+                                  0 0 95 2 0 0 0 0 122 1 0 0 0 83 2 0
+                                  19 0 0 1 1 0 0 0 93 1 0 0 0 81 1 0 0
+                                  0 98 1 0 0 0 86 1 0 0 0 96 1 0 0 0 84
+                                  1 0 0 0 97 1 0 0 0 85 1 0 0 0 94 1 0
+                                  0 0 82 1 0 0 0 121 0 0 0 23 0 0 0 44
+                                  2 0 11 9 0 21 3 0 11 9 0 19 22 1 0 8
+                                  0 18 2 0 8 0 19 20 1 0 0 0 109 1 0 0
+                                  0 1 2 0 0 0 117 1 2 0 0 0 0 111 2 0
+                                  19 0 0 58 2 0 19 0 0 55 2 0 19 0 0 66
+                                  2 0 19 0 0 57 2 0 19 0 0 54 2 0 0 0
+                                  26 67 2 0 0 0 0 45 2 0 0 0 0 61 1 0 0
+                                  0 59 2 0 0 0 0 60 2 0 0 0 0 71 2 0 0
+                                  0 116 153 2 0 0 0 26 70 2 0 0 0 117 1
+                                  2 0 0 0 24 1 2 0 0 116 0 1 2 0 0 0
+                                  116 1 2 0 0 0 0 62 2 0 0 26 0 63 2 0
+                                  0 117 0 1 2 0 0 24 0 35)))))
           '|lookupComplete|)) 
 
 (MAKEPROP '|DoubleFloat| 'NILADIC T)