diff --git a/books/bookvol10.3.pamphlet b/books/bookvol10.3.pamphlet
index 6ba05b1..1ce747d 100644
--- a/books/bookvol10.3.pamphlet
+++ b/books/bookvol10.3.pamphlet
@@ -115188,39 +115188,36 @@ This is eventually forcibly replaced by a recompiled version.
     (|x| (SPADCALL "true" (QREFELT |$| 38)))
     ((QUOTE T) (SPADCALL "false" (QREFELT |$| 38))))) 
 
-(DEFUN |Boolean| NIL 
-  (PROG NIL 
-    (RETURN 
-      (PROG (#1=#:G82461) 
-        (RETURN 
-          (COND 
-            ((LETT #1# 
-                (HGET |$ConstructorCache| (QUOTE |Boolean|))
-                |Boolean|)
-              (|CDRwithIncrement| (CDAR #1#)))
-             ((QUOTE T) 
-               (|UNWIND-PROTECT| 
-                 (PROG1 
-                   (CDDAR 
-                     (HPUT 
-                       |$ConstructorCache| 
-                       (QUOTE |Boolean|) 
-                       (LIST (CONS NIL (CONS 1 (|Boolean;|))))))
-                   (LETT #1# T |Boolean|))
-                 (COND 
-                   ((NOT #1#) 
-                     (HREM |$ConstructorCache| (QUOTE |Boolean|)))))))))))) 
-
-(DEFUN |Boolean;| NIL 
-  (PROG (|dv$| |$| |pv$|) 
-    (RETURN 
-      (PROGN 
-        (LETT |dv$| (QUOTE (|Boolean|)) . #1=(|Boolean|))
-        (LETT |$| (GETREFV 41) . #1#)
-        (QSETREFV |$| 0 |dv$|)
-        (QSETREFV |$| 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#))
-        (|haddProp| |$ConstructorCache| (QUOTE |Boolean|) NIL (CONS 1 |$|))
-        (|stuffDomainSlots| |$|) |$|)))) 
+(DEFUN |Boolean| ()
+  (PROG ()
+    (RETURN
+      (PROG (G82461)
+        (RETURN
+          (COND
+            ((LETT G82461 (HGET |$ConstructorCache| '|Boolean|)
+                   |Boolean|)
+             (|CDRwithIncrement| (CDAR G82461)))
+            ('T
+             (UNWIND-PROTECT
+               (PROG1 (CDDAR (HPUT |$ConstructorCache| '|Boolean|
+                                   (LIST
+                                    (CONS NIL (CONS 1 (|Boolean;|))))))
+                 (LETT G82461 T |Boolean|))
+               (COND
+                 ((NOT G82461) (HREM |$ConstructorCache| '|Boolean|)))))))))))
+
+(DEFUN |Boolean;| ()
+  (PROG (|dv$| $ |pv$|)
+    (RETURN
+      (PROGN
+        (LETT |dv$| '(|Boolean|) |Boolean|)
+        (LETT $ (GETREFV 41) |Boolean|)
+        (QSETREFV $ 0 |dv$|)
+        (QSETREFV $ 3
+            (LETT |pv$| (|buildPredVector| 0 0 NIL) |Boolean|))
+        (|haddProp| |$ConstructorCache| '|Boolean| NIL (CONS 1 $))
+        (|stuffDomainSlots| $)
+        $))))
 
 (MAKEPROP 
   (QUOTE |Boolean|) 
@@ -115331,12 +115328,12 @@ Note that this code is not included in the generated catdef.spad file.
 
 (DEFUN |CHAR;index;Pi$;4| (|n| |$|) (SPADCALL (|-| |n| 1) (QREFELT |$| 18))) 
 
-(DEFUN |CHAR;lookup;$Pi;5| (|c| |$|)
- (PROG (#1=#:G90919)
-  (RETURN
-   (PROG1
-    (LETT #1# (|+| 1 (SPADCALL |c| (QREFELT |$| 21))) |CHAR;lookup;$Pi;5|)
-    (|check-subtype| (|>| #1# 0) (QUOTE (|PositiveInteger|)) #1#))))) 
+(DEFUN |CHAR;lookup;$Pi;5| (|c| $)
+  (PROG (G90919)
+    (RETURN
+      (PROG1 (LETT G90919 (+ 1 (SPADCALL |c| (QREFELT $ 21)))
+                   |CHAR;lookup;$Pi;5|)
+        (|check-subtype| (> G90919 0) '(|PositiveInteger|) G90919)))))
 
 (DEFUN |CHAR;char;I$;6| (|n| |$|) (SPADCALL |n| (QREFELT |$| 23))) 
 
@@ -115400,51 +115397,51 @@ Note that this code is not included in the generated catdef.spad file.
 (DEFUN |CHAR;lowerCase;2$;22| (|c| |$|)
  (QENUM (PNAME (DOWNCASE (NUM2CHAR (SPADCALL |c| (QREFELT |$| 21))))) 0)) 
 
-(DEFUN |Character| NIL
- (PROG NIL
-  (RETURN
-   (PROG (#1=#:G90941)
+(DEFUN |Character| ()
+  (PROG ()
     (RETURN
-     (COND
-      ((LETT #1# (HGET |$ConstructorCache| (QUOTE |Character|)) |Character|)
-        (|CDRwithIncrement| (CDAR #1#)))
-      ((QUOTE T)
-        (|UNWIND-PROTECT|
-         (PROG1
-          (CDDAR 
-           (HPUT |$ConstructorCache| (QUOTE |Character|)
-            (LIST (CONS NIL (CONS 1 (|Character;|))))))
-          (LETT #1# T |Character|))
-         (COND
-          ((NOT #1#) (HREM |$ConstructorCache| (QUOTE |Character|)))))))))))) 
-
-(DEFUN |Character;| NIL
- (PROG (|dv$| |$| |pv$| #1=#:G90939 |i|)
-  (RETURN
-   (SEQ
-    (PROGN
-     (LETT |dv$| (QUOTE (|Character|)) . #2=(|Character|))
-     (LETT |$| (GETREFV 53) . #2#)
-     (QSETREFV |$| 0 |dv$|)
-     (QSETREFV |$| 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #2#))
-     (|haddProp| |$ConstructorCache| (QUOTE |Character|) NIL (CONS 1 |$|))
-     (|stuffDomainSlots| |$|)
-     (QSETREFV |$| 6 (|SingleInteger|))
-     (QSETREFV |$| 10 
-      (SPADCALL
-       (PROGN
-        (LETT #1# NIL . #2#)
-        (SEQ
-         (LETT |i| 0 . #2#)
-         G190
-         (COND ((QSGREATERP |i| 255) (GO G191)))
-         (SEQ (EXIT (LETT #1# (CONS (NUM2CHAR |i|) #1#) . #2#)))
-         (LETT |i| (QSADD1 |i|) . #2#)
-         (GO G190)
-         G191
-         (EXIT (NREVERSE0 #1#))))
-       (QREFELT |$| 9)))
-     (QSETREFV |$| 11 0) |$|))))) 
+      (PROG (G90941)
+        (RETURN
+          (COND
+            ((LETT G90941 (HGET |$ConstructorCache| '|Character|)
+                   |Character|)
+             (|CDRwithIncrement| (CDAR G90941)))
+            ('T
+             (UNWIND-PROTECT
+               (PROG1 (CDDAR (HPUT |$ConstructorCache| '|Character|
+                                   (LIST
+                                    (CONS NIL (CONS 1 (|Character;|))))))
+                 (LETT G90941 T |Character|))
+               (COND
+                ((NOT G90941) (HREM |$ConstructorCache| '|Character|)))))))))))
+
+(DEFUN |Character;| ()
+  (PROG (|dv$| $ |pv$| G90939 |i|)
+    (RETURN
+      (SEQ (PROGN
+             (LETT |dv$| '(|Character|) |Character|)
+             (LETT $ (GETREFV 53) |Character|)
+             (QSETREFV $ 0 |dv$|)
+             (QSETREFV $ 3
+                 (LETT |pv$| (|buildPredVector| 0 0 NIL) |Character|))
+             (|haddProp| |$ConstructorCache| '|Character| NIL
+                 (CONS 1 $))
+             (|stuffDomainSlots| $)
+             (QSETREFV $ 6 (|SingleInteger|))
+             (QSETREFV $ 10
+                 (SPADCALL
+                     (PROGN
+                       (LETT G90939 NIL |Character|)
+                       (SEQ (LETT |i| 0 |Character|) G190
+                            (COND ((QSGREATERP |i| 255) (GO G191)))
+                            (SEQ (EXIT (LETT G90939
+                                        (CONS (NUM2CHAR |i|) G90939)
+                                        |Character|)))
+                            (LETT |i| (QSADD1 |i|) |Character|)
+                            (GO G190) G191 (EXIT (NREVERSE0 G90939))))
+                     (QREFELT $ 9)))
+             (QSETREFV $ 11 0)
+             $)))))
 
 (MAKEPROP (QUOTE |Character|) (QUOTE |infovec|)
  (LIST (QUOTE 
@@ -115568,24 +115565,22 @@ Note that this code is not included in the generated catdef.spad file.
 
 (DEFUN |DFLOAT;precision;Pi;9| (|$|) (|FLOAT-DIGITS| 0.0)) 
 
-(DEFUN |DFLOAT;bits;Pi;10| (|$|)
- (PROG (#1=#:G105705)
-  (RETURN
-   (COND
-    ((EQL (|FLOAT-RADIX| 0.0) 2) (|FLOAT-DIGITS| 0.0))
-    ((EQL (|FLOAT-RADIX| 0.0) 16) (|*| 4 (|FLOAT-DIGITS| 0.0)))
-    ((QUOTE T)
-     (PROG1
-      (LETT #1#
-       (FIX
-        (SPADCALL
-         (|FLOAT-DIGITS| 0.0)
-         (SPADCALL
-          (FLOAT (|FLOAT-RADIX| 0.0) |MOST-POSITIVE-LONG-FLOAT|)
-          (QREFELT |$| 28))
-         (QREFELT |$| 29)))
-       |DFLOAT;bits;Pi;10|)
-      (|check-subtype| (|>| #1# 0) (QUOTE (|PositiveInteger|)) #1#))))))) 
+(DEFUN |DFLOAT;bits;Pi;10| ($)
+  (PROG (G105705)
+    (RETURN
+      (COND
+        ((EQL (FLOAT-RADIX 0.0) 2) (FLOAT-DIGITS 0.0))
+        ((EQL (FLOAT-RADIX 0.0) 16) (* 4 (FLOAT-DIGITS 0.0)))
+        ('T
+         (PROG1 (LETT G105705
+                      (FIX (SPADCALL (FLOAT-DIGITS 0.0)
+                               (SPADCALL
+                                   (FLOAT (FLOAT-RADIX 0.0)
+                                    MOST-POSITIVE-LONG-FLOAT)
+                                   (QREFELT $ 28))
+                               (QREFELT $ 29)))
+                      |DFLOAT;bits;Pi;10|)
+           (|check-subtype| (> G105705 0) '(|PositiveInteger|) G105705)))))))
 
 (PUT
  (QUOTE |DFLOAT;max;$;11|)
@@ -115848,26 +115843,26 @@ Note that this code is not included in the generated catdef.spad file.
        (COND ((|<| |y| 0.0) (LETT |theta| (|-| |theta|) |DFLOAT;atan;3$;75|)))
        (EXIT |theta|)))))))) 
 
-(DEFUN |DFLOAT;retract;$F;76| (|x| |$|)
- (PROG (#1=#:G105780)
-  (RETURN
-   (SPADCALL |x|
-    (PROG1
-     (LETT #1# (|-| (|FLOAT-DIGITS| 0.0) 1) |DFLOAT;retract;$F;76|)
-     (|check-subtype| (|>=| #1# 0) (QUOTE (|NonNegativeInteger|)) #1#))
-    (|FLOAT-RADIX| 0.0)
-    (QREFELT |$| 105))))) 
-
-(DEFUN |DFLOAT;retractIfCan;$U;77| (|x| |$|)
- (PROG (#1=#:G105785)
-  (RETURN
-   (CONS 0
-    (SPADCALL |x|
-     (PROG1
-      (LETT #1# (|-| (|FLOAT-DIGITS| 0.0) 1) |DFLOAT;retractIfCan;$U;77|)
-      (|check-subtype| (|>=| #1# 0) (QUOTE (|NonNegativeInteger|)) #1#))
-     (|FLOAT-RADIX| 0.0)
-     (QREFELT |$| 105)))))) 
+(DEFUN |DFLOAT;retract;$F;76| (|x| $)
+  (PROG (G105780)
+    (RETURN
+      (SPADCALL |x|
+          (PROG1 (LETT G105780 (- (FLOAT-DIGITS 0.0) 1)
+                       |DFLOAT;retract;$F;76|)
+            (|check-subtype| (>= G105780 0) '(|NonNegativeInteger|)
+                G105780))
+          (FLOAT-RADIX 0.0) (QREFELT $ 105)))))
+
+(DEFUN |DFLOAT;retractIfCan;$U;77| (|x| $)
+  (PROG (G105785)
+    (RETURN
+      (CONS 0
+            (SPADCALL |x|
+                (PROG1 (LETT G105785 (- (FLOAT-DIGITS 0.0) 1)
+                             |DFLOAT;retractIfCan;$U;77|)
+                  (|check-subtype| (>= G105785 0)
+                      '(|NonNegativeInteger|) G105785))
+                (FLOAT-RADIX 0.0) (QREFELT $ 105))))))
 
 (DEFUN |DFLOAT;retract;$I;78| (|x| |$|)
  (PROG (|n|)
@@ -115899,231 +115894,244 @@ Note that this code is not included in the generated catdef.spad file.
 
 (DEFUN |DFLOAT;abs;2$;81| (|x| |$|) (|FLOAT-SIGN| 1.0 |x|)) 
 
-(DEFUN |DFLOAT;manexp| (|x| |$|)
- (PROG (|s| #1=#:G105806 |me| |two53|)
-  (RETURN
-   (SEQ
-    (EXIT
-     (COND
-      ((ZEROP |x|) (CONS 0 0))
-      ((QUOTE T)
-       (SEQ
-        (LETT |s| (SPADCALL |x| (QREFELT |$| 114)) |DFLOAT;manexp|)
-        (LETT |x| (|FLOAT-SIGN| 1.0 |x|) |DFLOAT;manexp|)
+(DEFUN |DFLOAT;manexp| (|x| $)
+  (PROG (|s| G105806 |me| |two53|)
+    (RETURN
+      (SEQ (EXIT (COND
+                   ((ZEROP |x|) (CONS 0 0))
+                   ('T
+                    (SEQ (LETT |s| (SPADCALL |x| (QREFELT $ 114))
+                               |DFLOAT;manexp|)
+                         (LETT |x| (FLOAT-SIGN 1.0 |x|)
+                               |DFLOAT;manexp|)
+                         (COND
+                           ((< MOST-POSITIVE-LONG-FLOAT |x|)
+                            (PROGN
+                              (LETT G105806
+                                    (CONS
+                                     (+
+                                      (* |s|
+                                       (SPADCALL
+                                        MOST-POSITIVE-LONG-FLOAT
+                                        (QREFELT $ 25)))
+                                      1)
+                                     (SPADCALL MOST-POSITIVE-LONG-FLOAT
+                                      (QREFELT $ 26)))
+                                    |DFLOAT;manexp|)
+                              (GO G105806))))
+                         (LETT |me| (MANEXP |x|) |DFLOAT;manexp|)
+                         (LETT |two53|
+                               (EXPT (FLOAT-RADIX 0.0)
+                                     (FLOAT-DIGITS 0.0))
+                               |DFLOAT;manexp|)
+                         (EXIT (CONS (* |s|
+                                      (FIX (* |two53| (QCAR |me|))))
+                                     (- (QCDR |me|) (FLOAT-DIGITS 0.0))))))))
+           G105806 (EXIT G105806)))))
+
+(DEFUN |DFLOAT;rationalApproximation;$2NniF;83| (|f| |d| |b| $)
+  (PROG (|#G102| |nu| |ex| BASE G105809 |de| |tol| |#G103| |q| |r| |p2|
+                 |q2| G105827 |#G104| |#G105| |p0| |p1| |#G106| |#G107|
+                 |q0| |q1| |#G108| |#G109| |s| |t| G105825)
+    (RETURN
+      (SEQ (EXIT (SEQ 
+       (PROGN
+        (LETT |#G102| (|DFLOAT;manexp| |f| $)
+                              |DFLOAT;rationalApproximation;$2NniF;83|)
+        (LETT |nu| (QCAR |#G102|)
+                              |DFLOAT;rationalApproximation;$2NniF;83|)
+        (LETT |ex| (QCDR |#G102|)
+                              |DFLOAT;rationalApproximation;$2NniF;83|)
+        |#G102|)
+       (LETT BASE (FLOAT-RADIX 0.0)
+                            |DFLOAT;rationalApproximation;$2NniF;83|)
+       (EXIT
         (COND
-         ((|<| |MOST-POSITIVE-LONG-FLOAT| |x|)
-          (PROGN
-           (LETT #1#
-            (CONS
-             (|+|
-              (|*|
-               |s|
-               (SPADCALL |MOST-POSITIVE-LONG-FLOAT| (QREFELT |$| 25))) 1)
-             (SPADCALL |MOST-POSITIVE-LONG-FLOAT| (QREFELT |$| 26)))
-            |DFLOAT;manexp|)
-           (GO #1#))))
-        (LETT |me| (MANEXP |x|) |DFLOAT;manexp|)
-        (LETT |two53|
-         (EXPT (|FLOAT-RADIX| 0.0) (|FLOAT-DIGITS| 0.0)) |DFLOAT;manexp|)
-        (EXIT
-         (CONS
-          (|*| |s| (FIX (|*| |two53| (QCAR |me|))))
-          (|-| (QCDR |me|) (|FLOAT-DIGITS| 0.0))))))))
-    #1#
-    (EXIT #1#))))) 
-
-(DEFUN |DFLOAT;rationalApproximation;$2NniF;83| (|f| |d| |b| |$|)
- (PROG (|#G102| |nu| |ex| BASE #1=#:G105809 |de| |tol| |#G103| |q| |r|
-        |p2| |q2| #2=#:G105827 |#G104| |#G105| |p0| |p1| |#G106| |#G107|
-        |q0| |q1| |#G108| |#G109| |s| |t| #3=#:G105825)
-  (RETURN
-   (SEQ
-    (EXIT
-     (SEQ
-      (PROGN 
-       (LETT |#G102|
-        (|DFLOAT;manexp| |f| |$|)
-        |DFLOAT;rationalApproximation;$2NniF;83|)
-       (LETT |nu| (QCAR |#G102|) |DFLOAT;rationalApproximation;$2NniF;83|)
-       (LETT |ex| (QCDR |#G102|) |DFLOAT;rationalApproximation;$2NniF;83|)
-       |#G102|)
-      (LETT BASE (|FLOAT-RADIX| 0.0) |DFLOAT;rationalApproximation;$2NniF;83|)
-      (EXIT
-       (COND
-        ((|<| |ex| 0)
-         (SEQ
-          (LETT |de|
-           (EXPT BASE
-            (PROG1
-             (LETT #1# (|-| |ex|) |DFLOAT;rationalApproximation;$2NniF;83|)
-             (|check-subtype|
-              (|>=| #1# 0)
-              (QUOTE (|NonNegativeInteger|))
-              #1#)))
-           |DFLOAT;rationalApproximation;$2NniF;83|)
-          (EXIT
-           (COND
-            ((|<| |b| 2) (|error| "base must be > 1"))
-            ((QUOTE T)
-             (SEQ
-              (LETT |tol|
-               (EXPT |b| |d|)
-               |DFLOAT;rationalApproximation;$2NniF;83|)
-              (LETT |s| |nu| |DFLOAT;rationalApproximation;$2NniF;83|)
-              (LETT |t| |de| |DFLOAT;rationalApproximation;$2NniF;83|)
-              (LETT |p0| 0 |DFLOAT;rationalApproximation;$2NniF;83|)
-              (LETT |p1| 1 |DFLOAT;rationalApproximation;$2NniF;83|)
-              (LETT |q0| 1 |DFLOAT;rationalApproximation;$2NniF;83|)
-              (LETT |q1| 0 |DFLOAT;rationalApproximation;$2NniF;83|)
-              (EXIT
-               (SEQ
-                G190
-                NIL
-                (SEQ
-                 (PROGN
-                  (LETT |#G103|
-                   (DIVIDE2 |s| |t|)
-                   |DFLOAT;rationalApproximation;$2NniF;83|)
-                  (LETT |q|
-                   (QCAR |#G103|)
-                   |DFLOAT;rationalApproximation;$2NniF;83|)
-                  (LETT |r|
-                   (QCDR |#G103|)
-                   |DFLOAT;rationalApproximation;$2NniF;83|)
-                  |#G103|)
-                 (LETT |p2|
-                  (|+| (|*| |q| |p1|) |p0|)
+         ((< |ex| 0)
+          (SEQ 
+           (LETT |de|
+            (EXPT BASE
+             (PROG1
+              (LETT G105809 (- |ex|) |DFLOAT;rationalApproximation;$2NniF;83|)
+              (|check-subtype| (>= G105809 0) '(|NonNegativeInteger|)
+                G105809)))
+            |DFLOAT;rationalApproximation;$2NniF;83|)
+           (EXIT
+            (COND
+             ((< |b| 2) (|error| "base must be > 1"))
+             (t
+              (SEQ
+               (LETT |tol| (EXPT |b| |d|)
                   |DFLOAT;rationalApproximation;$2NniF;83|)
-                 (LETT |q2|
-                  (|+| (|*| |q| |q1|) |q0|)
+               (LETT |s| |nu|
                   |DFLOAT;rationalApproximation;$2NniF;83|)
-                 (COND
-                  ((OR
-                    (EQL |r| 0)
-                    (|<|
-                     (SPADCALL |tol|
-                      (ABS (|-| (|*| |nu| |q2|) (|*| |de| |p2|)))
-                      (QREFELT |$| 118))
-                     (|*| |de| (ABS |p2|))))
-                   (EXIT
-                    (PROGN
-                     (LETT #2#
-                      (SPADCALL |p2| |q2| (QREFELT |$| 117))
-                      |DFLOAT;rationalApproximation;$2NniF;83|)
-                     (GO #2#)))))
-                 (PROGN
-                  (LETT |#G104| |p1| |DFLOAT;rationalApproximation;$2NniF;83|)
-                  (LETT |#G105| |p2| |DFLOAT;rationalApproximation;$2NniF;83|)
-                  (LETT |p0| |#G104| |DFLOAT;rationalApproximation;$2NniF;83|)
-                  (LETT |p1| |#G105| |DFLOAT;rationalApproximation;$2NniF;83|))
-                 (PROGN
-                  (LETT |#G106| |q1| |DFLOAT;rationalApproximation;$2NniF;83|)
-                  (LETT |#G107| |q2| |DFLOAT;rationalApproximation;$2NniF;83|)
-                  (LETT |q0| |#G106| |DFLOAT;rationalApproximation;$2NniF;83|)
-                  (LETT |q1| |#G107| |DFLOAT;rationalApproximation;$2NniF;83|))
-                 (EXIT
+               (LETT |t| |de|
+                  |DFLOAT;rationalApproximation;$2NniF;83|)
+               (LETT |p0| 0
+                  |DFLOAT;rationalApproximation;$2NniF;83|)
+               (LETT |p1| 1
+                  |DFLOAT;rationalApproximation;$2NniF;83|)
+               (LETT |q0| 1
+                  |DFLOAT;rationalApproximation;$2NniF;83|)
+               (LETT |q1| 0
+                  |DFLOAT;rationalApproximation;$2NniF;83|)
+               (EXIT
+                (SEQ G190 NIL
+                 (SEQ
                   (PROGN
-                   (LETT |#G108| |t| |DFLOAT;rationalApproximation;$2NniF;83|)
-                   (LETT |#G109| |r| |DFLOAT;rationalApproximation;$2NniF;83|)
-                   (LETT |s| |#G108| |DFLOAT;rationalApproximation;$2NniF;83|)
-                   (LETT |t|
-                    |#G109|
-                    |DFLOAT;rationalApproximation;$2NniF;83|))))
-                NIL (GO G190) G191 (EXIT NIL)))))))))
-        ((QUOTE T)
-         (SPADCALL
-          (|*| |nu|
-           (EXPT BASE
-            (PROG1
-             (LETT #3# |ex| |DFLOAT;rationalApproximation;$2NniF;83|)
-             (|check-subtype|
-              (|>=| #3# 0)
-              (QUOTE (|NonNegativeInteger|))
-              #3#))))
-          (QREFELT |$| 119)))))))
-    #2#
-    (EXIT #2#))))) 
-
-(DEFUN |DFLOAT;**;$F$;84| (|x| |r| |$|)
- (PROG (|n| |d| #1=#:G105837)
-  (RETURN
-   (SEQ
-    (EXIT
-     (COND
-      ((ZEROP |x|)
-       (COND
-        ((SPADCALL |r| (QREFELT |$| 120)) (|error| "0**0 is undefined"))
-        ((SPADCALL |r| (QREFELT |$| 121)) (|error| "division by 0"))
-        ((QUOTE T) 0.0)))
-      ((OR (SPADCALL |r| (QREFELT |$| 120)) (SPADCALL |x| (QREFELT |$| 122)))
-        1.0)
-      ((QUOTE T)
-       (COND
-        ((SPADCALL |r| (QREFELT |$| 123)) |x|)
-        ((QUOTE T)
-         (SEQ
-          (LETT |n| (SPADCALL |r| (QREFELT |$| 124)) |DFLOAT;**;$F$;84|)
-          (LETT |d| (SPADCALL |r| (QREFELT |$| 125)) |DFLOAT;**;$F$;84|)
-          (EXIT
-           (COND
-            ((MINUSP |x|)
-             (COND
-              ((ODDP |d|)
-               (COND
-                ((ODDP |n|)
-                 (PROGN
-                  (LETT #1#
-                   (|-| (SPADCALL (|-| |x|) |r| (QREFELT |$| 126)))
-                   |DFLOAT;**;$F$;84|)
-                  (GO #1#)))
-                ((QUOTE T)
-                 (PROGN
-                  (LETT #1#
-                   (SPADCALL (|-| |x|) |r| (QREFELT |$| 126))
-                   |DFLOAT;**;$F$;84|)
-                  (GO #1#)))))
-              ((QUOTE T) (|error| "negative root"))))
-            ((EQL |d| 2) (EXPT (SPADCALL |x| (QREFELT |$| 54)) |n|))
-            ((QUOTE T)
-             (SPADCALL |x|
-              (|/|
-               (FLOAT |n| |MOST-POSITIVE-LONG-FLOAT|)
-               (FLOAT |d| |MOST-POSITIVE-LONG-FLOAT|))
-              (QREFELT |$| 57)))))))))))
-    #1#
-    (EXIT #1#))))) 
-
-(DEFUN |DoubleFloat| NIL
- (PROG NIL
-  (RETURN 
-   (PROG (#1=#:G105850)
+                   (LETT |#G103| (DIVIDE2 |s| |t|)
+                    |DFLOAT;rationalApproximation;$2NniF;83|)
+                   (LETT |q| (QCAR |#G103|)
+                    |DFLOAT;rationalApproximation;$2NniF;83|)
+                   (LETT |r| (QCDR |#G103|)
+                    |DFLOAT;rationalApproximation;$2NniF;83|)
+                   |#G103|)
+                  (LETT |p2| (+ (* |q| |p1|) |p0|)
+                   |DFLOAT;rationalApproximation;$2NniF;83|)
+                  (LETT |q2| (+ (* |q| |q1|) |q0|)
+                   |DFLOAT;rationalApproximation;$2NniF;83|)
+                  (COND
+                   ((OR (EQL |r| 0)
+                     (< (SPADCALL |tol| (ABS (- (* |nu| |q2|) (* |de| |p2|)))
+                                        (QREFELT $ 118))
+                                        (* |de| (ABS |p2|))))
+                    (EXIT
+                     (PROGN
+                      (LETT G105827
+                       (SPADCALL |p2| |q2| (QREFELT $ 117))
+                       |DFLOAT;rationalApproximation;$2NniF;83|)
+                      (GO G105827)))))
+                     (PROGN
+                      (LETT |#G104| |p1|
+                       |DFLOAT;rationalApproximation;$2NniF;83|)
+                      (LETT |#G105| |p2|
+                       |DFLOAT;rationalApproximation;$2NniF;83|)
+                      (LETT |p0| |#G104|
+                       |DFLOAT;rationalApproximation;$2NniF;83|)
+                      (LETT |p1| |#G105|
+                       |DFLOAT;rationalApproximation;$2NniF;83|))
+                      (PROGN
+                       (LETT |#G106| |q1|
+                        |DFLOAT;rationalApproximation;$2NniF;83|)
+                       (LETT |#G107| |q2|
+                        |DFLOAT;rationalApproximation;$2NniF;83|)
+                       (LETT |q0| |#G106|
+                        |DFLOAT;rationalApproximation;$2NniF;83|)
+                       (LETT |q1| |#G107|
+                        |DFLOAT;rationalApproximation;$2NniF;83|))
+                       (EXIT
+                        (PROGN
+                         (LETT |#G108| |t|
+                          |DFLOAT;rationalApproximation;$2NniF;83|)
+                         (LETT |#G109| |r|
+                          |DFLOAT;rationalApproximation;$2NniF;83|)
+                         (LETT |s| |#G108|
+                          |DFLOAT;rationalApproximation;$2NniF;83|)
+                         (LETT |t| |#G109|
+                          |DFLOAT;rationalApproximation;$2NniF;83|))))
+                         NIL (GO G190) G191
+                         (EXIT NIL)))))))))
+         ('T
+          (SPADCALL
+           (* |nu|
+            (EXPT BASE
+             (PROG1
+              (LETT G105825 |ex| |DFLOAT;rationalApproximation;$2NniF;83|)
+              (|check-subtype| (>= G105825 0) '(|NonNegativeInteger|)
+                 G105825))))
+           (QREFELT $ 119)))))))
+    G105827 
+      (EXIT G105827)))))
+
+(DEFUN |DFLOAT;**;$F$;84| (|x| |r| $)
+  (PROG (|n| |d| G105837)
     (RETURN
-     (COND
-      ((LETT #1#
-        (HGET |$ConstructorCache| (QUOTE |DoubleFloat|))
-        |DoubleFloat|)
-       (|CDRwithIncrement| (CDAR #1#)))
-      ((QUOTE T)
-       (|UNWIND-PROTECT|
-        (PROG1
-         (CDDAR
-          (HPUT |$ConstructorCache|
-           (QUOTE |DoubleFloat|)
-           (LIST (CONS NIL (CONS 1 (|DoubleFloat;|))))))
-         (LETT #1# T |DoubleFloat|))
-        (COND
-         ((NOT #1#) (HREM |$ConstructorCache| (QUOTE |DoubleFloat|)))))))))))) 
+      (SEQ (EXIT (COND
+                   ((ZEROP |x|)
+                    (COND
+                      ((SPADCALL |r| (QREFELT $ 120))
+                       (|error| "0**0 is undefined"))
+                      ((SPADCALL |r| (QREFELT $ 121))
+                       (|error| "division by 0"))
+                      ('T 0.0)))
+                   ((OR (SPADCALL |r| (QREFELT $ 120))
+                        (SPADCALL |x| (QREFELT $ 122)))
+                    1.0)
+                   ('T
+                    (COND
+                      ((SPADCALL |r| (QREFELT $ 123)) |x|)
+                      ('T
+                       (SEQ (LETT |n| (SPADCALL |r| (QREFELT $ 124))
+                                  |DFLOAT;**;$F$;84|)
+                            (LETT |d| (SPADCALL |r| (QREFELT $ 125))
+                                  |DFLOAT;**;$F$;84|)
+                            (EXIT (COND
+                                    ((MINUSP |x|)
+                                     (COND
+                                       ((ODDP |d|)
+                                        (COND
+                                          ((ODDP |n|)
+                                           (PROGN
+                                             (LETT G105837
+                                              (-
+                                               (SPADCALL (- |x|) |r|
+                                                (QREFELT $ 126)))
+                                              |DFLOAT;**;$F$;84|)
+                                             (GO G105837)))
+                                          ('T
+                                           (PROGN
+                                             (LETT G105837
+                                              (SPADCALL (- |x|) |r|
+                                               (QREFELT $ 126))
+                                              |DFLOAT;**;$F$;84|)
+                                             (GO G105837)))))
+                                       ('T (|error| "negative root"))))
+                                    ((EQL |d| 2)
+                                     (EXPT
+                                      (SPADCALL |x| (QREFELT $ 54))
+                                      |n|))
+                                    ('T
+                                     (SPADCALL |x|
+                                      (/
+                                       (FLOAT |n|
+                                        MOST-POSITIVE-LONG-FLOAT)
+                                       (FLOAT |d|
+                                        MOST-POSITIVE-LONG-FLOAT))
+                                      (QREFELT $ 57)))))))))))
+           G105837 (EXIT G105837)))))
+
+(DEFUN |DoubleFloat| ()
+  (PROG ()
+    (RETURN
+      (PROG (G105850)
+        (RETURN
+          (COND
+            ((LETT G105850 (HGET |$ConstructorCache| '|DoubleFloat|)
+                   |DoubleFloat|)
+             (|CDRwithIncrement| (CDAR G105850)))
+            ('T
+             (UNWIND-PROTECT
+               (PROG1 (CDDAR (HPUT |$ConstructorCache| '|DoubleFloat|
+                                   (LIST
+                                    (CONS NIL
+                                     (CONS 1 (|DoubleFloat;|))))))
+                 (LETT G105850 T |DoubleFloat|))
+               (COND
+                 ((NOT G105850)
+                  (HREM |$ConstructorCache| '|DoubleFloat|)))))))))))
 
-(DEFUN |DoubleFloat;| NIL
- (PROG (|dv$| |$| |pv$|)
-  (RETURN
-   (PROGN 
-    (LETT |dv$| (QUOTE (|DoubleFloat|)) . #1=(|DoubleFloat|))
-    (LETT |$| (GETREFV 140) . #1#)
-    (QSETREFV |$| 0 |dv$|)
-    (QSETREFV |$| 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#))
-    (|haddProp| |$ConstructorCache| (QUOTE |DoubleFloat|) NIL (CONS 1 |$|))
-    (|stuffDomainSlots| |$|) |$|)))) 
+(DEFUN |DoubleFloat;| ()
+  (PROG (|dv$| $ |pv$|)
+    (RETURN
+      (PROGN
+        (LETT |dv$| '(|DoubleFloat|) |DoubleFloat|)
+        (LETT $ (GETREFV 140) |DoubleFloat|)
+        (QSETREFV $ 0 |dv$|)
+        (QSETREFV $ 3
+            (LETT |pv$| (|buildPredVector| 0 0 NIL) |DoubleFloat|))
+        (|haddProp| |$ConstructorCache| '|DoubleFloat| NIL (CONS 1 $))
+        (|stuffDomainSlots| $)
+        $))))
 
 (MAKEPROP
  (QUOTE |DoubleFloat|)
@@ -116470,39 +116478,40 @@ Note that this code is not included in the generated catdef.spad file.
            (QREFELT |$| 44))
           (QREFELT |$| 39))))))))))) 
 
-(DEFUN |ILIST;=;2$B;22| (|x| |y| |$|)
- (PROG (#1=#:G102042)
-  (RETURN
-   (SEQ
-    (EXIT
-     (COND
-      ((EQ |x| |y|) (QUOTE T))
-      ((QUOTE T)
-       (SEQ
-        (SEQ
-         G190
-         (COND
-          ((NULL
-            (COND
-             ((OR (NULL |x|) (NULL |y|)) (QUOTE NIL))
-             ((QUOTE T) (QUOTE T))))
-           (GO G191)))
-         (SEQ
-          (EXIT
-           (COND
-            ((NULL (SPADCALL (QCAR |x|) (QCAR |y|) (QREFELT |$| 46)))
-             (PROGN (LETT #1# (QUOTE NIL) |ILIST;=;2$B;22|) (GO #1#)))
-            ((QUOTE T)
-             (SEQ
-              (LETT |x| (QCDR |x|) |ILIST;=;2$B;22|)
-              (EXIT (LETT |y| (QCDR |y|) |ILIST;=;2$B;22|)))))))
-         NIL
-         (GO G190)
-         G191
-         (EXIT NIL))
-        (EXIT (COND ((NULL |x|) (NULL |y|)) ((QUOTE T) (QUOTE NIL))))))))
-    #1#
-    (EXIT #1#))))) 
+(DEFUN |ILIST;=;2$B;22| (|x| |y| $)
+  (PROG (G102042)
+    (RETURN
+      (SEQ (EXIT (COND
+                   ((EQ |x| |y|) 'T)
+                   ('T
+                    (SEQ (SEQ G190
+                              (COND
+                                ((NULL (COND
+                                         ((OR (NULL |x|) (NULL |y|))
+                                          'NIL)
+                                         ('T 'T)))
+                                 (GO G191)))
+                              (SEQ (EXIT
+                                    (COND
+                                      ((NULL
+                                        (SPADCALL (QCAR |x|) (QCAR |y|)
+                                         (QREFELT $ 46)))
+                                       (PROGN
+                                         (LETT G102042 'NIL
+                                          |ILIST;=;2$B;22|)
+                                         (GO G102042)))
+                                      ('T
+                                       (SEQ
+                                        (LETT |x| (QCDR |x|)
+                                         |ILIST;=;2$B;22|)
+                                        (EXIT
+                                         (LETT |y| (QCDR |y|)
+                                          |ILIST;=;2$B;22|)))))))
+                              NIL (GO G190) G191 (EXIT NIL))
+                         (EXIT (COND
+                                 ((NULL |x|) (NULL |y|))
+                                 ('T 'NIL)))))))
+           G102042 (EXIT G102042)))))
 
 (DEFUN |ILIST;latex;$S;23| (|x| |$|)
  (PROG (|s|)
@@ -116529,30 +116538,26 @@ Note that this code is not included in the generated catdef.spad file.
      (EXIT NIL))
     (EXIT (STRCONC |s| " \\right]")))))) 
 
-(DEFUN |ILIST;member?;S$B;24| (|s| |x| |$|)
- (PROG (#1=#:G102052)
-  (RETURN
-   (SEQ
-    (EXIT
-     (SEQ
-      (SEQ
-       G190
-       (COND
-        ((NULL (COND ((NULL |x|) (QUOTE NIL)) ((QUOTE T) (QUOTE T))))
-          (GO G191)))
-       (SEQ 
-        (EXIT 
-         (COND 
-          ((SPADCALL |s| (QCAR |x|) (QREFELT |$| 46))
-            (PROGN (LETT #1# (QUOTE T) |ILIST;member?;S$B;24|) (GO #1#)))
-          ((QUOTE T) (LETT |x| (QCDR |x|) |ILIST;member?;S$B;24|)))))
-       NIL
-       (GO G190)
-       G191
-       (EXIT NIL))
-      (EXIT (QUOTE NIL))))
-    #1#
-    (EXIT #1#))))) 
+(DEFUN |ILIST;member?;S$B;24| (|s| |x| $)
+  (PROG (G102052)
+    (RETURN
+      (SEQ (EXIT (SEQ (SEQ G190
+                           (COND
+                             ((NULL (COND ((NULL |x|) 'NIL) ('T 'T)))
+                              (GO G191)))
+                           (SEQ (EXIT (COND
+                                        ((SPADCALL |s| (QCAR |x|)
+                                          (QREFELT $ 46))
+                                         (PROGN
+                                           (LETT G102052 'T
+                                            |ILIST;member?;S$B;24|)
+                                           (GO G102052)))
+                                        ('T
+                                         (LETT |x| (QCDR |x|)
+                                          |ILIST;member?;S$B;24|)))))
+                           NIL (GO G190) G191 (EXIT NIL))
+                      (EXIT 'NIL)))
+           G102052 (EXIT G102052)))))
 
 (DEFUN |ILIST;concat!;3$;25| (|x| |y| |$|)
  (PROG (|z|)
@@ -116671,121 +116676,133 @@ Note that this code is not included in the generated catdef.spad file.
        (QRPLACD |t| (COND ((NULL |p|) |q|) ((QUOTE T) |p|)))
        (EXIT |r|)))))))) 
 
-(DEFUN |ILIST;split!;$I$;29| (|p| |n| |$|)
- (PROG (#1=#:G102085 |q|)
-  (RETURN
-   (SEQ
-    (COND
-     ((|<| |n| 1) (|error| "index out of range"))
-     ((QUOTE T)
-      (SEQ
-       (LETT |p|
-        (SPADCALL |p|
-         (PROG1
-          (LETT #1# (|-| |n| 1) |ILIST;split!;$I$;29|)
-          (|check-subtype| (|>=| #1# 0) (QUOTE (|NonNegativeInteger|)) #1#))
-         (QREFELT |$| 32))
-        |ILIST;split!;$I$;29|)
-       (LETT |q| (QCDR |p|) |ILIST;split!;$I$;29|)
-       (QRPLACD |p| NIL) (EXIT |q|)))))))) 
-
-(DEFUN |ILIST;mergeSort| (|f| |p| |n| |$|)
- (PROG (#1=#:G102089 |l| |q|)
-  (RETURN
-   (SEQ
-    (COND
-     ((EQL |n| 2)
-      (COND
-       ((SPADCALL
-         (SPADCALL (SPADCALL |p| (QREFELT |$| 18)) (QREFELT |$| 13))
-         (SPADCALL |p| (QREFELT |$| 13)) |f|)
-        (LETT |p| (SPADCALL |p| (QREFELT |$| 28)) |ILIST;mergeSort|)))))
-    (EXIT
-     (COND
-      ((|<| |n| 3) |p|)
-      ((QUOTE T)
-       (SEQ 
-        (LETT |l|
-         (PROG1
-          (LETT #1# (QUOTIENT2 |n| 2) |ILIST;mergeSort|)
-          (|check-subtype| (|>=| #1# 0) (QUOTE (|NonNegativeInteger|)) #1#))
-         |ILIST;mergeSort|)
-        (LETT |q| (SPADCALL |p| |l| (QREFELT |$| 57)) |ILIST;mergeSort|)
-        (LETT |p| (|ILIST;mergeSort| |f| |p| |l| |$|) |ILIST;mergeSort|)
-        (LETT |q|
-         (|ILIST;mergeSort| |f| |q| (|-| |n| |l|) |$|)
-         |ILIST;mergeSort|)
-        (EXIT (SPADCALL |f| |p| |q| (QREFELT |$| 56))))))))))) 
-
-(DEFUN |IndexedList| (|&REST| #1=#:G102103 |&AUX| #2=#:G102101)
- (DSETQ #2# #1#)
- (PROG NIL
-  (RETURN
-   (PROG (#3=#:G102102)
+(DEFUN |ILIST;split!;$I$;29| (|p| |n| $)
+  (PROG (G102085 |q|)
     (RETURN
-     (COND
-      ((LETT #3#
-        (|lassocShiftWithFunction|
-         (|devaluateList| #2#)
-         (HGET |$ConstructorCache| (QUOTE |IndexedList|))
-         (QUOTE |domainEqualList|))
-        |IndexedList|)
-       (|CDRwithIncrement| #3#))
-      ((QUOTE T)
-       (|UNWIND-PROTECT|
-        (PROG1
-         (APPLY (|function| |IndexedList;|) #2#)
-         (LETT #3# T |IndexedList|))
-        (COND
-         ((NOT #3#) (HREM |$ConstructorCache| (QUOTE |IndexedList|)))))))))))) 
+      (SEQ (COND
+             ((< |n| 1) (|error| "index out of range"))
+             ('T
+              (SEQ (LETT |p|
+                         (SPADCALL |p|
+                             (PROG1 (LETT G102085 (- |n| 1)
+                                     |ILIST;split!;$I$;29|)
+                               (|check-subtype| (>= G102085 0)
+                                   '(|NonNegativeInteger|) G102085))
+                             (QREFELT $ 32))
+                         |ILIST;split!;$I$;29|)
+                   (LETT |q| (QCDR |p|) |ILIST;split!;$I$;29|)
+                   (QRPLACD |p| NIL) (EXIT |q|))))))))
+
+(DEFUN |ILIST;mergeSort| (|f| |p| |n| $)
+  (PROG (G102089 |l| |q|)
+    (RETURN
+      (SEQ (COND
+             ((EQL |n| 2)
+              (COND
+                ((SPADCALL
+                     (SPADCALL (SPADCALL |p| (QREFELT $ 18))
+                         (QREFELT $ 13))
+                     (SPADCALL |p| (QREFELT $ 13)) |f|)
+                 (LETT |p| (SPADCALL |p| (QREFELT $ 28))
+                       |ILIST;mergeSort|)))))
+           (EXIT (COND
+                   ((< |n| 3) |p|)
+                   ('T
+                    (SEQ (LETT |l|
+                               (PROG1 (LETT G102089 (QUOTIENT2 |n| 2)
+                                       |ILIST;mergeSort|)
+                                 (|check-subtype| (>= G102089 0)
+                                     '(|NonNegativeInteger|) G102089))
+                               |ILIST;mergeSort|)
+                         (LETT |q| (SPADCALL |p| |l| (QREFELT $ 57))
+                               |ILIST;mergeSort|)
+                         (LETT |p| (|ILIST;mergeSort| |f| |p| |l| $)
+                               |ILIST;mergeSort|)
+                         (LETT |q|
+                               (|ILIST;mergeSort| |f| |q| (- |n| |l|)
+                                   $)
+                               |ILIST;mergeSort|)
+                         (EXIT (SPADCALL |f| |p| |q| (QREFELT $ 56)))))))))))
+
+(DEFUN |IndexedList| (&REST G102103 &AUX G102101)
+  (DSETQ G102101 G102103)
+  (PROG ()
+    (RETURN
+      (PROG (G102102)
+        (RETURN
+          (COND
+            ((LETT G102102
+                   (|lassocShiftWithFunction| (|devaluateList| G102101)
+                       (HGET |$ConstructorCache| '|IndexedList|)
+                       '|domainEqualList|)
+                   |IndexedList|)
+             (|CDRwithIncrement| G102102))
+            ('T
+             (UNWIND-PROTECT
+               (PROG1 (APPLY (|function| |IndexedList;|) G102101)
+                 (LETT G102102 T |IndexedList|))
+               (COND
+                 ((NOT G102102)
+                  (HREM |$ConstructorCache| '|IndexedList|)))))))))))
 
 (DEFUN |IndexedList;| (|#1| |#2|)
- (PROG (|DV$1| |DV$2| |dv$| |$| #1=#:G102100 |pv$|)
-  (RETURN
-   (PROGN
-    (LETT |DV$1| (|devaluate| |#1|) . #2=(|IndexedList|))
-    (LETT |DV$2| (|devaluate| |#2|) . #2#)
-    (LETT |dv$| (LIST (QUOTE |IndexedList|) |DV$1| |DV$2|) . #2#)
-    (LETT |$| (GETREFV 71) . #2#)
-    (QSETREFV |$| 0 |dv$|)
-    (QSETREFV |$| 3 
-     (LETT |pv$| 
-      (|buildPredVector| 0 0
-       (LIST 
-        (|HasCategory| |#1| (QUOTE (|SetCategory|)))
-        (|HasCategory| |#1| (QUOTE (|ConvertibleTo| (|InputForm|))))
-        (LETT #1# (|HasCategory| |#1| (QUOTE (|OrderedSet|))) . #2#)
-        (OR #1# (|HasCategory| |#1| (QUOTE (|SetCategory|))))
-        (|HasCategory| (|Integer|) (QUOTE (|OrderedSet|)))
-        (AND
-         (|HasCategory| |#1| (LIST (QUOTE |Evalable|) (|devaluate| |#1|)))
-         (|HasCategory| |#1| (QUOTE (|SetCategory|))))
-        (OR
-         (AND
-          (|HasCategory| |#1| (LIST (QUOTE |Evalable|) (|devaluate| |#1|)))
-          #1#)
-         (AND
-          (|HasCategory| |#1| (LIST (QUOTE |Evalable|) (|devaluate| |#1|)))
-          (|HasCategory| |#1| (QUOTE (|SetCategory|)))))))
-      . #2#))
-    (|haddProp| |$ConstructorCache|
-     (QUOTE |IndexedList|) (LIST |DV$1| |DV$2|) (CONS 1 |$|))
-    (|stuffDomainSlots| |$|)
-    (QSETREFV |$| 6 |#1|)
-    (QSETREFV |$| 7 |#2|)
-    (COND
-     ((|testBitVector| |pv$| 1)
+  (PROG (DV$1 DV$2 |dv$| $ G102100 |pv$|)
+    (RETURN
       (PROGN
-       (QSETREFV |$| 45 (CONS (|dispatchFunction| |ILIST;coerce;$Of;21|) |$|))
-       (QSETREFV |$| 47 (CONS (|dispatchFunction| |ILIST;=;2$B;22|) |$|))
-       (QSETREFV |$| 50 (CONS (|dispatchFunction| |ILIST;latex;$S;23|) |$|))
-       (QSETREFV |$| 51
-        (CONS (|dispatchFunction| |ILIST;member?;S$B;24|) |$|)))))
-    (COND
-     ((|testBitVector| |pv$| 1)
-      (QSETREFV |$| 53
-       (CONS (|dispatchFunction| |ILIST;removeDuplicates!;2$;26|) |$|))))
-    |$|)))) 
+        (LETT DV$1 (|devaluate| |#1|) |IndexedList|)
+        (LETT DV$2 (|devaluate| |#2|) |IndexedList|)
+        (LETT |dv$| (LIST '|IndexedList| DV$1 DV$2) |IndexedList|)
+        (LETT $ (GETREFV 71) |IndexedList|)
+        (QSETREFV $ 0 |dv$|)
+        (QSETREFV $ 3
+            (LETT |pv$|
+                  (|buildPredVector| 0 0
+                      (LIST (|HasCategory| |#1| '(|SetCategory|))
+                            (|HasCategory| |#1|
+                                '(|ConvertibleTo| (|InputForm|)))
+                            (LETT G102100
+                                  (|HasCategory| |#1| '(|OrderedSet|))
+                                  |IndexedList|)
+                            (OR G102100
+                                (|HasCategory| |#1| '(|SetCategory|)))
+                            (|HasCategory| (|Integer|) '(|OrderedSet|))
+                            (AND (|HasCategory| |#1|
+                                     (LIST '|Evalable|
+                                      (|devaluate| |#1|)))
+                                 (|HasCategory| |#1| '(|SetCategory|)))
+                            (OR (AND (|HasCategory| |#1|
+                                      (LIST '|Evalable|
+                                       (|devaluate| |#1|)))
+                                     G102100)
+                                (AND (|HasCategory| |#1|
+                                      (LIST '|Evalable|
+                                       (|devaluate| |#1|)))
+                                     (|HasCategory| |#1|
+                                      '(|SetCategory|))))))
+                  |IndexedList|))
+        (|haddProp| |$ConstructorCache| '|IndexedList| (LIST DV$1 DV$2)
+            (CONS 1 $))
+        (|stuffDomainSlots| $)
+        (QSETREFV $ 6 |#1|)
+        (QSETREFV $ 7 |#2|)
+        (COND
+          ((|testBitVector| |pv$| 1)
+           (PROGN
+             (QSETREFV $ 45
+                 (CONS (|dispatchFunction| |ILIST;coerce;$Of;21|) $))
+             (QSETREFV $ 47
+                 (CONS (|dispatchFunction| |ILIST;=;2$B;22|) $))
+             (QSETREFV $ 50
+                 (CONS (|dispatchFunction| |ILIST;latex;$S;23|) $))
+             (QSETREFV $ 51
+                 (CONS (|dispatchFunction| |ILIST;member?;S$B;24|) $)))))
+        (COND
+          ((|testBitVector| |pv$| 1)
+           (QSETREFV $ 53
+               (CONS (|dispatchFunction|
+                         |ILIST;removeDuplicates!;2$;26|)
+                     $))))
+        $))))
 
 (MAKEPROP
  (QUOTE |IndexedList|)
@@ -117020,21 +117037,18 @@ Note that this code is not included in the generated catdef.spad file.
 
 (DEFUN |INT;length;2$;18| (|a| |$|) (|INTEGER-LENGTH| |a|)) 
 
-(DEFUN |INT;addmod;4$;19| (|a| |b| |p| |$|)
- (PROG (|c| #1=#:G86338)
-  (RETURN
-   (SEQ
-    (EXIT
-     (SEQ
-      (SEQ
-       (LETT |c| (|+| |a| |b|) |INT;addmod;4$;19|)
-       (EXIT
-        (COND
-         ((NULL (|<| |c| |p|))
-           (PROGN (LETT #1# (|-| |c| |p|) |INT;addmod;4$;19|) (GO #1#))))))
-      (EXIT |c|)))
-    #1#
-    (EXIT #1#))))) 
+(DEFUN |INT;addmod;4$;19| (|a| |b| |p| $)
+  (PROG (|c| G86338)
+    (RETURN
+      (SEQ (EXIT (SEQ (SEQ (LETT |c| (+ |a| |b|) |INT;addmod;4$;19|)
+                           (EXIT (COND
+                                   ((NULL (< |c| |p|))
+                                    (PROGN
+                                      (LETT G86338 (- |c| |p|)
+                                       |INT;addmod;4$;19|)
+                                      (GO G86338))))))
+                      (EXIT |c|)))
+           G86338 (EXIT G86338)))))
 
 (DEFUN |INT;submod;4$;20| (|a| |b| |p| |$|)
  (PROG (|c|)
@@ -117187,33 +117201,31 @@ Note that this code is not included in the generated catdef.spad file.
 
 (DEFUN |INT;squareFreePolynomial| (|p| |$|) (SPADCALL |p| (QREFELT |$| 95))) 
 
-(DEFUN |INT;factorPolynomial| (|p| |$|)
- (PROG (|pp| #1=#:G86409)
-  (RETURN
-   (SEQ
-    (LETT |pp| (SPADCALL |p| (QREFELT |$| 96)) |INT;factorPolynomial|)
-    (EXIT
-     (COND
-      ((EQL (SPADCALL |pp| (QREFELT |$| 97)) (SPADCALL |p| (QREFELT |$| 97)))
-        (SPADCALL |p| (QREFELT |$| 99)))
-      ((QUOTE T)
-       (SPADCALL
-        (SPADCALL |pp| (QREFELT |$| 99))
-        (SPADCALL
-         (CONS (FUNCTION |INT;factorPolynomial!0|) |$|)
-         (SPADCALL
-          (PROG2
-           (LETT #1#
-            (SPADCALL
-             (SPADCALL |p| (QREFELT |$| 97))
-             (SPADCALL |pp| (QREFELT |$| 97))
-             (QREFELT |$| 81))
-            |INT;factorPolynomial|)
-           (QCDR #1#)
-           (|check-union| (QEQCAR #1# 0) |$| #1#))
-          (QREFELT |$| 102))
-         (QREFELT |$| 106))
-        (QREFELT |$| 108))))))))) 
+(DEFUN |INT;factorPolynomial| (|p| $)
+  (PROG (|pp| G86409)
+    (RETURN
+      (SEQ (LETT |pp| (SPADCALL |p| (QREFELT $ 96))
+                 |INT;factorPolynomial|)
+           (EXIT (COND
+                   ((EQL (SPADCALL |pp| (QREFELT $ 97))
+                         (SPADCALL |p| (QREFELT $ 97)))
+                    (SPADCALL |p| (QREFELT $ 99)))
+                   ('T
+                    (SPADCALL (SPADCALL |pp| (QREFELT $ 99))
+                        (SPADCALL (CONS #'|INT;factorPolynomial!0| $)
+                            (SPADCALL
+                                (PROG2 (LETT G86409
+                                        (SPADCALL
+                                         (SPADCALL |p| (QREFELT $ 97))
+                                         (SPADCALL |pp| (QREFELT $ 97))
+                                         (QREFELT $ 81))
+                                        |INT;factorPolynomial|)
+                                       (QCDR G86409)
+                                  (|check-union| (QEQCAR G86409 0) $
+                                      G86409))
+                                (QREFELT $ 102))
+                            (QREFELT $ 106))
+                        (QREFELT $ 108)))))))))
 
 (DEFUN |INT;factorPolynomial!0| (|#1| |$|) (SPADCALL |#1| (QREFELT |$| 100))) 
 
@@ -117226,37 +117238,38 @@ Note that this code is not included in the generated catdef.spad file.
   ((SPADCALL |q| (QREFELT |$| 110)) (SPADCALL |p| (QREFELT |$| 111)))
   ((QUOTE T) (SPADCALL (LIST |p| |q|) (QREFELT |$| 114))))) 
 
-(DEFUN |Integer| NIL
- (PROG NIL
-  (RETURN
-   (PROG (#1=#:G86434)
+(DEFUN |Integer| ()
+  (PROG ()
     (RETURN
-     (COND
-      ((LETT #1# (HGET |$ConstructorCache| (QUOTE |Integer|)) |Integer|)
-       (|CDRwithIncrement| (CDAR #1#)))
-      ((QUOTE T)
-       (|UNWIND-PROTECT|
-        (PROG1
-         (CDDAR 
-          (HPUT |$ConstructorCache| (QUOTE |Integer|)
-            (LIST (CONS NIL (CONS 1 (|Integer;|))))))
-         (LETT #1# T |Integer|))
-        (COND
-         ((NOT #1#) (HREM |$ConstructorCache| (QUOTE |Integer|)))))))))))) 
+      (PROG (G86434)
+        (RETURN
+          (COND
+            ((LETT G86434 (HGET |$ConstructorCache| '|Integer|)
+                   |Integer|)
+             (|CDRwithIncrement| (CDAR G86434)))
+            ('T
+             (UNWIND-PROTECT
+               (PROG1 (CDDAR (HPUT |$ConstructorCache| '|Integer|
+                                   (LIST
+                                    (CONS NIL (CONS 1 (|Integer;|))))))
+                 (LETT G86434 T |Integer|))
+               (COND
+                 ((NOT G86434) (HREM |$ConstructorCache| '|Integer|)))))))))))
 
-(DEFUN |Integer;| NIL
- (PROG (|dv$| |$| |pv$|)
-  (RETURN
-   (PROGN
-    (LETT |dv$| (QUOTE (|Integer|)) . #1=(|Integer|))
-    (LETT |$| (GETREFV 130) . #1#)
-    (QSETREFV |$| 0 |dv$|)
-    (QSETREFV |$| 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#))
-    (|haddProp| |$ConstructorCache| (QUOTE |Integer|) NIL (CONS 1 |$|))
-    (|stuffDomainSlots| |$|)
-    (QSETREFV |$| 69 
-     (QSETREFV |$| 68 (CONS (|dispatchFunction| |INT;*;3$;39|) |$|)))
-    |$|)))) 
+(DEFUN |Integer;| ()
+  (PROG (|dv$| $ |pv$|)
+    (RETURN
+      (PROGN
+        (LETT |dv$| '(|Integer|) |Integer|)
+        (LETT $ (GETREFV 130) |Integer|)
+        (QSETREFV $ 0 |dv$|)
+        (QSETREFV $ 3
+            (LETT |pv$| (|buildPredVector| 0 0 NIL) |Integer|))
+        (|haddProp| |$ConstructorCache| '|Integer| NIL (CONS 1 $))
+        (|stuffDomainSlots| $)
+        (QSETREFV $ 69
+            (QSETREFV $ 68 (CONS (|dispatchFunction| |INT;*;3$;39|) $)))
+        $))))
 
 (MAKEPROP
  (QUOTE |Integer|)
@@ -117416,95 +117429,905 @@ Note that this code is not included in the generated catdef.spad file.
 
 (|/VERSIONCHECK| 2) 
 
-(PUT (QUOTE |ISTRING;new;NniC$;1|) (QUOTE |SPADreplace|) (QUOTE |MAKE-FULL-CVEC|)) 
+(PUT '|ISTRING;new;NniC$;1| '|SPADreplace| 'MAKE-FULL-CVEC)
 
 (DEFUN |ISTRING;new;NniC$;1| (|n| |c| |$|) (|MAKE-FULL-CVEC| |n| |c|)) 
 
-(PUT (QUOTE |ISTRING;empty;$;2|) (QUOTE |SPADreplace|) (QUOTE (XLAM NIL (|MAKE-FULL-CVEC| 0)))) 
+(PUT '|ISTRING;empty;$;2| '|SPADreplace|
+     '(XLAM NIL (MAKE-FULL-CVEC 0)))
 
 (DEFUN |ISTRING;empty;$;2| (|$|) (|MAKE-FULL-CVEC| 0)) 
 
 (DEFUN |ISTRING;empty?;$B;3| (|s| |$|) (EQL (QCSIZE |s|) 0)) 
 
-(PUT (QUOTE |ISTRING;#;$Nni;4|) (QUOTE |SPADreplace|) (QUOTE QCSIZE)) 
+(PUT '|ISTRING;#;$Nni;4| '|SPADreplace| 'QCSIZE)
 
 (DEFUN |ISTRING;#;$Nni;4| (|s| |$|) (QCSIZE |s|)) 
 
-(PUT (QUOTE |ISTRING;=;2$B;5|) (QUOTE |SPADreplace|) (QUOTE EQUAL)) 
+(PUT '|ISTRING;=;2$B;5| '|SPADreplace| 'EQUAL)
 
 (DEFUN |ISTRING;=;2$B;5| (|s| |t| |$|) (EQUAL |s| |t|)) 
 
-(PUT (QUOTE |ISTRING;<;2$B;6|) (QUOTE |SPADreplace|) (QUOTE (XLAM (|s| |t|) (CGREATERP |t| |s|)))) 
+(PUT '|ISTRING;<;2$B;6| '|SPADreplace|
+     '(XLAM (|s| |t|) (CGREATERP |t| |s|)))
 
 (DEFUN |ISTRING;<;2$B;6| (|s| |t| |$|) (CGREATERP |t| |s|)) 
 
-(PUT (QUOTE |ISTRING;concat;3$;7|) (QUOTE |SPADreplace|) (QUOTE STRCONC)) 
+(PUT '|ISTRING;concat;3$;7| '|SPADreplace| 'STRCONC)
 
 (DEFUN |ISTRING;concat;3$;7| (|s| |t| |$|) (STRCONC |s| |t|)) 
 
-(PUT (QUOTE |ISTRING;copy;2$;8|) (QUOTE |SPADreplace|) (QUOTE |COPY-SEQ|)) 
+(PUT '|ISTRING;copy;2$;8| '|SPADreplace| 'COPY-SEQ)
 
 (DEFUN |ISTRING;copy;2$;8| (|s| |$|) (|COPY-SEQ| |s|)) 
 
-(DEFUN |ISTRING;insert;2$I$;9| (|s| |t| |i| |$|) (SPADCALL (SPADCALL (SPADCALL |s| (SPADCALL (QREFELT |$| 6) (|-| |i| 1) (QREFELT |$| 20)) (QREFELT |$| 21)) |t| (QREFELT |$| 16)) (SPADCALL |s| (SPADCALL |i| (QREFELT |$| 22)) (QREFELT |$| 21)) (QREFELT |$| 16))) 
+(DEFUN |ISTRING;insert;2$I$;9| (|s| |t| |i| $)
+  (SPADCALL
+      (SPADCALL
+          (SPADCALL |s|
+              (SPADCALL (QREFELT $ 6) (- |i| 1) (QREFELT $ 20))
+              (QREFELT $ 21))
+          |t| (QREFELT $ 16))
+      (SPADCALL |s| (SPADCALL |i| (QREFELT $ 22)) (QREFELT $ 21))
+      (QREFELT $ 16)))
 
 (DEFUN |ISTRING;coerce;$Of;10| (|s| |$|) (SPADCALL |s| (QREFELT |$| 26))) 
 
 (DEFUN |ISTRING;minIndex;$I;11| (|s| |$|) (QREFELT |$| 6)) 
 
-(DEFUN |ISTRING;upperCase!;2$;12| (|s| |$|) (SPADCALL (ELT |$| 31) |s| (QREFELT |$| 33))) 
-
-(DEFUN |ISTRING;lowerCase!;2$;13| (|s| |$|) (SPADCALL (ELT |$| 36) |s| (QREFELT |$| 33))) 
-
-(DEFUN |ISTRING;latex;$S;14| (|s| |$|) (STRCONC "\\mbox{``" (STRCONC |s| "''}"))) 
-
-(DEFUN |ISTRING;replace;$Us2$;15| (|s| |sg| |t| |$|) (PROG (|l| |m| |n| |h| #1=#:G91425 |r| #2=#:G91433 #3=#:G91432 |i| #4=#:G91431 |k|) (RETURN (SEQ (LETT |l| (|-| (SPADCALL |sg| (QREFELT |$| 39)) (QREFELT |$| 6)) |ISTRING;replace;$Us2$;15|) (LETT |m| (SPADCALL |s| (QREFELT |$| 13)) |ISTRING;replace;$Us2$;15|) (LETT |n| (SPADCALL |t| (QREFELT |$| 13)) |ISTRING;replace;$Us2$;15|) (LETT |h| (COND ((SPADCALL |sg| (QREFELT |$| 40)) (|-| (SPADCALL |sg| (QREFELT |$| 41)) (QREFELT |$| 6))) ((QUOTE T) (|-| (SPADCALL |s| (QREFELT |$| 42)) (QREFELT |$| 6)))) |ISTRING;replace;$Us2$;15|) (COND ((OR (OR (|<| |l| 0) (NULL (|<| |h| |m|))) (|<| |h| (|-| |l| 1))) (EXIT (|error| "index out of range")))) (LETT |r| (SPADCALL (PROG1 (LETT #1# (|+| (|-| |m| (|+| (|-| |h| |l|) 1)) |n|) |ISTRING;replace;$Us2$;15|) (|check-subtype| (|>=| #1# 0) (QUOTE (|NonNegativeInteger|)) #1#)) (SPADCALL (QREFELT |$| 43)) (QREFELT |$| 9)) |ISTRING;replace;$Us2$;15|) (SEQ (LETT |i| 0 |ISTRING;replace;$Us2$;15|) (LETT #2# (|-| |l| 1) |ISTRING;replace;$Us2$;15|) (LETT |k| 0 |ISTRING;replace;$Us2$;15|) G190 (COND ((QSGREATERP |i| #2#) (GO G191))) (SEQ (EXIT (QESET |r| |k| (QENUM |s| |i|)))) (LETT |k| (PROG1 (QSADD1 |k|) (LETT |i| (QSADD1 |i|) |ISTRING;replace;$Us2$;15|)) |ISTRING;replace;$Us2$;15|) (GO G190) G191 (EXIT NIL)) (SEQ (LETT |i| 0 |ISTRING;replace;$Us2$;15|) (LETT #3# (|-| |n| 1) |ISTRING;replace;$Us2$;15|) (LETT |k| |k| |ISTRING;replace;$Us2$;15|) G190 (COND ((QSGREATERP |i| #3#) (GO G191))) (SEQ (EXIT (QESET |r| |k| (QENUM |t| |i|)))) (LETT |k| (PROG1 (|+| |k| 1) (LETT |i| (QSADD1 |i|) |ISTRING;replace;$Us2$;15|)) |ISTRING;replace;$Us2$;15|) (GO G190) G191 (EXIT NIL)) (SEQ (LETT |i| (|+| |h| 1) |ISTRING;replace;$Us2$;15|) (LETT #4# (|-| |m| 1) |ISTRING;replace;$Us2$;15|) (LETT |k| |k| |ISTRING;replace;$Us2$;15|) G190 (COND ((|>| |i| #4#) (GO G191))) (SEQ (EXIT (QESET |r| |k| (QENUM |s| |i|)))) (LETT |k| (PROG1 (|+| |k| 1) (LETT |i| (|+| |i| 1) |ISTRING;replace;$Us2$;15|)) |ISTRING;replace;$Us2$;15|) (GO G190) G191 (EXIT NIL)) (EXIT |r|))))) 
-
-(DEFUN |ISTRING;setelt;$I2C;16| (|s| |i| |c| |$|) (SEQ (COND ((OR (|<| |i| (QREFELT |$| 6)) (|<| (SPADCALL |s| (QREFELT |$| 42)) |i|)) (|error| "index out of range")) ((QUOTE T) (SEQ (QESET |s| (|-| |i| (QREFELT |$| 6)) |c|) (EXIT |c|)))))) 
-
-(DEFUN |ISTRING;substring?;2$IB;17| (|part| |whole| |startpos| |$|) (PROG (|np| |nw| |iw| |ip| #1=#:G91443 #2=#:G91442 #3=#:G91438) (RETURN (SEQ (EXIT (SEQ (LETT |np| (QCSIZE |part|) |ISTRING;substring?;2$IB;17|) (LETT |nw| (QCSIZE |whole|) |ISTRING;substring?;2$IB;17|) (LETT |startpos| (|-| |startpos| (QREFELT |$| 6)) |ISTRING;substring?;2$IB;17|) (EXIT (COND ((|<| |startpos| 0) (|error| "index out of bounds")) ((|<| (|-| |nw| |startpos|) |np|) (QUOTE NIL)) ((QUOTE T) (SEQ (SEQ (EXIT (SEQ (LETT |iw| |startpos| |ISTRING;substring?;2$IB;17|) (LETT |ip| 0 |ISTRING;substring?;2$IB;17|) (LETT #1# (|-| |np| 1) |ISTRING;substring?;2$IB;17|) G190 (COND ((QSGREATERP |ip| #1#) (GO G191))) (SEQ (EXIT (COND ((NULL (EQL (QENUM |part| |ip|) (QENUM |whole| |iw|))) (PROGN (LETT #3# (PROGN (LETT #2# (QUOTE NIL) |ISTRING;substring?;2$IB;17|) (GO #2#)) |ISTRING;substring?;2$IB;17|) (GO #3#)))))) (LETT |ip| (PROG1 (QSADD1 |ip|) (LETT |iw| (|+| |iw| 1) |ISTRING;substring?;2$IB;17|)) |ISTRING;substring?;2$IB;17|) (GO G190) G191 (EXIT NIL))) #3# (EXIT #3#)) (EXIT (QUOTE T)))))))) #2# (EXIT #2#))))) 
-
-(DEFUN |ISTRING;position;2$2I;18| (|s| |t| |startpos| |$|) (PROG (|r|) (RETURN (SEQ (LETT |startpos| (|-| |startpos| (QREFELT |$| 6)) |ISTRING;position;2$2I;18|) (EXIT (COND ((|<| |startpos| 0) (|error| "index out of bounds")) ((NULL (|<| |startpos| (QCSIZE |t|))) (|-| (QREFELT |$| 6) 1)) ((QUOTE T) (SEQ (LETT |r| (STRPOS |s| |t| |startpos| NIL) |ISTRING;position;2$2I;18|) (EXIT (COND ((EQ |r| NIL) (|-| (QREFELT |$| 6) 1)) ((QUOTE T) (|+| |r| (QREFELT |$| 6))))))))))))) 
-
-(DEFUN |ISTRING;position;C$2I;19| (|c| |t| |startpos| |$|) (PROG (|r| #1=#:G91454 #2=#:G91453) (RETURN (SEQ (EXIT (SEQ (LETT |startpos| (|-| |startpos| (QREFELT |$| 6)) |ISTRING;position;C$2I;19|) (EXIT (COND ((|<| |startpos| 0) (|error| "index out of bounds")) ((NULL (|<| |startpos| (QCSIZE |t|))) (|-| (QREFELT |$| 6) 1)) ((QUOTE T) (SEQ (SEQ (LETT |r| |startpos| |ISTRING;position;C$2I;19|) (LETT #1# (QSDIFFERENCE (QCSIZE |t|) 1) |ISTRING;position;C$2I;19|) G190 (COND ((|>| |r| #1#) (GO G191))) (SEQ (EXIT (COND ((EQL (QENUM |t| |r|) |c|) (PROGN (LETT #2# (|+| |r| (QREFELT |$| 6)) |ISTRING;position;C$2I;19|) (GO #2#)))))) (LETT |r| (|+| |r| 1) |ISTRING;position;C$2I;19|) (GO G190) G191 (EXIT NIL)) (EXIT (|-| (QREFELT |$| 6) 1)))))))) #2# (EXIT #2#))))) 
-
-(DEFUN |ISTRING;position;Cc$2I;20| (|cc| |t| |startpos| |$|) (PROG (|r| #1=#:G91461 #2=#:G91460) (RETURN (SEQ (EXIT (SEQ (LETT |startpos| (|-| |startpos| (QREFELT |$| 6)) |ISTRING;position;Cc$2I;20|) (EXIT (COND ((|<| |startpos| 0) (|error| "index out of bounds")) ((NULL (|<| |startpos| (QCSIZE |t|))) (|-| (QREFELT |$| 6) 1)) ((QUOTE T) (SEQ (SEQ (LETT |r| |startpos| |ISTRING;position;Cc$2I;20|) (LETT #1# (QSDIFFERENCE (QCSIZE |t|) 1) |ISTRING;position;Cc$2I;20|) G190 (COND ((|>| |r| #1#) (GO G191))) (SEQ (EXIT (COND ((SPADCALL (QENUM |t| |r|) |cc| (QREFELT |$| 49)) (PROGN (LETT #2# (|+| |r| (QREFELT |$| 6)) |ISTRING;position;Cc$2I;20|) (GO #2#)))))) (LETT |r| (|+| |r| 1) |ISTRING;position;Cc$2I;20|) (GO G190) G191 (EXIT NIL)) (EXIT (|-| (QREFELT |$| 6) 1)))))))) #2# (EXIT #2#))))) 
-
-(DEFUN |ISTRING;suffix?;2$B;21| (|s| |t| |$|) (PROG (|n| |m|) (RETURN (SEQ (LETT |n| (SPADCALL |t| (QREFELT |$| 42)) |ISTRING;suffix?;2$B;21|) (LETT |m| (SPADCALL |s| (QREFELT |$| 42)) |ISTRING;suffix?;2$B;21|) (EXIT (COND ((|<| |n| |m|) (QUOTE NIL)) ((QUOTE T) (SPADCALL |s| |t| (|-| (|+| (QREFELT |$| 6) |n|) |m|) (QREFELT |$| 46))))))))) 
-
-(DEFUN |ISTRING;split;$CL;22| (|s| |c| |$|) (PROG (|n| |j| |i| |l|) (RETURN (SEQ (LETT |n| (SPADCALL |s| (QREFELT |$| 42)) |ISTRING;split;$CL;22|) (SEQ (LETT |i| (QREFELT |$| 6) |ISTRING;split;$CL;22|) G190 (COND ((OR (|>| |i| |n|) (NULL (SPADCALL (SPADCALL |s| |i| (QREFELT |$| 52)) |c| (QREFELT |$| 53)))) (GO G191))) (SEQ (EXIT 0)) (LETT |i| (|+| |i| 1) |ISTRING;split;$CL;22|) (GO G190) G191 (EXIT NIL)) (LETT |l| (SPADCALL (QREFELT |$| 55)) |ISTRING;split;$CL;22|) (SEQ G190 (COND ((NULL (COND ((|<| |n| |i|) (QUOTE NIL)) ((QUOTE T) (SEQ (LETT |j| (SPADCALL |c| |s| |i| (QREFELT |$| 48)) |ISTRING;split;$CL;22|) (EXIT (COND ((|<| |j| (QREFELT |$| 6)) (QUOTE NIL)) ((QUOTE T) (QUOTE T)))))))) (GO G191))) (SEQ (LETT |l| (SPADCALL (SPADCALL |s| (SPADCALL |i| (|-| |j| 1) (QREFELT |$| 20)) (QREFELT |$| 21)) |l| (QREFELT |$| 56)) |ISTRING;split;$CL;22|) (EXIT (SEQ (LETT |i| |j| |ISTRING;split;$CL;22|) G190 (COND ((OR (|>| |i| |n|) (NULL (SPADCALL (SPADCALL |s| |i| (QREFELT |$| 52)) |c| (QREFELT |$| 53)))) (GO G191))) (SEQ (EXIT 0)) (LETT |i| (|+| |i| 1) |ISTRING;split;$CL;22|) (GO G190) G191 (EXIT NIL)))) NIL (GO G190) G191 (EXIT NIL)) (COND ((NULL (|<| |n| |i|)) (LETT |l| (SPADCALL (SPADCALL |s| (SPADCALL |i| |n| (QREFELT |$| 20)) (QREFELT |$| 21)) |l| (QREFELT |$| 56)) |ISTRING;split;$CL;22|))) (EXIT (SPADCALL |l| (QREFELT |$| 57))))))) 
-
-(DEFUN |ISTRING;split;$CcL;23| (|s| |cc| |$|) (PROG (|n| |j| |i| |l|) (RETURN (SEQ (LETT |n| (SPADCALL |s| (QREFELT |$| 42)) |ISTRING;split;$CcL;23|) (SEQ (LETT |i| (QREFELT |$| 6) |ISTRING;split;$CcL;23|) G190 (COND ((OR (|>| |i| |n|) (NULL (SPADCALL (SPADCALL |s| |i| (QREFELT |$| 52)) |cc| (QREFELT |$| 49)))) (GO G191))) (SEQ (EXIT 0)) (LETT |i| (|+| |i| 1) |ISTRING;split;$CcL;23|) (GO G190) G191 (EXIT NIL)) (LETT |l| (SPADCALL (QREFELT |$| 55)) |ISTRING;split;$CcL;23|) (SEQ G190 (COND ((NULL (COND ((|<| |n| |i|) (QUOTE NIL)) ((QUOTE T) (SEQ (LETT |j| (SPADCALL |cc| |s| |i| (QREFELT |$| 50)) |ISTRING;split;$CcL;23|) (EXIT (COND ((|<| |j| (QREFELT |$| 6)) (QUOTE NIL)) ((QUOTE T) (QUOTE T)))))))) (GO G191))) (SEQ (LETT |l| (SPADCALL (SPADCALL |s| (SPADCALL |i| (|-| |j| 1) (QREFELT |$| 20)) (QREFELT |$| 21)) |l| (QREFELT |$| 56)) |ISTRING;split;$CcL;23|) (EXIT (SEQ (LETT |i| |j| |ISTRING;split;$CcL;23|) G190 (COND ((OR (|>| |i| |n|) (NULL (SPADCALL (SPADCALL |s| |i| (QREFELT |$| 52)) |cc| (QREFELT |$| 49)))) (GO G191))) (SEQ (EXIT 0)) (LETT |i| (|+| |i| 1) |ISTRING;split;$CcL;23|) (GO G190) G191 (EXIT NIL)))) NIL (GO G190) G191 (EXIT NIL)) (COND ((NULL (|<| |n| |i|)) (LETT |l| (SPADCALL (SPADCALL |s| (SPADCALL |i| |n| (QREFELT |$| 20)) (QREFELT |$| 21)) |l| (QREFELT |$| 56)) |ISTRING;split;$CcL;23|))) (EXIT (SPADCALL |l| (QREFELT |$| 57))))))) 
-
-(DEFUN |ISTRING;leftTrim;$C$;24| (|s| |c| |$|) (PROG (|n| |i|) (RETURN (SEQ (LETT |n| (SPADCALL |s| (QREFELT |$| 42)) |ISTRING;leftTrim;$C$;24|) (SEQ (LETT |i| (QREFELT |$| 6) |ISTRING;leftTrim;$C$;24|) G190 (COND ((OR (|>| |i| |n|) (NULL (SPADCALL (SPADCALL |s| |i| (QREFELT |$| 52)) |c| (QREFELT |$| 53)))) (GO G191))) (SEQ (EXIT 0)) (LETT |i| (|+| |i| 1) |ISTRING;leftTrim;$C$;24|) (GO G190) G191 (EXIT NIL)) (EXIT (SPADCALL |s| (SPADCALL |i| |n| (QREFELT |$| 20)) (QREFELT |$| 21))))))) 
-
-(DEFUN |ISTRING;leftTrim;$Cc$;25| (|s| |cc| |$|) (PROG (|n| |i|) (RETURN (SEQ (LETT |n| (SPADCALL |s| (QREFELT |$| 42)) |ISTRING;leftTrim;$Cc$;25|) (SEQ (LETT |i| (QREFELT |$| 6) |ISTRING;leftTrim;$Cc$;25|) G190 (COND ((OR (|>| |i| |n|) (NULL (SPADCALL (SPADCALL |s| |i| (QREFELT |$| 52)) |cc| (QREFELT |$| 49)))) (GO G191))) (SEQ (EXIT 0)) (LETT |i| (|+| |i| 1) |ISTRING;leftTrim;$Cc$;25|) (GO G190) G191 (EXIT NIL)) (EXIT (SPADCALL |s| (SPADCALL |i| |n| (QREFELT |$| 20)) (QREFELT |$| 21))))))) 
-
-(DEFUN |ISTRING;rightTrim;$C$;26| (|s| |c| |$|) (PROG (|j| #1=#:G91487) (RETURN (SEQ (SEQ (LETT |j| (SPADCALL |s| (QREFELT |$| 42)) |ISTRING;rightTrim;$C$;26|) (LETT #1# (QREFELT |$| 6) |ISTRING;rightTrim;$C$;26|) G190 (COND ((OR (|<| |j| #1#) (NULL (SPADCALL (SPADCALL |s| |j| (QREFELT |$| 52)) |c| (QREFELT |$| 53)))) (GO G191))) (SEQ (EXIT 0)) (LETT |j| (|+| |j| -1) |ISTRING;rightTrim;$C$;26|) (GO G190) G191 (EXIT NIL)) (EXIT (SPADCALL |s| (SPADCALL (SPADCALL |s| (QREFELT |$| 28)) |j| (QREFELT |$| 20)) (QREFELT |$| 21))))))) 
+(DEFUN |ISTRING;upperCase!;2$;12| (|s| $)
+  (SPADCALL (ELT $ 31) |s| (QREFELT $ 33)))
 
-(DEFUN |ISTRING;rightTrim;$Cc$;27| (|s| |cc| |$|) (PROG (|j| #1=#:G91491) (RETURN (SEQ (SEQ (LETT |j| (SPADCALL |s| (QREFELT |$| 42)) |ISTRING;rightTrim;$Cc$;27|) (LETT #1# (QREFELT |$| 6) |ISTRING;rightTrim;$Cc$;27|) G190 (COND ((OR (|<| |j| #1#) (NULL (SPADCALL (SPADCALL |s| |j| (QREFELT |$| 52)) |cc| (QREFELT |$| 49)))) (GO G191))) (SEQ (EXIT 0)) (LETT |j| (|+| |j| -1) |ISTRING;rightTrim;$Cc$;27|) (GO G190) G191 (EXIT NIL)) (EXIT (SPADCALL |s| (SPADCALL (SPADCALL |s| (QREFELT |$| 28)) |j| (QREFELT |$| 20)) (QREFELT |$| 21))))))) 
+(DEFUN |ISTRING;lowerCase!;2$;13| (|s| $)
+  (SPADCALL (ELT $ 36) |s| (QREFELT $ 33)))
 
-(DEFUN |ISTRING;concat;L$;28| (|l| |$|) (PROG (#1=#:G91500 #2=#:G91494 #3=#:G91492 #4=#:G91493 |t| |s| #5=#:G91499 |i|) (RETURN (SEQ (LETT |t| (SPADCALL (PROGN (LETT #4# NIL |ISTRING;concat;L$;28|) (SEQ (LETT |s| NIL |ISTRING;concat;L$;28|) (LETT #1# |l| |ISTRING;concat;L$;28|) G190 (COND ((OR (ATOM #1#) (PROGN (LETT |s| (CAR #1#) |ISTRING;concat;L$;28|) NIL)) (GO G191))) (SEQ (EXIT (PROGN (LETT #2# (SPADCALL |s| (QREFELT |$| 13)) |ISTRING;concat;L$;28|) (COND (#4# (LETT #3# (|+| #3# #2#) |ISTRING;concat;L$;28|)) ((QUOTE T) (PROGN (LETT #3# #2# |ISTRING;concat;L$;28|) (LETT #4# (QUOTE T) |ISTRING;concat;L$;28|))))))) (LETT #1# (CDR #1#) |ISTRING;concat;L$;28|) (GO G190) G191 (EXIT NIL)) (COND (#4# #3#) ((QUOTE T) 0))) (SPADCALL (QREFELT |$| 43)) (QREFELT |$| 9)) |ISTRING;concat;L$;28|) (LETT |i| (QREFELT |$| 6) |ISTRING;concat;L$;28|) (SEQ (LETT |s| NIL |ISTRING;concat;L$;28|) (LETT #5# |l| |ISTRING;concat;L$;28|) G190 (COND ((OR (ATOM #5#) (PROGN (LETT |s| (CAR #5#) |ISTRING;concat;L$;28|) NIL)) (GO G191))) (SEQ (SPADCALL |t| |s| |i| (QREFELT |$| 65)) (EXIT (LETT |i| (|+| |i| (SPADCALL |s| (QREFELT |$| 13))) |ISTRING;concat;L$;28|))) (LETT #5# (CDR #5#) |ISTRING;concat;L$;28|) (GO G190) G191 (EXIT NIL)) (EXIT |t|))))) 
+(DEFUN |ISTRING;latex;$S;14| (|s| $)
+  (STRCONC "\\mbox{``" (STRCONC |s| "''}")))
 
-(DEFUN |ISTRING;copyInto!;2$I$;29| (|y| |x| |s| |$|) (PROG (|m| |n|) (RETURN (SEQ (LETT |m| (SPADCALL |x| (QREFELT |$| 13)) |ISTRING;copyInto!;2$I$;29|) (LETT |n| (SPADCALL |y| (QREFELT |$| 13)) |ISTRING;copyInto!;2$I$;29|) (LETT |s| (|-| |s| (QREFELT |$| 6)) |ISTRING;copyInto!;2$I$;29|) (COND ((OR (|<| |s| 0) (|<| |n| (|+| |s| |m|))) (EXIT (|error| "index out of range")))) (RPLACSTR |y| |s| |m| |x| 0 |m|) (EXIT |y|))))) 
-
-(DEFUN |ISTRING;elt;$IC;30| (|s| |i| |$|) (COND ((OR (|<| |i| (QREFELT |$| 6)) (|<| (SPADCALL |s| (QREFELT |$| 42)) |i|)) (|error| "index out of range")) ((QUOTE T) (QENUM |s| (|-| |i| (QREFELT |$| 6)))))) 
-
-(DEFUN |ISTRING;elt;$Us$;31| (|s| |sg| |$|) (PROG (|l| |h|) (RETURN (SEQ (LETT |l| (|-| (SPADCALL |sg| (QREFELT |$| 39)) (QREFELT |$| 6)) |ISTRING;elt;$Us$;31|) (LETT |h| (COND ((SPADCALL |sg| (QREFELT |$| 40)) (|-| (SPADCALL |sg| (QREFELT |$| 41)) (QREFELT |$| 6))) ((QUOTE T) (|-| (SPADCALL |s| (QREFELT |$| 42)) (QREFELT |$| 6)))) |ISTRING;elt;$Us$;31|) (COND ((OR (|<| |l| 0) (NULL (|<| |h| (SPADCALL |s| (QREFELT |$| 13))))) (EXIT (|error| "index out of bound")))) (EXIT (SUBSTRING |s| |l| (MAX 0 (|+| (|-| |h| |l|) 1)))))))) 
+(DEFUN |ISTRING;replace;$Us2$;15| (|s| |sg| |t| $)
+  (PROG (|l| |m| |n| |h| G91425 |r| G91433 G91432 |i| G91431
+             |k|)
+    (RETURN
+      (SEQ (LETT |l| (- (SPADCALL |sg| (QREFELT $ 39)) (QREFELT $ 6))
+                 |ISTRING;replace;$Us2$;15|)
+           (LETT |m| (SPADCALL |s| (QREFELT $ 13))
+                 |ISTRING;replace;$Us2$;15|)
+           (LETT |n| (SPADCALL |t| (QREFELT $ 13))
+                 |ISTRING;replace;$Us2$;15|)
+           (LETT |h|
+                 (COND
+                   ((SPADCALL |sg| (QREFELT $ 40))
+                    (- (SPADCALL |sg| (QREFELT $ 41)) (QREFELT $ 6)))
+                   ('T (- (SPADCALL |s| (QREFELT $ 42)) (QREFELT $ 6))))
+                 |ISTRING;replace;$Us2$;15|)
+           (COND
+             ((OR (OR (< |l| 0) (NULL (< |h| |m|))) (< |h| (- |l| 1)))
+              (EXIT (|error| "index out of range"))))
+           (LETT |r|
+                 (SPADCALL
+                     (PROG1 (LETT G91425
+                                  (+ (- |m| (+ (- |h| |l|) 1)) |n|)
+                                  |ISTRING;replace;$Us2$;15|)
+                       (|check-subtype| (>= G91425 0)
+                           '(|NonNegativeInteger|) G91425))
+                     (SPADCALL (QREFELT $ 43)) (QREFELT $ 9))
+                 |ISTRING;replace;$Us2$;15|)
+           (SEQ (LETT |i| 0 |ISTRING;replace;$Us2$;15|)
+                (LETT G91433 (- |l| 1) |ISTRING;replace;$Us2$;15|)
+                (LETT |k| 0 |ISTRING;replace;$Us2$;15|) G190
+                (COND ((QSGREATERP |i| G91433) (GO G191)))
+                (SEQ (EXIT (QESET |r| |k| (QENUM |s| |i|))))
+                (LETT |k|
+                      (PROG1 (QSADD1 |k|)
+                        (LETT |i| (QSADD1 |i|)
+                              |ISTRING;replace;$Us2$;15|))
+                      |ISTRING;replace;$Us2$;15|)
+                (GO G190) G191 (EXIT NIL))
+           (SEQ (LETT |i| 0 |ISTRING;replace;$Us2$;15|)
+                (LETT G91432 (- |n| 1) |ISTRING;replace;$Us2$;15|)
+                (LETT |k| |k| |ISTRING;replace;$Us2$;15|) G190
+                (COND ((QSGREATERP |i| G91432) (GO G191)))
+                (SEQ (EXIT (QESET |r| |k| (QENUM |t| |i|))))
+                (LETT |k|
+                      (PROG1 (+ |k| 1)
+                        (LETT |i| (QSADD1 |i|)
+                              |ISTRING;replace;$Us2$;15|))
+                      |ISTRING;replace;$Us2$;15|)
+                (GO G190) G191 (EXIT NIL))
+           (SEQ (LETT |i| (+ |h| 1) |ISTRING;replace;$Us2$;15|)
+                (LETT G91431 (- |m| 1) |ISTRING;replace;$Us2$;15|)
+                (LETT |k| |k| |ISTRING;replace;$Us2$;15|) G190
+                (COND ((> |i| G91431) (GO G191)))
+                (SEQ (EXIT (QESET |r| |k| (QENUM |s| |i|))))
+                (LETT |k|
+                      (PROG1 (+ |k| 1)
+                        (LETT |i| (+ |i| 1) |ISTRING;replace;$Us2$;15|))
+                      |ISTRING;replace;$Us2$;15|)
+                (GO G190) G191 (EXIT NIL))
+           (EXIT |r|)))))
+
+(DEFUN |ISTRING;setelt;$I2C;16| (|s| |i| |c| $)
+  (SEQ (COND
+         ((OR (< |i| (QREFELT $ 6))
+              (< (SPADCALL |s| (QREFELT $ 42)) |i|))
+          (|error| "index out of range"))
+         ('T (SEQ (QESET |s| (- |i| (QREFELT $ 6)) |c|) (EXIT |c|))))))
+
+(DEFUN |ISTRING;substring?;2$IB;17| (|part| |whole| |startpos| $)
+  (PROG (|np| |nw| |iw| |ip| G91443 G91442 G91438)
+    (RETURN
+      (SEQ (EXIT (SEQ (LETT |np| (QCSIZE |part|)
+                            |ISTRING;substring?;2$IB;17|)
+                      (LETT |nw| (QCSIZE |whole|)
+                            |ISTRING;substring?;2$IB;17|)
+                      (LETT |startpos| (- |startpos| (QREFELT $ 6))
+                            |ISTRING;substring?;2$IB;17|)
+                      (EXIT (COND
+                              ((< |startpos| 0)
+                               (|error| "index out of bounds"))
+                              ((< (- |nw| |startpos|) |np|) 'NIL)
+                              ('T
+                               (SEQ (SEQ
+                                     (EXIT
+                                      (SEQ
+                                       (LETT |iw| |startpos|
+                                        |ISTRING;substring?;2$IB;17|)
+                                       (LETT |ip| 0
+                                        |ISTRING;substring?;2$IB;17|)
+                                       (LETT G91443 (- |np| 1)
+                                        |ISTRING;substring?;2$IB;17|)
+                                       G190
+                                       (COND
+                                         ((QSGREATERP |ip| G91443)
+                                          (GO G191)))
+                                       (SEQ
+                                        (EXIT
+                                         (COND
+                                           ((NULL
+                                             (EQL (QENUM |part| |ip|)
+                                              (QENUM |whole| |iw|)))
+                                            (PROGN
+                                              (LETT G91438
+                                               (PROGN
+                                                 (LETT G91442 'NIL
+                                                  |ISTRING;substring?;2$IB;17|)
+                                                 (GO G91442))
+                                               |ISTRING;substring?;2$IB;17|)
+                                              (GO G91438))))))
+                                       (LETT |ip|
+                                        (PROG1 (QSADD1 |ip|)
+                                          (LETT |iw| (+ |iw| 1)
+                                           |ISTRING;substring?;2$IB;17|))
+                                        |ISTRING;substring?;2$IB;17|)
+                                       (GO G190) G191 (EXIT NIL)))
+                                     G91438 (EXIT G91438))
+                                    (EXIT 'T)))))))
+           G91442 (EXIT G91442)))))
+
+(DEFUN |ISTRING;position;2$2I;18| (|s| |t| |startpos| $)
+  (PROG (|r|)
+    (RETURN
+      (SEQ (LETT |startpos| (- |startpos| (QREFELT $ 6))
+                 |ISTRING;position;2$2I;18|)
+           (EXIT (COND
+                   ((< |startpos| 0) (|error| "index out of bounds"))
+                   ((NULL (< |startpos| (QCSIZE |t|)))
+                    (- (QREFELT $ 6) 1))
+                   ('T
+                    (SEQ (LETT |r| (STRPOS |s| |t| |startpos| NIL)
+                               |ISTRING;position;2$2I;18|)
+                         (EXIT (COND
+                                 ((EQ |r| NIL) (- (QREFELT $ 6) 1))
+                                 ('T (+ |r| (QREFELT $ 6)))))))))))))
+
+(DEFUN |ISTRING;position;C$2I;19| (|c| |t| |startpos| $)
+  (PROG (|r| G91454 G91453)
+    (RETURN
+      (SEQ (EXIT (SEQ (LETT |startpos| (- |startpos| (QREFELT $ 6))
+                            |ISTRING;position;C$2I;19|)
+                      (EXIT (COND
+                              ((< |startpos| 0)
+                               (|error| "index out of bounds"))
+                              ((NULL (< |startpos| (QCSIZE |t|)))
+                               (- (QREFELT $ 6) 1))
+                              ('T
+                               (SEQ (SEQ
+                                     (LETT |r| |startpos|
+                                      |ISTRING;position;C$2I;19|)
+                                     (LETT G91454
+                                      (QSDIFFERENCE (QCSIZE |t|) 1)
+                                      |ISTRING;position;C$2I;19|)
+                                     G190
+                                     (COND
+                                       ((> |r| G91454) (GO G191)))
+                                     (SEQ
+                                      (EXIT
+                                       (COND
+                                         ((EQL (QENUM |t| |r|) |c|)
+                                          (PROGN
+                                            (LETT G91453
+                                             (+ |r| (QREFELT $ 6))
+                                             |ISTRING;position;C$2I;19|)
+                                            (GO G91453))))))
+                                     (LETT |r| (+ |r| 1)
+                                      |ISTRING;position;C$2I;19|)
+                                     (GO G190) G191 (EXIT NIL))
+                                    (EXIT (- (QREFELT $ 6) 1))))))))
+           G91453 (EXIT G91453)))))
+
+(DEFUN |ISTRING;position;Cc$2I;20| (|cc| |t| |startpos| $)
+  (PROG (|r| G91461 G91460)
+    (RETURN
+      (SEQ (EXIT (SEQ (LETT |startpos| (- |startpos| (QREFELT $ 6))
+                            |ISTRING;position;Cc$2I;20|)
+                      (EXIT (COND
+                              ((< |startpos| 0)
+                               (|error| "index out of bounds"))
+                              ((NULL (< |startpos| (QCSIZE |t|)))
+                               (- (QREFELT $ 6) 1))
+                              ('T
+                               (SEQ (SEQ
+                                     (LETT |r| |startpos|
+                                      |ISTRING;position;Cc$2I;20|)
+                                     (LETT G91461
+                                      (QSDIFFERENCE (QCSIZE |t|) 1)
+                                      |ISTRING;position;Cc$2I;20|)
+                                     G190
+                                     (COND
+                                       ((> |r| G91461) (GO G191)))
+                                     (SEQ
+                                      (EXIT
+                                       (COND
+                                         ((SPADCALL (QENUM |t| |r|)
+                                           |cc| (QREFELT $ 49))
+                                          (PROGN
+                                            (LETT G91460
+                                             (+ |r| (QREFELT $ 6))
+                                             |ISTRING;position;Cc$2I;20|)
+                                            (GO G91460))))))
+                                     (LETT |r| (+ |r| 1)
+                                      |ISTRING;position;Cc$2I;20|)
+                                     (GO G190) G191 (EXIT NIL))
+                                    (EXIT (- (QREFELT $ 6) 1))))))))
+           G91460 (EXIT G91460)))))
+
+(DEFUN |ISTRING;suffix?;2$B;21| (|s| |t| $)
+  (PROG (|n| |m|)
+    (RETURN
+      (SEQ (LETT |n| (SPADCALL |t| (QREFELT $ 42))
+                 |ISTRING;suffix?;2$B;21|)
+           (LETT |m| (SPADCALL |s| (QREFELT $ 42))
+                 |ISTRING;suffix?;2$B;21|)
+           (EXIT (COND
+                   ((< |n| |m|) 'NIL)
+                   ('T
+                    (SPADCALL |s| |t| (- (+ (QREFELT $ 6) |n|) |m|)
+                        (QREFELT $ 46)))))))))
+
+(DEFUN |ISTRING;split;$CL;22| (|s| |c| $)
+  (PROG (|n| |j| |i| |l|)
+    (RETURN
+      (SEQ (LETT |n| (SPADCALL |s| (QREFELT $ 42))
+                 |ISTRING;split;$CL;22|)
+           (SEQ (LETT |i| (QREFELT $ 6) |ISTRING;split;$CL;22|) G190
+                (COND
+                  ((OR (> |i| |n|)
+                       (NULL (SPADCALL
+                                 (SPADCALL |s| |i| (QREFELT $ 52)) |c|
+                                 (QREFELT $ 53))))
+                   (GO G191)))
+                (SEQ (EXIT 0))
+                (LETT |i| (+ |i| 1) |ISTRING;split;$CL;22|) (GO G190)
+                G191 (EXIT NIL))
+           (LETT |l| (SPADCALL (QREFELT $ 55)) |ISTRING;split;$CL;22|)
+           (SEQ G190
+                (COND
+                  ((NULL (COND
+                           ((< |n| |i|) 'NIL)
+                           ('T
+                            (SEQ (LETT |j|
+                                       (SPADCALL |c| |s| |i|
+                                        (QREFELT $ 48))
+                                       |ISTRING;split;$CL;22|)
+                                 (EXIT (COND
+                                         ((< |j| (QREFELT $ 6)) 'NIL)
+                                         ('T 'T)))))))
+                   (GO G191)))
+                (SEQ (LETT |l|
+                           (SPADCALL
+                               (SPADCALL |s|
+                                   (SPADCALL |i| (- |j| 1)
+                                    (QREFELT $ 20))
+                                   (QREFELT $ 21))
+                               |l| (QREFELT $ 56))
+                           |ISTRING;split;$CL;22|)
+                     (EXIT (SEQ (LETT |i| |j| |ISTRING;split;$CL;22|)
+                                G190
+                                (COND
+                                  ((OR (> |i| |n|)
+                                    (NULL
+                                     (SPADCALL
+                                      (SPADCALL |s| |i| (QREFELT $ 52))
+                                      |c| (QREFELT $ 53))))
+                                   (GO G191)))
+                                (SEQ (EXIT 0))
+                                (LETT |i| (+ |i| 1)
+                                      |ISTRING;split;$CL;22|)
+                                (GO G190) G191 (EXIT NIL))))
+                NIL (GO G190) G191 (EXIT NIL))
+           (COND
+             ((NULL (< |n| |i|))
+              (LETT |l|
+                    (SPADCALL
+                        (SPADCALL |s| (SPADCALL |i| |n| (QREFELT $ 20))
+                            (QREFELT $ 21))
+                        |l| (QREFELT $ 56))
+                    |ISTRING;split;$CL;22|)))
+           (EXIT (SPADCALL |l| (QREFELT $ 57)))))))
+
+(DEFUN |ISTRING;split;$CcL;23| (|s| |cc| $)
+  (PROG (|n| |j| |i| |l|)
+    (RETURN
+      (SEQ (LETT |n| (SPADCALL |s| (QREFELT $ 42))
+                 |ISTRING;split;$CcL;23|)
+           (SEQ (LETT |i| (QREFELT $ 6) |ISTRING;split;$CcL;23|) G190
+                (COND
+                  ((OR (> |i| |n|)
+                       (NULL (SPADCALL
+                                 (SPADCALL |s| |i| (QREFELT $ 52)) |cc|
+                                 (QREFELT $ 49))))
+                   (GO G191)))
+                (SEQ (EXIT 0))
+                (LETT |i| (+ |i| 1) |ISTRING;split;$CcL;23|) (GO G190)
+                G191 (EXIT NIL))
+           (LETT |l| (SPADCALL (QREFELT $ 55)) |ISTRING;split;$CcL;23|)
+           (SEQ G190
+                (COND
+                  ((NULL (COND
+                           ((< |n| |i|) 'NIL)
+                           ('T
+                            (SEQ (LETT |j|
+                                       (SPADCALL |cc| |s| |i|
+                                        (QREFELT $ 50))
+                                       |ISTRING;split;$CcL;23|)
+                                 (EXIT (COND
+                                         ((< |j| (QREFELT $ 6)) 'NIL)
+                                         ('T 'T)))))))
+                   (GO G191)))
+                (SEQ (LETT |l|
+                           (SPADCALL
+                               (SPADCALL |s|
+                                   (SPADCALL |i| (- |j| 1)
+                                    (QREFELT $ 20))
+                                   (QREFELT $ 21))
+                               |l| (QREFELT $ 56))
+                           |ISTRING;split;$CcL;23|)
+                     (EXIT (SEQ (LETT |i| |j| |ISTRING;split;$CcL;23|)
+                                G190
+                                (COND
+                                  ((OR (> |i| |n|)
+                                    (NULL
+                                     (SPADCALL
+                                      (SPADCALL |s| |i| (QREFELT $ 52))
+                                      |cc| (QREFELT $ 49))))
+                                   (GO G191)))
+                                (SEQ (EXIT 0))
+                                (LETT |i| (+ |i| 1)
+                                      |ISTRING;split;$CcL;23|)
+                                (GO G190) G191 (EXIT NIL))))
+                NIL (GO G190) G191 (EXIT NIL))
+           (COND
+             ((NULL (< |n| |i|))
+              (LETT |l|
+                    (SPADCALL
+                        (SPADCALL |s| (SPADCALL |i| |n| (QREFELT $ 20))
+                            (QREFELT $ 21))
+                        |l| (QREFELT $ 56))
+                    |ISTRING;split;$CcL;23|)))
+           (EXIT (SPADCALL |l| (QREFELT $ 57)))))))
+
+(DEFUN |ISTRING;leftTrim;$C$;24| (|s| |c| $)
+  (PROG (|n| |i|)
+    (RETURN
+      (SEQ (LETT |n| (SPADCALL |s| (QREFELT $ 42))
+                 |ISTRING;leftTrim;$C$;24|)
+           (SEQ (LETT |i| (QREFELT $ 6) |ISTRING;leftTrim;$C$;24|) G190
+                (COND
+                  ((OR (> |i| |n|)
+                       (NULL (SPADCALL
+                                 (SPADCALL |s| |i| (QREFELT $ 52)) |c|
+                                 (QREFELT $ 53))))
+                   (GO G191)))
+                (SEQ (EXIT 0))
+                (LETT |i| (+ |i| 1) |ISTRING;leftTrim;$C$;24|)
+                (GO G190) G191 (EXIT NIL))
+           (EXIT (SPADCALL |s| (SPADCALL |i| |n| (QREFELT $ 20))
+                     (QREFELT $ 21)))))))
+
+(DEFUN |ISTRING;leftTrim;$Cc$;25| (|s| |cc| $)
+  (PROG (|n| |i|)
+    (RETURN
+      (SEQ (LETT |n| (SPADCALL |s| (QREFELT $ 42))
+                 |ISTRING;leftTrim;$Cc$;25|)
+           (SEQ (LETT |i| (QREFELT $ 6) |ISTRING;leftTrim;$Cc$;25|)
+                G190
+                (COND
+                  ((OR (> |i| |n|)
+                       (NULL (SPADCALL
+                                 (SPADCALL |s| |i| (QREFELT $ 52)) |cc|
+                                 (QREFELT $ 49))))
+                   (GO G191)))
+                (SEQ (EXIT 0))
+                (LETT |i| (+ |i| 1) |ISTRING;leftTrim;$Cc$;25|)
+                (GO G190) G191 (EXIT NIL))
+           (EXIT (SPADCALL |s| (SPADCALL |i| |n| (QREFELT $ 20))
+                     (QREFELT $ 21)))))))
+
+(DEFUN |ISTRING;rightTrim;$C$;26| (|s| |c| $)
+  (PROG (|j| G91487)
+    (RETURN
+      (SEQ (SEQ (LETT |j| (SPADCALL |s| (QREFELT $ 42))
+                      |ISTRING;rightTrim;$C$;26|)
+                (LETT G91487 (QREFELT $ 6)
+                      |ISTRING;rightTrim;$C$;26|)
+                G190
+                (COND
+                  ((OR (< |j| G91487)
+                       (NULL (SPADCALL
+                                 (SPADCALL |s| |j| (QREFELT $ 52)) |c|
+                                 (QREFELT $ 53))))
+                   (GO G191)))
+                (SEQ (EXIT 0))
+                (LETT |j| (+ |j| -1) |ISTRING;rightTrim;$C$;26|)
+                (GO G190) G191 (EXIT NIL))
+           (EXIT (SPADCALL |s|
+                     (SPADCALL (SPADCALL |s| (QREFELT $ 28)) |j|
+                         (QREFELT $ 20))
+                     (QREFELT $ 21)))))))
+
+(DEFUN |ISTRING;rightTrim;$Cc$;27| (|s| |cc| $)
+  (PROG (|j| G91491)
+    (RETURN
+      (SEQ (SEQ (LETT |j| (SPADCALL |s| (QREFELT $ 42))
+                      |ISTRING;rightTrim;$Cc$;27|)
+                (LETT G91491 (QREFELT $ 6)
+                      |ISTRING;rightTrim;$Cc$;27|)
+                G190
+                (COND
+                  ((OR (< |j| G91491)
+                       (NULL (SPADCALL
+                                 (SPADCALL |s| |j| (QREFELT $ 52)) |cc|
+                                 (QREFELT $ 49))))
+                   (GO G191)))
+                (SEQ (EXIT 0))
+                (LETT |j| (+ |j| -1) |ISTRING;rightTrim;$Cc$;27|)
+                (GO G190) G191 (EXIT NIL))
+           (EXIT (SPADCALL |s|
+                     (SPADCALL (SPADCALL |s| (QREFELT $ 28)) |j|
+                         (QREFELT $ 20))
+                     (QREFELT $ 21)))))))
+
+
+(DEFUN |ISTRING;concat;L$;28| (|l| $)
+  (PROG (G91500 G91494 G91492 G91493 |t| |s| G91499 |i|)
+    (RETURN
+      (SEQ (LETT |t|
+                 (SPADCALL
+                     (PROGN
+                       (LETT G91493 NIL |ISTRING;concat;L$;28|)
+                       (SEQ (LETT |s| NIL |ISTRING;concat;L$;28|)
+                            (LETT G91500 |l| |ISTRING;concat;L$;28|)
+                            G190
+                            (COND
+                              ((OR (ATOM G91500)
+                                   (PROGN
+                                     (LETT |s| (CAR G91500)
+                                      |ISTRING;concat;L$;28|)
+                                     NIL))
+                               (GO G191)))
+                            (SEQ (EXIT (PROGN
+                                         (LETT G91494
+                                          (SPADCALL |s| (QREFELT $ 13))
+                                          |ISTRING;concat;L$;28|)
+                                         (COND
+                                           (G91493
+                                            (LETT G91492
+                                             (+ G91492 G91494)
+                                             |ISTRING;concat;L$;28|))
+                                           ('T
+                                            (PROGN
+                                              (LETT G91492 G91494
+                                               |ISTRING;concat;L$;28|)
+                                              (LETT G91493 'T
+                                               |ISTRING;concat;L$;28|)))))))
+                            (LETT G91500 (CDR G91500)
+                                  |ISTRING;concat;L$;28|)
+                            (GO G190) G191 (EXIT NIL))
+                       (COND (G91493 G91492) ('T 0)))
+                     (SPADCALL (QREFELT $ 43)) (QREFELT $ 9))
+                 |ISTRING;concat;L$;28|)
+           (LETT |i| (QREFELT $ 6) |ISTRING;concat;L$;28|)
+           (SEQ (LETT |s| NIL |ISTRING;concat;L$;28|)
+                (LETT G91499 |l| |ISTRING;concat;L$;28|) G190
+                (COND
+                  ((OR (ATOM G91499)
+                       (PROGN
+                         (LETT |s| (CAR G91499)
+                               |ISTRING;concat;L$;28|)
+                         NIL))
+                   (GO G191)))
+                (SEQ (SPADCALL |t| |s| |i| (QREFELT $ 65))
+                     (EXIT (LETT |i|
+                                 (+ |i| (SPADCALL |s| (QREFELT $ 13)))
+                                 |ISTRING;concat;L$;28|)))
+                (LETT G91499 (CDR G91499) |ISTRING;concat;L$;28|)
+                (GO G190) G191 (EXIT NIL))
+           (EXIT |t|)))))
+
+(DEFUN |ISTRING;copyInto!;2$I$;29| (|y| |x| |s| $)
+  (PROG (|m| |n|)
+    (RETURN
+      (SEQ (LETT |m| (SPADCALL |x| (QREFELT $ 13))
+                 |ISTRING;copyInto!;2$I$;29|)
+           (LETT |n| (SPADCALL |y| (QREFELT $ 13))
+                 |ISTRING;copyInto!;2$I$;29|)
+           (LETT |s| (- |s| (QREFELT $ 6)) |ISTRING;copyInto!;2$I$;29|)
+           (COND
+             ((OR (< |s| 0) (< |n| (+ |s| |m|)))
+              (EXIT (|error| "index out of range"))))
+           (RPLACSTR |y| |s| |m| |x| 0 |m|) (EXIT |y|)))))
 
-(DEFUN |ISTRING;hash;$I;32| (|s| |$|) (PROG (|n|) (RETURN (SEQ (LETT |n| (QCSIZE |s|) |ISTRING;hash;$I;32|) (EXIT (COND ((ZEROP |n|) 0) ((EQL |n| 1) (SPADCALL (SPADCALL |s| (QREFELT |$| 6) (QREFELT |$| 52)) (QREFELT |$| 67))) ((QUOTE T) (|*| (|*| (SPADCALL (SPADCALL |s| (QREFELT |$| 6) (QREFELT |$| 52)) (QREFELT |$| 67)) (SPADCALL (SPADCALL |s| (|-| (|+| (QREFELT |$| 6) |n|) 1) (QREFELT |$| 52)) (QREFELT |$| 67))) (SPADCALL (SPADCALL |s| (|+| (QREFELT |$| 6) (QUOTIENT2 |n| 2)) (QREFELT |$| 52)) (QREFELT |$| 67)))))))))) 
 
-(PUT (QUOTE |ISTRING;match;2$CNni;33|) (QUOTE |SPADreplace|) (QUOTE |stringMatch|)) 
+(DEFUN |ISTRING;elt;$IC;30| (|s| |i| $)
+  (COND
+    ((OR (< |i| (QREFELT $ 6)) (< (SPADCALL |s| (QREFELT $ 42)) |i|))
+     (|error| "index out of range"))
+    ('T (QENUM |s| (- |i| (QREFELT $ 6))))))
 
-(DEFUN |ISTRING;match;2$CNni;33| (|pattern| |target| |wildcard| |$|) (|stringMatch| |pattern| |target| |wildcard|)) 
+(DEFUN |ISTRING;elt;$Us$;31| (|s| |sg| $)
+  (PROG (|l| |h|)
+    (RETURN
+      (SEQ (LETT |l| (- (SPADCALL |sg| (QREFELT $ 39)) (QREFELT $ 6))
+                 |ISTRING;elt;$Us$;31|)
+           (LETT |h|
+                 (COND
+                   ((SPADCALL |sg| (QREFELT $ 40))
+                    (- (SPADCALL |sg| (QREFELT $ 41)) (QREFELT $ 6)))
+                   ('T (- (SPADCALL |s| (QREFELT $ 42)) (QREFELT $ 6))))
+                 |ISTRING;elt;$Us$;31|)
+           (COND
+             ((OR (< |l| 0)
+                  (NULL (< |h| (SPADCALL |s| (QREFELT $ 13)))))
+              (EXIT (|error| "index out of bound"))))
+           (EXIT (SUBSTRING |s| |l| (MAX 0 (+ (- |h| |l|) 1))))))))
 
-(DEFUN |ISTRING;match?;2$CB;34| (|pattern| |target| |dontcare| |$|) (PROG (|n| |m| #1=#:G91514 #2=#:G91516 |s| #3=#:G91518 #4=#:G91526 |i| |p| #5=#:G91519 |q|) (RETURN (SEQ (EXIT (SEQ (LETT |n| (SPADCALL |pattern| (QREFELT |$| 42)) |ISTRING;match?;2$CB;34|) (LETT |p| (PROG1 (LETT #1# (SPADCALL |dontcare| |pattern| (LETT |m| (SPADCALL |pattern| (QREFELT |$| 28)) |ISTRING;match?;2$CB;34|) (QREFELT |$| 48)) |ISTRING;match?;2$CB;34|) (|check-subtype| (|>=| #1# 0) (QUOTE (|NonNegativeInteger|)) #1#)) |ISTRING;match?;2$CB;34|) (EXIT (COND ((EQL |p| (|-| |m| 1)) (SPADCALL |pattern| |target| (QREFELT |$| 14))) ((QUOTE T) (SEQ (COND ((NULL (EQL |p| |m|)) (COND ((NULL (SPADCALL (SPADCALL |pattern| (SPADCALL |m| (|-| |p| 1) (QREFELT |$| 20)) (QREFELT |$| 21)) |target| (QREFELT |$| 70))) (EXIT (QUOTE NIL)))))) (LETT |i| |p| |ISTRING;match?;2$CB;34|) (LETT |q| (PROG1 (LETT #2# (SPADCALL |dontcare| |pattern| (|+| |p| 1) (QREFELT |$| 48)) |ISTRING;match?;2$CB;34|) (|check-subtype| (|>=| #2# 0) (QUOTE (|NonNegativeInteger|)) #2#)) |ISTRING;match?;2$CB;34|) (SEQ G190 (COND ((NULL (COND ((EQL |q| (|-| |m| 1)) (QUOTE NIL)) ((QUOTE T) (QUOTE T)))) (GO G191))) (SEQ (LETT |s| (SPADCALL |pattern| (SPADCALL (|+| |p| 1) (|-| |q| 1) (QREFELT |$| 20)) (QREFELT |$| 21)) |ISTRING;match?;2$CB;34|) (LETT |i| (PROG1 (LETT #3# (SPADCALL |s| |target| |i| (QREFELT |$| 47)) |ISTRING;match?;2$CB;34|) (|check-subtype| (|>=| #3# 0) (QUOTE (|NonNegativeInteger|)) #3#)) |ISTRING;match?;2$CB;34|) (EXIT (COND ((EQL |i| (|-| |m| 1)) (PROGN (LETT #4# (QUOTE NIL) |ISTRING;match?;2$CB;34|) (GO #4#))) ((QUOTE T) (SEQ (LETT |i| (|+| |i| (SPADCALL |s| (QREFELT |$| 13))) |ISTRING;match?;2$CB;34|) (LETT |p| |q| |ISTRING;match?;2$CB;34|) (EXIT (LETT |q| (PROG1 (LETT #5# (SPADCALL |dontcare| |pattern| (|+| |q| 1) (QREFELT |$| 48)) |ISTRING;match?;2$CB;34|) (|check-subtype| (|>=| #5# 0) (QUOTE (|NonNegativeInteger|)) #5#)) |ISTRING;match?;2$CB;34|))))))) NIL (GO G190) G191 (EXIT NIL)) (COND ((NULL (EQL |p| |n|)) (COND ((NULL (SPADCALL (SPADCALL |pattern| (SPADCALL (|+| |p| 1) |n| (QREFELT |$| 20)) (QREFELT |$| 21)) |target| (QREFELT |$| 51))) (EXIT (QUOTE NIL)))))) (EXIT (QUOTE T)))))))) #4# (EXIT #4#))))) 
 
-(DEFUN |IndexedString| (#1=#:G91535) (PROG NIL (RETURN (PROG (#2=#:G91536) (RETURN (COND ((LETT #2# (|lassocShiftWithFunction| (LIST (|devaluate| #1#)) (HGET |$ConstructorCache| (QUOTE |IndexedString|)) (QUOTE |domainEqualList|)) |IndexedString|) (|CDRwithIncrement| #2#)) ((QUOTE T) (|UNWIND-PROTECT| (PROG1 (|IndexedString;| #1#) (LETT #2# T |IndexedString|)) (COND ((NOT #2#) (HREM |$ConstructorCache| (QUOTE |IndexedString|)))))))))))) 
+(DEFUN |ISTRING;hash;$I;32| (|s| $)
+  (PROG (|n|)
+    (RETURN
+      (SEQ (LETT |n| (QCSIZE |s|) |ISTRING;hash;$I;32|)
+           (EXIT (COND
+                   ((ZEROP |n|) 0)
+                   ((EQL |n| 1)
+                    (SPADCALL
+                        (SPADCALL |s| (QREFELT $ 6) (QREFELT $ 52))
+                        (QREFELT $ 67)))
+                   ('T
+                    (* (* (SPADCALL
+                              (SPADCALL |s| (QREFELT $ 6)
+                                  (QREFELT $ 52))
+                              (QREFELT $ 67))
+                          (SPADCALL
+                              (SPADCALL |s| (- (+ (QREFELT $ 6) |n|) 1)
+                                  (QREFELT $ 52))
+                              (QREFELT $ 67)))
+                       (SPADCALL
+                           (SPADCALL |s|
+                               (+ (QREFELT $ 6) (QUOTIENT2 |n| 2))
+                               (QREFELT $ 52))
+                           (QREFELT $ 67))))))))))
+
+(PUT '|ISTRING;match;2$CNni;33| '|SPADreplace| '|stringMatch|)
+
+(DEFUN |ISTRING;match;2$CNni;33| (|pattern| |target| |wildcard| $)
+  (|stringMatch| |pattern| |target| |wildcard|))
+
+(DEFUN |ISTRING;match?;2$CB;34| (|pattern| |target| |dontcare| $)
+  (PROG (|n| |m| G91514 G91516 |s| G91518 G91526 |i| |p|
+             G91519 |q|)
+    (RETURN
+      (SEQ (EXIT (SEQ (LETT |n| (SPADCALL |pattern| (QREFELT $ 42))
+                            |ISTRING;match?;2$CB;34|)
+                      (LETT |p|
+                            (PROG1 (LETT G91514
+                                    (SPADCALL |dontcare| |pattern|
+                                     (LETT |m|
+                                      (SPADCALL |pattern|
+                                       (QREFELT $ 28))
+                                      |ISTRING;match?;2$CB;34|)
+                                     (QREFELT $ 48))
+                                    |ISTRING;match?;2$CB;34|)
+                              (|check-subtype| (>= G91514 0)
+                                  '(|NonNegativeInteger|) G91514))
+                            |ISTRING;match?;2$CB;34|)
+                      (EXIT (COND
+                              ((EQL |p| (- |m| 1))
+                               (SPADCALL |pattern| |target|
+                                   (QREFELT $ 14)))
+                              ('T
+                               (SEQ (COND
+                                      ((NULL (EQL |p| |m|))
+                                       (COND
+                                         ((NULL
+                                           (SPADCALL
+                                            (SPADCALL |pattern|
+                                             (SPADCALL |m| (- |p| 1)
+                                              (QREFELT $ 20))
+                                             (QREFELT $ 21))
+                                            |target| (QREFELT $ 70)))
+                                          (EXIT 'NIL)))))
+                                    (LETT |i| |p|
+                                     |ISTRING;match?;2$CB;34|)
+                                    (LETT |q|
+                                     (PROG1
+                                      (LETT G91516
+                                       (SPADCALL |dontcare| |pattern|
+                                        (+ |p| 1) (QREFELT $ 48))
+                                       |ISTRING;match?;2$CB;34|)
+                                       (|check-subtype| (>= G91516 0)
+                                        '(|NonNegativeInteger|)
+                                        G91516))
+                                     |ISTRING;match?;2$CB;34|)
+                                    (SEQ G190
+                                     (COND
+                                       ((NULL
+                                         (COND
+                                           ((EQL |q| (- |m| 1)) 'NIL)
+                                           ('T 'T)))
+                                        (GO G191)))
+                                     (SEQ
+                                      (LETT |s|
+                                       (SPADCALL |pattern|
+                                        (SPADCALL (+ |p| 1) (- |q| 1)
+                                         (QREFELT $ 20))
+                                        (QREFELT $ 21))
+                                       |ISTRING;match?;2$CB;34|)
+                                      (LETT |i|
+                                       (PROG1
+                                        (LETT G91518
+                                         (SPADCALL |s| |target| |i|
+                                          (QREFELT $ 47))
+                                         |ISTRING;match?;2$CB;34|)
+                                         (|check-subtype|
+                                          (>= G91518 0)
+                                          '(|NonNegativeInteger|)
+                                          G91518))
+                                       |ISTRING;match?;2$CB;34|)
+                                      (EXIT
+                                       (COND
+                                         ((EQL |i| (- |m| 1))
+                                          (PROGN
+                                            (LETT G91526 'NIL
+                                             |ISTRING;match?;2$CB;34|)
+                                            (GO G91526)))
+                                         ('T
+                                          (SEQ
+                                           (LETT |i|
+                                            (+ |i|
+                                             (SPADCALL |s|
+                                              (QREFELT $ 13)))
+                                            |ISTRING;match?;2$CB;34|)
+                                           (LETT |p| |q|
+                                            |ISTRING;match?;2$CB;34|)
+                                           (EXIT
+                                            (LETT |q|
+                                             (PROG1
+                                              (LETT G91519
+                                               (SPADCALL |dontcare|
+                                                |pattern| (+ |q| 1)
+                                                (QREFELT $ 48))
+                                               |ISTRING;match?;2$CB;34|)
+                                               (|check-subtype|
+                                                (>= G91519 0)
+                                                '(|NonNegativeInteger|)
+                                                G91519))
+                                             |ISTRING;match?;2$CB;34|)))))))
+                                     NIL (GO G190) G191 (EXIT NIL))
+                                    (COND
+                                      ((NULL (EQL |p| |n|))
+                                       (COND
+                                         ((NULL
+                                           (SPADCALL
+                                            (SPADCALL |pattern|
+                                             (SPADCALL (+ |p| 1) |n|
+                                              (QREFELT $ 20))
+                                             (QREFELT $ 21))
+                                            |target| (QREFELT $ 51)))
+                                          (EXIT 'NIL)))))
+                                    (EXIT 'T)))))))
+           G91526 (EXIT G91526)))))
+
+(DEFUN |IndexedString| (G91535)
+  (PROG ()
+    (RETURN
+      (PROG (G91536)
+        (RETURN
+          (COND
+            ((LETT G91536
+                   (|lassocShiftWithFunction|
+                       (LIST (|devaluate| G91535))
+                       (HGET |$ConstructorCache| '|IndexedString|)
+                       '|domainEqualList|)
+                   |IndexedString|)
+             (|CDRwithIncrement| G91536))
+            ('T
+             (UNWIND-PROTECT
+               (PROG1 (|IndexedString;| G91535)
+                 (LETT G91536 T |IndexedString|))
+               (COND
+                 ((NOT G91536)
+                  (HREM |$ConstructorCache| '|IndexedString|)))))))))))
 
-(DEFUN |IndexedString;| (|#1|) (PROG (|DV$1| |dv$| |$| #1=#:G91534 #2=#:G91533 |pv$|) (RETURN (PROGN (LETT |DV$1| (|devaluate| |#1|) . #3=(|IndexedString|)) (LETT |dv$| (LIST (QUOTE |IndexedString|) |DV$1|) . #3#) (LETT |$| (GETREFV 83) . #3#) (QSETREFV |$| 0 |dv$|) (QSETREFV |$| 3 (LETT |pv$| (|buildPredVector| 0 0 (LIST (|HasCategory| (|Character|) (QUOTE (|SetCategory|))) (|HasCategory| (|Character|) (QUOTE (|ConvertibleTo| (|InputForm|)))) (LETT #1# (|HasCategory| (|Character|) (QUOTE (|OrderedSet|))) . #3#) (OR #1# (|HasCategory| (|Character|) (QUOTE (|SetCategory|)))) (|HasCategory| (|Integer|) (QUOTE (|OrderedSet|))) (LETT #2# (AND (|HasCategory| (|Character|) (QUOTE (|Evalable| (|Character|)))) (|HasCategory| (|Character|) (QUOTE (|SetCategory|)))) . #3#) (OR (AND (|HasCategory| (|Character|) (QUOTE (|Evalable| (|Character|)))) #1#) #2#))) . #3#)) (|haddProp| |$ConstructorCache| (QUOTE |IndexedString|) (LIST |DV$1|) (CONS 1 |$|)) (|stuffDomainSlots| |$|) (QSETREFV |$| 6 |#1|) |$|)))) 
+(DEFUN |IndexedString;| (|#1|)
+  (PROG (DV$1 |dv$| $ G91534 G91533 |pv$|)
+    (RETURN
+      (PROGN
+        (LETT DV$1 (|devaluate| |#1|) |IndexedString|)
+        (LETT |dv$| (LIST '|IndexedString| DV$1) |IndexedString|)
+        (LETT $ (GETREFV 83) |IndexedString|)
+        (QSETREFV $ 0 |dv$|)
+        (QSETREFV $ 3
+            (LETT |pv$|
+                  (|buildPredVector| 0 0
+                      (LIST (|HasCategory| (|Character|)
+                                '(|SetCategory|))
+                            (|HasCategory| (|Character|)
+                                '(|ConvertibleTo| (|InputForm|)))
+                            (LETT G91534
+                                  (|HasCategory| (|Character|)
+                                      '(|OrderedSet|))
+                                  |IndexedString|)
+                            (OR G91534
+                                (|HasCategory| (|Character|)
+                                    '(|SetCategory|)))
+                            (|HasCategory| (|Integer|) '(|OrderedSet|))
+                            (LETT G91533
+                                  (AND (|HasCategory| (|Character|)
+                                        '(|Evalable| (|Character|)))
+                                       (|HasCategory| (|Character|)
+                                        '(|SetCategory|)))
+                                  |IndexedString|)
+                            (OR (AND (|HasCategory| (|Character|)
+                                      '(|Evalable| (|Character|)))
+                                     G91534)
+                                G91533)))
+                  |IndexedString|))
+        (|haddProp| |$ConstructorCache| '|IndexedString| (LIST DV$1)
+            (CONS 1 $))
+        (|stuffDomainSlots| $)
+        (QSETREFV $ 6 |#1|)
+        $))))
+
+(MAKEPROP '|IndexedString| '|infovec|
+    (LIST '#(NIL NIL NIL NIL NIL NIL (|local| |#1|)
+             (|NonNegativeInteger|) (|Character|) |ISTRING;new;NniC$;1|
+             |ISTRING;empty;$;2| (|Boolean|) |ISTRING;empty?;$B;3|
+             |ISTRING;#;$Nni;4| |ISTRING;=;2$B;5| |ISTRING;<;2$B;6|
+             |ISTRING;concat;3$;7| |ISTRING;copy;2$;8| (|Integer|)
+             (|UniversalSegment| 18) (0 . SEGMENT)
+             |ISTRING;elt;$Us$;31| (6 . SEGMENT)
+             |ISTRING;insert;2$I$;9| (|String|) (|OutputForm|)
+             (11 . |outputForm|) |ISTRING;coerce;$Of;10|
+             |ISTRING;minIndex;$I;11| (|CharacterClass|)
+             (16 . |upperCase|) (20 . |upperCase|) (|Mapping| 8 8)
+             (25 . |map!|) |ISTRING;upperCase!;2$;12|
+             (31 . |lowerCase|) (35 . |lowerCase|)
+             |ISTRING;lowerCase!;2$;13| |ISTRING;latex;$S;14|
+             (40 . |lo|) (45 . |hasHi|) (50 . |hi|) (55 . |maxIndex|)
+             (60 . |space|) |ISTRING;replace;$Us2$;15|
+             |ISTRING;setelt;$I2C;16| |ISTRING;substring?;2$IB;17|
+             |ISTRING;position;2$2I;18| |ISTRING;position;C$2I;19|
+             (64 . |member?|) |ISTRING;position;Cc$2I;20|
+             |ISTRING;suffix?;2$B;21| |ISTRING;elt;$IC;30| (70 . =)
+             (|List| $$) (76 . |empty|) (80 . |concat|)
+             (86 . |reverse!|) (|List| $) |ISTRING;split;$CL;22|
+             |ISTRING;split;$CcL;23| |ISTRING;leftTrim;$C$;24|
+             |ISTRING;leftTrim;$Cc$;25| |ISTRING;rightTrim;$C$;26|
+             |ISTRING;rightTrim;$Cc$;27| |ISTRING;copyInto!;2$I$;29|
+             |ISTRING;concat;L$;28| (91 . |ord|) |ISTRING;hash;$I;32|
+             |ISTRING;match;2$CNni;33| (96 . |prefix?|)
+             |ISTRING;match?;2$CB;34| (|List| 8) (|List| 74)
+             (|Equation| 8) (|Mapping| 8 8 8) (|InputForm|)
+             (|SingleInteger|) (|Mapping| 11 8) (|Mapping| 11 8 8)
+             (|Void|) (|Union| 8 '"failed") (|List| 18))
+          '#(~= 102 |upperCase!| 108 |upperCase| 113 |trim| 118 |swap!|
+             130 |suffix?| 137 |substring?| 143 |split| 150 |sorted?|
+             162 |sort!| 173 |sort| 184 |size?| 195 |setelt| 201
+             |select| 215 |sample| 221 |rightTrim| 225 |reverse!| 237
+             |reverse| 242 |replace| 247 |removeDuplicates| 254
+             |remove| 259 |reduce| 271 |qsetelt!| 292 |qelt| 299
+             |prefix?| 305 |position| 311 |parts| 344 |new| 349 |more?|
+             355 |minIndex| 361 |min| 366 |merge| 372 |members| 385
+             |member?| 390 |maxIndex| 396 |max| 401 |match?| 407
+             |match| 414 |map!| 421 |map| 427 |lowerCase!| 440
+             |lowerCase| 445 |less?| 450 |leftTrim| 456 |latex| 468
+             |insert| 473 |indices| 487 |index?| 492 |hash| 498 |first|
+             508 |find| 513 |fill!| 519 |every?| 525 |eval| 531 |eq?|
+             557 |entry?| 563 |entries| 569 |empty?| 574 |empty| 579
+             |elt| 583 |delete| 608 |count| 620 |copyInto!| 632 |copy|
+             639 |convert| 644 |construct| 649 |concat| 654 |coerce|
+             677 |any?| 687 >= 693 > 699 = 705 <= 711 < 717 |#| 723)
+          '((|shallowlyMutable| . 0) (|finiteAggregate| . 0))
+          (CONS (|makeByteWordVec2| 7
+                    '(0 0 0 0 0 0 0 3 0 0 7 4 0 0 7 1 2 4))
+                (CONS '#(|StringAggregate&|
+                         |OneDimensionalArrayAggregate&|
+                         |FiniteLinearAggregate&| |LinearAggregate&|
+                         |IndexedAggregate&| |Collection&|
+                         |HomogeneousAggregate&| |OrderedSet&|
+                         |Aggregate&| |EltableAggregate&| |Evalable&|
+                         |SetCategory&| NIL NIL |InnerEvalable&| NIL
+                         NIL |BasicType&|)
+                      (CONS '#((|StringAggregate|)
+                               (|OneDimensionalArrayAggregate| 8)
+                               (|FiniteLinearAggregate| 8)
+                               (|LinearAggregate| 8)
+                               (|IndexedAggregate| 18 8)
+                               (|Collection| 8)
+                               (|HomogeneousAggregate| 8)
+                               (|OrderedSet|) (|Aggregate|)
+                               (|EltableAggregate| 18 8) (|Evalable| 8)
+                               (|SetCategory|) (|Type|)
+                               (|Eltable| 18 8) (|InnerEvalable| 8 8)
+                               (|CoercibleTo| 25) (|ConvertibleTo| 76)
+                               (|BasicType|))
+                            (|makeByteWordVec2| 82
+                                '(2 19 0 18 18 20 1 19 0 18 22 1 25 0
+                                  24 26 0 29 0 30 1 8 0 0 31 2 0 0 32 0
+                                  33 0 29 0 35 1 8 0 0 36 1 19 18 0 39
+                                  1 19 11 0 40 1 19 18 0 41 1 0 18 0 42
+                                  0 8 0 43 2 29 11 8 0 49 2 8 11 0 0 53
+                                  0 54 0 55 2 54 0 2 0 56 1 54 0 0 57 1
+                                  8 18 0 67 2 0 11 0 0 70 2 1 11 0 0 1
+                                  1 0 0 0 34 1 0 0 0 1 2 0 0 0 8 1 2 0
+                                  0 0 29 1 3 0 80 0 18 18 1 2 0 11 0 0
+                                  51 3 0 11 0 0 18 46 2 0 58 0 29 60 2
+                                  0 58 0 8 59 1 3 11 0 1 2 0 11 79 0 1
+                                  1 3 0 0 1 2 0 0 79 0 1 1 3 0 0 1 2 0
+                                  0 79 0 1 2 0 11 0 7 1 3 0 8 0 19 8 1
+                                  3 0 8 0 18 8 45 2 0 0 78 0 1 0 0 0 1
+                                  2 0 0 0 8 63 2 0 0 0 29 64 1 0 0 0 1
+                                  1 0 0 0 1 3 0 0 0 19 0 44 1 1 0 0 1 2
+                                  1 0 8 0 1 2 0 0 78 0 1 4 1 8 75 0 8 8
+                                  1 3 0 8 75 0 8 1 2 0 8 75 0 1 3 0 8 0
+                                  18 8 1 2 0 8 0 18 1 2 0 11 0 0 70 3 1
+                                  18 8 0 18 48 2 1 18 8 0 1 3 0 18 29 0
+                                  18 50 3 0 18 0 0 18 47 2 0 18 78 0 1
+                                  1 0 72 0 1 2 0 0 7 8 9 2 0 11 0 7 1 1
+                                  5 18 0 28 2 3 0 0 0 1 2 3 0 0 0 1 3 0
+                                  0 79 0 0 1 1 0 72 0 1 2 1 11 8 0 1 1
+                                  5 18 0 42 2 3 0 0 0 1 3 0 11 0 0 8 71
+                                  3 0 7 0 0 8 69 2 0 0 32 0 33 3 0 0 75
+                                  0 0 1 2 0 0 32 0 1 1 0 0 0 37 1 0 0 0
+                                  1 2 0 11 0 7 1 2 0 0 0 8 61 2 0 0 0
+                                  29 62 1 1 24 0 38 3 0 0 8 0 18 1 3 0
+                                  0 0 0 18 23 1 0 82 0 1 2 0 11 18 0 1
+                                  1 1 77 0 1 1 0 18 0 68 1 5 8 0 1 2 0
+                                  81 78 0 1 2 0 0 0 8 1 2 0 11 78 0 1 3
+                                  6 0 0 72 72 1 3 6 0 0 8 8 1 2 6 0 0
+                                  73 1 2 6 0 0 74 1 2 0 11 0 0 1 2 1 11
+                                  8 0 1 1 0 72 0 1 1 0 11 0 12 0 0 0 10
+                                  2 0 0 0 0 1 2 0 0 0 19 21 2 0 8 0 18
+                                  52 3 0 8 0 18 8 1 2 0 0 0 18 1 2 0 0
+                                  0 19 1 2 1 7 8 0 1 2 0 7 78 0 1 3 0 0
+                                  0 0 18 65 1 0 0 0 17 1 2 76 0 1 1 0 0
+                                  72 1 1 0 0 58 66 2 0 0 0 0 16 2 0 0 0
+                                  8 1 2 0 0 8 0 1 1 1 25 0 27 1 0 0 8 1
+                                  2 0 11 78 0 1 2 3 11 0 0 1 2 3 11 0 0
+                                  1 2 1 11 0 0 14 2 3 11 0 0 1 2 3 11 0
+                                  0 15 1 0 7 0 13)))))
+          '|lookupComplete|))
 
-(MAKEPROP (QUOTE |IndexedString|) (QUOTE |infovec|) (LIST (QUOTE #(NIL NIL NIL NIL NIL NIL (|local| |#1|) (|NonNegativeInteger|) (|Character|) |ISTRING;new;NniC$;1| |ISTRING;empty;$;2| (|Boolean|) |ISTRING;empty?;$B;3| |ISTRING;#;$Nni;4| |ISTRING;=;2$B;5| |ISTRING;<;2$B;6| |ISTRING;concat;3$;7| |ISTRING;copy;2$;8| (|Integer|) (|UniversalSegment| 18) (0 . SEGMENT) |ISTRING;elt;$Us$;31| (6 . SEGMENT) |ISTRING;insert;2$I$;9| (|String|) (|OutputForm|) (11 . |outputForm|) |ISTRING;coerce;$Of;10| |ISTRING;minIndex;$I;11| (|CharacterClass|) (16 . |upperCase|) (20 . |upperCase|) (|Mapping| 8 8) (25 . |map!|) |ISTRING;upperCase!;2$;12| (31 . |lowerCase|) (35 . |lowerCase|) |ISTRING;lowerCase!;2$;13| |ISTRING;latex;$S;14| (40 . |lo|) (45 . |hasHi|) (50 . |hi|) (55 . |maxIndex|) (60 . |space|) |ISTRING;replace;$Us2$;15| |ISTRING;setelt;$I2C;16| |ISTRING;substring?;2$IB;17| |ISTRING;position;2$2I;18| |ISTRING;position;C$2I;19| (64 . |member?|) |ISTRING;position;Cc$2I;20| |ISTRING;suffix?;2$B;21| |ISTRING;elt;$IC;30| (70 . |=|) (|List| |$$|) (76 . |empty|) (80 . |concat|) (86 . |reverse!|) (|List| |$|) |ISTRING;split;$CL;22| |ISTRING;split;$CcL;23| |ISTRING;leftTrim;$C$;24| |ISTRING;leftTrim;$Cc$;25| |ISTRING;rightTrim;$C$;26| |ISTRING;rightTrim;$Cc$;27| |ISTRING;copyInto!;2$I$;29| |ISTRING;concat;L$;28| (91 . |ord|) |ISTRING;hash;$I;32| |ISTRING;match;2$CNni;33| (96 . |prefix?|) |ISTRING;match?;2$CB;34| (|List| 8) (|List| 74) (|Equation| 8) (|Mapping| 8 8 8) (|InputForm|) (|SingleInteger|) (|Mapping| 11 8) (|Mapping| 11 8 8) (|Void|) (|Union| 8 (QUOTE "failed")) (|List| 18))) (QUOTE #(|~=| 102 |upperCase!| 108 |upperCase| 113 |trim| 118 |swap!| 130 |suffix?| 137 |substring?| 143 |split| 150 |sorted?| 162 |sort!| 173 |sort| 184 |size?| 195 |setelt| 201 |select| 215 |sample| 221 |rightTrim| 225 |reverse!| 237 |reverse| 242 |replace| 247 |removeDuplicates| 254 |remove| 259 |reduce| 271 |qsetelt!| 292 |qelt| 299 |prefix?| 305 |position| 311 |parts| 344 |new| 349 |more?| 355 |minIndex| 361 |min| 366 |merge| 372 |members| 385 |member?| 390 |maxIndex| 396 |max| 401 |match?| 407 |match| 414 |map!| 421 |map| 427 |lowerCase!| 440 |lowerCase| 445 |less?| 450 |leftTrim| 456 |latex| 468 |insert| 473 |indices| 487 |index?| 492 |hash| 498 |first| 508 |find| 513 |fill!| 519 |every?| 525 |eval| 531 |eq?| 557 |entry?| 563 |entries| 569 |empty?| 574 |empty| 579 |elt| 583 |delete| 608 |count| 620 |copyInto!| 632 |copy| 639 |convert| 644 |construct| 649 |concat| 654 |coerce| 677 |any?| 687 |>=| 693 |>| 699 |=| 705 |<=| 711 |<| 717 |#| 723)) (QUOTE ((|shallowlyMutable| . 0) (|finiteAggregate| . 0))) (CONS (|makeByteWordVec2| 7 (QUOTE (0 0 0 0 0 0 0 3 0 0 7 4 0 0 7 1 2 4))) (CONS (QUOTE #(|StringAggregate&| |OneDimensionalArrayAggregate&| |FiniteLinearAggregate&| |LinearAggregate&| |IndexedAggregate&| |Collection&| |HomogeneousAggregate&| |OrderedSet&| |Aggregate&| |EltableAggregate&| |Evalable&| |SetCategory&| NIL NIL |InnerEvalable&| NIL NIL |BasicType&|)) (CONS (QUOTE #((|StringAggregate|) (|OneDimensionalArrayAggregate| 8) (|FiniteLinearAggregate| 8) (|LinearAggregate| 8) (|IndexedAggregate| 18 8) (|Collection| 8) (|HomogeneousAggregate| 8) (|OrderedSet|) (|Aggregate|) (|EltableAggregate| 18 8) (|Evalable| 8) (|SetCategory|) (|Type|) (|Eltable| 18 8) (|InnerEvalable| 8 8) (|CoercibleTo| 25) (|ConvertibleTo| 76) (|BasicType|))) (|makeByteWordVec2| 82 (QUOTE (2 19 0 18 18 20 1 19 0 18 22 1 25 0 24 26 0 29 0 30 1 8 0 0 31 2 0 0 32 0 33 0 29 0 35 1 8 0 0 36 1 19 18 0 39 1 19 11 0 40 1 19 18 0 41 1 0 18 0 42 0 8 0 43 2 29 11 8 0 49 2 8 11 0 0 53 0 54 0 55 2 54 0 2 0 56 1 54 0 0 57 1 8 18 0 67 2 0 11 0 0 70 2 1 11 0 0 1 1 0 0 0 34 1 0 0 0 1 2 0 0 0 8 1 2 0 0 0 29 1 3 0 80 0 18 18 1 2 0 11 0 0 51 3 0 11 0 0 18 46 2 0 58 0 29 60 2 0 58 0 8 59 1 3 11 0 1 2 0 11 79 0 1 1 3 0 0 1 2 0 0 79 0 1 1 3 0 0 1 2 0 0 79 0 1 2 0 11 0 7 1 3 0 8 0 19 8 1 3 0 8 0 18 8 45 2 0 0 78 0 1 0 0 0 1 2 0 0 0 8 63 2 0 0 0 29 64 1 0 0 0 1 1 0 0 0 1 3 0 0 0 19 0 44 1 1 0 0 1 2 1 0 8 0 1 2 0 0 78 0 1 4 1 8 75 0 8 8 1 3 0 8 75 0 8 1 2 0 8 75 0 1 3 0 8 0 18 8 1 2 0 8 0 18 1 2 0 11 0 0 70 3 1 18 8 0 18 48 2 1 18 8 0 1 3 0 18 29 0 18 50 3 0 18 0 0 18 47 2 0 18 78 0 1 1 0 72 0 1 2 0 0 7 8 9 2 0 11 0 7 1 1 5 18 0 28 2 3 0 0 0 1 2 3 0 0 0 1 3 0 0 79 0 0 1 1 0 72 0 1 2 1 11 8 0 1 1 5 18 0 42 2 3 0 0 0 1 3 0 11 0 0 8 71 3 0 7 0 0 8 69 2 0 0 32 0 33 3 0 0 75 0 0 1 2 0 0 32 0 1 1 0 0 0 37 1 0 0 0 1 2 0 11 0 7 1 2 0 0 0 8 61 2 0 0 0 29 62 1 1 24 0 38 3 0 0 8 0 18 1 3 0 0 0 0 18 23 1 0 82 0 1 2 0 11 18 0 1 1 1 77 0 1 1 0 18 0 68 1 5 8 0 1 2 0 81 78 0 1 2 0 0 0 8 1 2 0 11 78 0 1 3 6 0 0 72 72 1 3 6 0 0 8 8 1 2 6 0 0 73 1 2 6 0 0 74 1 2 0 11 0 0 1 2 1 11 8 0 1 1 0 72 0 1 1 0 11 0 12 0 0 0 10 2 0 0 0 0 1 2 0 0 0 19 21 2 0 8 0 18 52 3 0 8 0 18 8 1 2 0 0 0 18 1 2 0 0 0 19 1 2 1 7 8 0 1 2 0 7 78 0 1 3 0 0 0 0 18 65 1 0 0 0 17 1 2 76 0 1 1 0 0 72 1 1 0 0 58 66 2 0 0 0 0 16 2 0 0 0 8 1 2 0 0 8 0 1 1 1 25 0 27 1 0 0 8 1 2 0 11 78 0 1 2 3 11 0 0 1 2 3 11 0 0 1 2 1 11 0 0 14 2 3 11 0 0 1 2 3 11 0 0 15 1 0 7 0 13)))))) (QUOTE |lookupComplete|))) 
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{LIST.lsp BOOTSTRAP} 
@@ -117648,106 +118471,119 @@ Note that this code is not included in the generated catdef.spad file.
      (EXIT NIL))
     (EXIT |lu|))))) 
 
-(DEFUN |LIST;convert;$If;13| (|x| |$|)
- (PROG (#1=#:G102544 |a| #2=#:G102545)
-  (RETURN
-   (SEQ
-    (SPADCALL
-     (CONS
-      (SPADCALL (SPADCALL "construct" (QREFELT |$| 38)) (QREFELT |$| 40))
-      (PROGN
-       (LETT #1# NIL |LIST;convert;$If;13|)
-       (SEQ
-        (LETT |a| NIL |LIST;convert;$If;13|)
-        (LETT #2# |x| |LIST;convert;$If;13|)
-        G190
-        (COND
-         ((OR 
-           (ATOM #2#)
-           (PROGN (LETT |a| (CAR #2#) |LIST;convert;$If;13|) NIL))
-          (GO G191)))
-        (SEQ
-         (EXIT
-          (LETT #1# 
-           (CONS (SPADCALL |a| (QREFELT |$| 41)) #1#)
-           |LIST;convert;$If;13|)))
-        (LETT #2# (CDR #2#) |LIST;convert;$If;13|)
-        (GO G190)
-        G191
-        (EXIT (NREVERSE0 #1#)))))
-     (QREFELT |$| 43)))))) 
-
-(DEFUN |List| (#1=#:G102555)
- (PROG NIL
-  (RETURN
-   (PROG (#2=#:G102556)
+(DEFUN |LIST;convert;$If;13| (|x| $)
+  (PROG (G102544 |a| G102545)
     (RETURN
-     (COND
-      ((LETT #2#
-        (|lassocShiftWithFunction|
-         (LIST (|devaluate| #1#))
-         (HGET |$ConstructorCache| (QUOTE |List|))
-         (QUOTE |domainEqualList|))
-        |List|)
-       (|CDRwithIncrement| #2#))
-      ((QUOTE T)
-       (|UNWIND-PROTECT|
-        (PROG1 (|List;| #1#) (LETT #2# T |List|))
-        (COND ((NOT #2#) (HREM |$ConstructorCache| (QUOTE |List|)))))))))))) 
+      (SEQ (SPADCALL
+               (CONS (SPADCALL (SPADCALL "construct" (QREFELT $ 38))
+                         (QREFELT $ 40))
+                     (PROGN
+                       (LETT G102544 NIL |LIST;convert;$If;13|)
+                       (SEQ (LETT |a| NIL |LIST;convert;$If;13|)
+                            (LETT G102545 |x| |LIST;convert;$If;13|)
+                            G190
+                            (COND
+                              ((OR (ATOM G102545)
+                                   (PROGN
+                                     (LETT |a| (CAR G102545)
+                                      |LIST;convert;$If;13|)
+                                     NIL))
+                               (GO G191)))
+                            (SEQ (EXIT (LETT G102544
+                                        (CONS
+                                         (SPADCALL |a| (QREFELT $ 41))
+                                         G102544)
+                                        |LIST;convert;$If;13|)))
+                            (LETT G102545 (CDR G102545)
+                                  |LIST;convert;$If;13|)
+                            (GO G190) G191 (EXIT (NREVERSE0 G102544)))))
+               (QREFELT $ 43))))))
+
+(DEFUN |List| (G102555)
+  (PROG ()
+    (RETURN
+      (PROG (G102556)
+        (RETURN
+          (COND
+            ((LETT G102556
+                   (|lassocShiftWithFunction|
+                       (LIST (|devaluate| G102555))
+                       (HGET |$ConstructorCache| '|List|)
+                       '|domainEqualList|)
+                   |List|)
+             (|CDRwithIncrement| G102556))
+            ('T
+             (UNWIND-PROTECT
+               (PROG1 (|List;| G102555) (LETT G102556 T |List|))
+               (COND
+                 ((NOT G102556) (HREM |$ConstructorCache| '|List|)))))))))))
 
 (DEFUN |List;| (|#1|)
- (PROG (|DV$1| |dv$| |$| #1=#:G102554 |pv$|)
-  (RETURN
-   (PROGN
-    (LETT |DV$1| (|devaluate| |#1|) . #2=(|List|))
-    (LETT |dv$| (LIST (QUOTE |List|) |DV$1|) . #2#)
-    (LETT |$| (GETREFV 62) . #2#)
-    (QSETREFV |$| 0 |dv$|)
-    (QSETREFV |$| 3 
-     (LETT |pv$| 
-      (|buildPredVector| 0 0 
-       (LIST 
-        (|HasCategory| |#1| (QUOTE (|SetCategory|)))
-        (|HasCategory| |#1| (QUOTE (|ConvertibleTo| (|InputForm|))))
-        (LETT #1# (|HasCategory| |#1| (QUOTE (|OrderedSet|))) . #2#)
-        (OR #1# (|HasCategory| |#1| (QUOTE (|SetCategory|))))
-        (|HasCategory| |#1| (QUOTE (|OpenMath|)))
-        (|HasCategory| (|Integer|) (QUOTE (|OrderedSet|)))
-        (AND 
-         (|HasCategory| |#1| (LIST (QUOTE |Evalable|) (|devaluate| |#1|)))
-         (|HasCategory| |#1| (QUOTE (|SetCategory|))))
-        (OR 
-         (AND
-          (|HasCategory| |#1| (LIST (QUOTE |Evalable|) (|devaluate| |#1|)))
-          #1#)
-         (AND
-          (|HasCategory| |#1| (LIST (QUOTE |Evalable|) (|devaluate| |#1|)))
-          (|HasCategory| |#1| (QUOTE (|SetCategory|)))))))
-      . #2#))
-    (|haddProp| |$ConstructorCache| (QUOTE |List|) (LIST |DV$1|) (CONS 1 |$|))
-    (|stuffDomainSlots| |$|)
-    (QSETREFV |$| 6 |#1|)
-    (COND
-     ((|testBitVector| |pv$| 5)
+  (PROG (DV$1 |dv$| $ G102554 |pv$|)
+    (RETURN
       (PROGN
-       (QSETREFV |$| 25 (CONS (|dispatchFunction| |LIST;OMwrite;$S;6|) |$|))
-       (QSETREFV |$| 26 (CONS (|dispatchFunction| |LIST;OMwrite;$BS;7|) |$|))
-       (QSETREFV |$| 27 (CONS (|dispatchFunction| |LIST;OMwrite;Omd$V;8|) |$|))
-       (QSETREFV |$| 28 
-        (CONS (|dispatchFunction| |LIST;OMwrite;Omd$BV;9|) |$|)))))
-    (COND 
-     ((|testBitVector| |pv$| 1)
-      (PROGN 
-       (QSETREFV |$| 31 
-        (CONS (|dispatchFunction| |LIST;setUnion;3$;10|) |$|))
-       (QSETREFV |$| 33 
-        (CONS (|dispatchFunction| |LIST;setIntersection;3$;11|) |$|))
-       (QSETREFV |$| 36 
-        (CONS (|dispatchFunction| |LIST;setDifference;3$;12|) |$|)))))
-    (COND
-     ((|testBitVector| |pv$| 2)
-      (QSETREFV |$| 44 (CONS (|dispatchFunction| |LIST;convert;$If;13|) |$|))))
-    |$|)))) 
+        (LETT DV$1 (|devaluate| |#1|) |List|)
+        (LETT |dv$| (LIST '|List| DV$1) |List|)
+        (LETT $ (GETREFV 62) |List|)
+        (QSETREFV $ 0 |dv$|)
+        (QSETREFV $ 3
+            (LETT |pv$|
+                  (|buildPredVector| 0 0
+                      (LIST (|HasCategory| |#1| '(|SetCategory|))
+                            (|HasCategory| |#1|
+                                '(|ConvertibleTo| (|InputForm|)))
+                            (LETT G102554
+                                  (|HasCategory| |#1| '(|OrderedSet|))
+                                  |List|)
+                            (OR G102554
+                                (|HasCategory| |#1| '(|SetCategory|)))
+                            (|HasCategory| |#1| '(|OpenMath|))
+                            (|HasCategory| (|Integer|) '(|OrderedSet|))
+                            (AND (|HasCategory| |#1|
+                                     (LIST '|Evalable|
+                                      (|devaluate| |#1|)))
+                                 (|HasCategory| |#1| '(|SetCategory|)))
+                            (OR (AND (|HasCategory| |#1|
+                                      (LIST '|Evalable|
+                                       (|devaluate| |#1|)))
+                                     G102554)
+                                (AND (|HasCategory| |#1|
+                                      (LIST '|Evalable|
+                                       (|devaluate| |#1|)))
+                                     (|HasCategory| |#1|
+                                      '(|SetCategory|))))))
+                  |List|))
+        (|haddProp| |$ConstructorCache| '|List| (LIST DV$1) (CONS 1 $))
+        (|stuffDomainSlots| $)
+        (QSETREFV $ 6 |#1|)
+        (COND
+          ((|testBitVector| |pv$| 5)
+           (PROGN
+             (QSETREFV $ 25
+                 (CONS (|dispatchFunction| |LIST;OMwrite;$S;6|) $))
+             (QSETREFV $ 26
+                 (CONS (|dispatchFunction| |LIST;OMwrite;$BS;7|) $))
+             (QSETREFV $ 27
+                 (CONS (|dispatchFunction| |LIST;OMwrite;Omd$V;8|) $))
+             (QSETREFV $ 28
+                 (CONS (|dispatchFunction| |LIST;OMwrite;Omd$BV;9|) $)))))
+        (COND
+          ((|testBitVector| |pv$| 1)
+           (PROGN
+             (QSETREFV $ 31
+                 (CONS (|dispatchFunction| |LIST;setUnion;3$;10|) $))
+             (QSETREFV $ 33
+                 (CONS (|dispatchFunction|
+                           |LIST;setIntersection;3$;11|)
+                       $))
+             (QSETREFV $ 36
+                 (CONS (|dispatchFunction| |LIST;setDifference;3$;12|)
+                       $)))))
+        (COND
+          ((|testBitVector| |pv$| 2)
+           (QSETREFV $ 44
+               (CONS (|dispatchFunction| |LIST;convert;$If;13|) $))))
+        $))))
 
 (MAKEPROP
  (QUOTE |List|)
@@ -117818,32 +118654,21 @@ Note that this code is not included in the generated catdef.spad file.
 
 (|/VERSIONCHECK| 2) 
 
-(SETQ |$CategoryFrame| 
-  (|put| 
-    #1=(QUOTE |NonNegativeInteger|) 
-   (QUOTE |SuperDomain|) 
-   #2=(QUOTE (|Integer|)) 
-  (|put| 
-    #2# 
-    #3=(QUOTE |SubDomain|) 
-    (CONS 
-      (QUOTE 
-        (|NonNegativeInteger| 
-          COND ((|<| |#1| 0) (QUOTE NIL)) ((QUOTE T) (QUOTE T))))
-      (DELASC #1# (|get| #2# #3# |$CategoryFrame|)))
-   |$CategoryFrame|))) 
+(SETQ |$CategoryFrame|
+      (|put| '|NonNegativeInteger| '|SuperDomain| '(|Integer|)
+             (|put| '(|Integer|) '|SubDomain|
+                    (CONS '(|NonNegativeInteger| COND ((< |#1| 0) 'NIL)
+                               ('T 'T))
+                          (DELASC '|NonNegativeInteger|
+                                  (|get| '(|Integer|) '|SubDomain|
+                                         |$CategoryFrame|)))
+                    |$CategoryFrame|)))
 
-(PUT 
-  (QUOTE |NNI;sup;3$;1|) 
-  (QUOTE |SPADreplace|) 
-  (QUOTE MAX)) 
+(PUT '|NNI;sup;3$;1| '|SPADreplace| 'MAX)
 
 (DEFUN |NNI;sup;3$;1| (|x| |y| |$|) (MAX |x| |y|)) 
 
-(PUT 
-  (QUOTE |NNI;shift;$I$;2|) 
-  (QUOTE |SPADreplace|) 
-  (QUOTE ASH)) 
+(PUT '|NNI;shift;$I$;2| '|SPADreplace| 'ASH)
 
 (DEFUN |NNI;shift;$I$;2| (|x| |n| |$|) (ASH |x| |n|)) 
 
@@ -117857,45 +118682,42 @@ Note that this code is not included in the generated catdef.spad file.
             ((|<| |c| 0) (CONS 1 "failed"))
             ((QUOTE T) (CONS 0 |c|)))))))) 
 
-(DEFUN |NonNegativeInteger| NIL 
-  (PROG NIL 
-    (RETURN 
-      (PROG (#1=#:G96708) 
-        (RETURN 
-          (COND 
-            ((LETT #1# 
-                (HGET |$ConstructorCache| (QUOTE |NonNegativeInteger|))
-                |NonNegativeInteger|)
-              (|CDRwithIncrement| (CDAR #1#)))
-            ((QUOTE T) 
-              (|UNWIND-PROTECT| 
-                (PROG1 
-                  (CDDAR 
-                    (HPUT 
-                       |$ConstructorCache| 
-                       (QUOTE |NonNegativeInteger|) 
-                       (LIST (CONS NIL (CONS 1 (|NonNegativeInteger;|))))))
-                  (LETT #1# T |NonNegativeInteger|))
-                (COND 
-                  ((NOT #1#) 
-                    (HREM 
-                      |$ConstructorCache| 
-                      (QUOTE |NonNegativeInteger|)))))))))))) 
-
-(DEFUN |NonNegativeInteger;| NIL 
-  (PROG (|dv$| |$| |pv$|) 
-    (RETURN 
-      (PROGN 
-        (LETT |dv$| (QUOTE (|NonNegativeInteger|)) . #1=(|NonNegativeInteger|))
-        (LETT |$| (GETREFV 17) . #1#)
-        (QSETREFV |$| 0 |dv$|)
-        (QSETREFV |$| 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#))
-        (|haddProp| 
-           |$ConstructorCache| 
-           (QUOTE |NonNegativeInteger|) 
-           NIL 
-           (CONS 1 |$|))
-        (|stuffDomainSlots| |$|) |$|)))) 
+(DEFUN |NonNegativeInteger| ()
+  (PROG ()
+    (RETURN
+      (PROG (G96708)
+        (RETURN
+          (COND
+            ((LETT G96708
+                   (HGET |$ConstructorCache| '|NonNegativeInteger|)
+                   |NonNegativeInteger|)
+             (|CDRwithIncrement| (CDAR G96708)))
+            ('T
+             (UNWIND-PROTECT
+               (PROG1 (CDDAR (HPUT |$ConstructorCache|
+                                   '|NonNegativeInteger|
+                                   (LIST
+                                    (CONS NIL
+                                     (CONS 1 (|NonNegativeInteger;|))))))
+                 (LETT G96708 T |NonNegativeInteger|))
+               (COND
+                 ((NOT G96708)
+                  (HREM |$ConstructorCache| '|NonNegativeInteger|)))))))))))
+
+(DEFUN |NonNegativeInteger;| ()
+  (PROG (|dv$| $ |pv$|)
+    (RETURN
+      (PROGN
+        (LETT |dv$| '(|NonNegativeInteger|) |NonNegativeInteger|)
+        (LETT $ (GETREFV 17) |NonNegativeInteger|)
+        (QSETREFV $ 0 |dv$|)
+        (QSETREFV $ 3
+            (LETT |pv$| (|buildPredVector| 0 0 NIL)
+                  |NonNegativeInteger|))
+        (|haddProp| |$ConstructorCache| '|NonNegativeInteger| NIL
+            (CONS 1 $))
+        (|stuffDomainSlots| $)
+        $))))
 
 (MAKEPROP 
   (QUOTE |NonNegativeInteger|)
@@ -118137,29 +118959,29 @@ Note that this code is not included in the generated catdef.spad file.
     (SPADCALL |n| (|-| |m| 1) (QREFELT |$| 46))
     (QREFELT |$| 45))))) 
 
-(DEFUN |OUTFORM;matrix;L$;29| (|ll| |$|)
- (PROG (#1=#:G82748 |l| #2=#:G82749 |lv|)
-  (RETURN
-   (SEQ
-    (LETT |lv|
-     (PROGN
-      (LETT #1# NIL |OUTFORM;matrix;L$;29|)
-      (SEQ
-       (LETT |l| NIL |OUTFORM;matrix;L$;29|)
-       (LETT #2# |ll| |OUTFORM;matrix;L$;29|)
-       G190
-       (COND
-        ((OR
-           (ATOM #2#)
-           (PROGN (LETT |l| (CAR #2#) |OUTFORM;matrix;L$;29|) NIL))
-         (GO G191)))
-       (SEQ (EXIT (LETT #1# (CONS (LIST2VEC |l|) #1#) |OUTFORM;matrix;L$;29|)))
-       (LETT #2# (CDR #2#) |OUTFORM;matrix;L$;29|)
-       (GO G190)
-       G191
-       (EXIT (NREVERSE0 #1#))))
-     |OUTFORM;matrix;L$;29|)
-    (EXIT (CONS (|OUTFORM;eform| (QUOTE MATRIX) |$|) (LIST2VEC |lv|))))))) 
+(DEFUN |OUTFORM;matrix;L$;29| (|ll| $)
+  (PROG (G82748 |l| G82749 |lv|)
+    (RETURN
+      (SEQ (LETT |lv|
+                 (PROGN
+                   (LETT G82748 NIL |OUTFORM;matrix;L$;29|)
+                   (SEQ (LETT |l| NIL |OUTFORM;matrix;L$;29|)
+                        (LETT G82749 |ll| |OUTFORM;matrix;L$;29|) G190
+                        (COND
+                          ((OR (ATOM G82749)
+                               (PROGN
+                                 (LETT |l| (CAR G82749)
+                                       |OUTFORM;matrix;L$;29|)
+                                 NIL))
+                           (GO G191)))
+                        (SEQ (EXIT (LETT G82748
+                                    (CONS (LIST2VEC |l|) G82748)
+                                    |OUTFORM;matrix;L$;29|)))
+                        (LETT G82749 (CDR G82749)
+                              |OUTFORM;matrix;L$;29|)
+                        (GO G190) G191 (EXIT (NREVERSE0 G82748))))
+                 |OUTFORM;matrix;L$;29|)
+           (EXIT (CONS (|OUTFORM;eform| 'MATRIX $) (LIST2VEC |lv|)))))))
 
 (DEFUN |OUTFORM;pile;L$;30| (|l| |$|)
  (CONS (|OUTFORM;eform| (QUOTE SC) |$|) |l|)) 
@@ -118170,37 +118992,36 @@ Note that this code is not included in the generated catdef.spad file.
 (DEFUN |OUTFORM;semicolonSeparate;L$;32| (|l| |$|)
  (CONS (|OUTFORM;eform| (QUOTE AGGSET) |$|) |l|)) 
 
-(DEFUN |OUTFORM;blankSeparate;L$;33| (|l| |$|)
- (PROG (|c| |u| #1=#:G82757 |l1|)
-  (RETURN
-   (SEQ
-    (LETT |c|
-     (|OUTFORM;eform| (QUOTE CONCATB) |$|)
-     |OUTFORM;blankSeparate;L$;33|)
-    (LETT |l1| NIL |OUTFORM;blankSeparate;L$;33|)
-    (SEQ
-     (LETT |u| NIL |OUTFORM;blankSeparate;L$;33|)
-     (LETT #1# (SPADCALL |l| (QREFELT |$| 53)) |OUTFORM;blankSeparate;L$;33|)
-     G190
-     (COND
-      ((OR
-        (ATOM #1#)
-        (PROGN (LETT |u| (CAR #1#) |OUTFORM;blankSeparate;L$;33|) NIL))
-       (GO G191)))
-     (SEQ
-      (EXIT
-       (COND
-        ((EQCAR |u| |c|)
-         (LETT |l1|
-          (SPADCALL (CDR |u|) |l1| (QREFELT |$| 54))
-          |OUTFORM;blankSeparate;L$;33|))
-        ((QUOTE T)
-         (LETT |l1| (CONS |u| |l1|) |OUTFORM;blankSeparate;L$;33|)))))
-     (LETT #1# (CDR #1#) |OUTFORM;blankSeparate;L$;33|)
-     (GO G190)
-     G191
-     (EXIT NIL))
-    (EXIT (CONS |c| |l1|)))))) 
+(DEFUN |OUTFORM;blankSeparate;L$;33| (|l| $)
+  (PROG (|c| |u| G82757 |l1|)
+    (RETURN
+      (SEQ (LETT |c| (|OUTFORM;eform| 'CONCATB $)
+                 |OUTFORM;blankSeparate;L$;33|)
+           (LETT |l1| NIL |OUTFORM;blankSeparate;L$;33|)
+           (SEQ (LETT |u| NIL |OUTFORM;blankSeparate;L$;33|)
+                (LETT G82757 (SPADCALL |l| (QREFELT $ 53))
+                      |OUTFORM;blankSeparate;L$;33|)
+                G190
+                (COND
+                  ((OR (ATOM G82757)
+                       (PROGN
+                         (LETT |u| (CAR G82757)
+                               |OUTFORM;blankSeparate;L$;33|)
+                         NIL))
+                   (GO G191)))
+                (SEQ (EXIT (COND
+                             ((EQCAR |u| |c|)
+                              (LETT |l1|
+                                    (SPADCALL (CDR |u|) |l1|
+                                     (QREFELT $ 54))
+                                    |OUTFORM;blankSeparate;L$;33|))
+                             ('T
+                              (LETT |l1| (CONS |u| |l1|)
+                                    |OUTFORM;blankSeparate;L$;33|)))))
+                (LETT G82757 (CDR G82757)
+                      |OUTFORM;blankSeparate;L$;33|)
+                (GO G190) G191 (EXIT NIL))
+           (EXIT (CONS |c| |l1|))))))
 
 (DEFUN |OUTFORM;brace;2$;34| (|a| |$|)
  (LIST (|OUTFORM;eform| (QUOTE BRACE) |$|) |a|)) 
@@ -118340,25 +119161,21 @@ Note that this code is not included in the generated catdef.spad file.
 (DEFUN |OUTFORM;empty;$;71| (|$|)
  (LIST (|OUTFORM;eform| (QUOTE NOTHING) |$|))) 
 
-(DEFUN |OUTFORM;infix?;$B;72| (|a| |$|)
- (PROG (#1=#:G82802 |e|)
-  (RETURN
-   (SEQ
-    (EXIT
-     (SEQ
-      (LETT |e|
-       (COND
-        ((IDENTP |a|) |a|)
-        ((STRINGP |a|) (INTERN |a|))
-        ((QUOTE T)
-         (PROGN (LETT #1# (QUOTE NIL) |OUTFORM;infix?;$B;72|) (GO #1#))))
-       |OUTFORM;infix?;$B;72|)
-      (EXIT
-       (COND
-        ((GET |e| (QUOTE INFIXOP)) (QUOTE T))
-        ((QUOTE T) (QUOTE NIL))))))
-    #1#
-    (EXIT #1#))))) 
+(DEFUN |OUTFORM;infix?;$B;72| (|a| $)
+  (PROG (G82802 |e|)
+    (RETURN
+      (SEQ (EXIT (SEQ (LETT |e|
+                            (COND
+                              ((IDENTP |a|) |a|)
+                              ((STRINGP |a|) (INTERN |a|))
+                              ('T
+                               (PROGN
+                                 (LETT G82802 'NIL
+                                       |OUTFORM;infix?;$B;72|)
+                                 (GO G82802))))
+                            |OUTFORM;infix?;$B;72|)
+                      (EXIT (COND ((GET |e| 'INFIXOP) 'T) ('T 'NIL)))))
+           G82802 (EXIT G82802)))))
 
 (PUT (QUOTE |OUTFORM;elt;$L$;73|) (QUOTE |SPADreplace|) (QUOTE CONS)) 
 
@@ -118457,29 +119274,27 @@ Note that this code is not included in the generated catdef.spad file.
 (DEFUN |OUTFORM;rarrow;3$;94| (|a| |b| |$|)
  (LIST (|OUTFORM;eform| (QUOTE TAG) |$|) |a| |b|)) 
 
-(DEFUN |OUTFORM;differentiate;$Nni$;95| (|a| |nn| |$|)
- (PROG (#1=#:G82832 |r| |s|)
-  (RETURN
-   (SEQ
-    (COND
-     ((ZEROP |nn|) |a|)
-     ((|<| |nn| 4) (SPADCALL |a| |nn| (QREFELT |$| 112)))
-     ((QUOTE T)
-      (SEQ
-       (LETT |r|
-        (SPADCALL
-         (PROG1
-          (LETT #1# |nn| |OUTFORM;differentiate;$Nni$;95|)
-          (|check-subtype| (|>| #1# 0) (QUOTE (|PositiveInteger|)) #1#))
-         (QREFELT |$| 125))
-        |OUTFORM;differentiate;$Nni$;95|)
-       (LETT |s|
-        (SPADCALL |r| (QREFELT |$| 126))
-        |OUTFORM;differentiate;$Nni$;95|)
-       (EXIT
-        (SPADCALL |a|
-         (SPADCALL (|OUTFORM;sform| |s| |$|) (QREFELT |$| 60))
-         (QREFELT |$| 63)))))))))) 
+(DEFUN |OUTFORM;differentiate;$Nni$;95| (|a| |nn| $)
+  (PROG (G82832 |r| |s|)
+    (RETURN
+      (SEQ (COND
+             ((ZEROP |nn|) |a|)
+             ((< |nn| 4) (SPADCALL |a| |nn| (QREFELT $ 112)))
+             ('T
+              (SEQ (LETT |r|
+                         (SPADCALL
+                             (PROG1 (LETT G82832 |nn|
+                                     |OUTFORM;differentiate;$Nni$;95|)
+                               (|check-subtype| (> G82832 0)
+                                   '(|PositiveInteger|) G82832))
+                             (QREFELT $ 125))
+                         |OUTFORM;differentiate;$Nni$;95|)
+                   (LETT |s| (SPADCALL |r| (QREFELT $ 126))
+                         |OUTFORM;differentiate;$Nni$;95|)
+                   (EXIT (SPADCALL |a|
+                             (SPADCALL (|OUTFORM;sform| |s| $)
+                                 (QREFELT $ 60))
+                             (QREFELT $ 63))))))))))
 
 (DEFUN |OUTFORM;sum;2$;96| (|a| |$|)
  (LIST (|OUTFORM;eform| (QUOTE SIGMA) |$|) (SPADCALL (QREFELT |$| 12)) |a|)) 
@@ -118516,34 +119331,38 @@ Note that this code is not included in the generated catdef.spad file.
 (DEFUN |OUTFORM;int;4$;104| (|a| |b| |c| |$|)
  (LIST (|OUTFORM;eform| (QUOTE INTSIGN) |$|) |b| |c| |a|)) 
 
-(DEFUN |OutputForm| NIL
- (PROG NIL
-  (RETURN
-   (PROG (#1=#:G82846)
+(DEFUN |OutputForm| ()
+  (PROG ()
     (RETURN
-     (COND
-      ((LETT #1# (HGET |$ConstructorCache| (QUOTE |OutputForm|)) |OutputForm|)
-        (|CDRwithIncrement| (CDAR #1#)))
-      ((QUOTE T)
-       (|UNWIND-PROTECT|
-        (PROG1
-         (CDDAR
-          (HPUT |$ConstructorCache|
-           (QUOTE |OutputForm|) (LIST (CONS NIL (CONS 1 (|OutputForm;|))))))
-         (LETT #1# T |OutputForm|))
-        (COND
-         ((NOT #1#) (HREM |$ConstructorCache| (QUOTE |OutputForm|)))))))))))) 
-
-(DEFUN |OutputForm;| NIL
- (PROG (|dv$| |$| |pv$|)
-  (RETURN 
-   (PROGN
-    (LETT |dv$| (QUOTE (|OutputForm|)) . #1=(|OutputForm|))
-    (LETT |$| (GETREFV 138) . #1#)
-    (QSETREFV |$| 0 |dv$|)
-    (QSETREFV |$| 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#))
-    (|haddProp| |$ConstructorCache| (QUOTE |OutputForm|) NIL (CONS 1 |$|))
-    (|stuffDomainSlots| |$|) (QSETREFV |$| 6 (|List| |$|)) |$|)))) 
+      (PROG (G82846)
+        (RETURN
+          (COND
+            ((LETT G82846 (HGET |$ConstructorCache| '|OutputForm|)
+                   |OutputForm|)
+             (|CDRwithIncrement| (CDAR G82846)))
+            ('T
+             (UNWIND-PROTECT
+               (PROG1 (CDDAR (HPUT |$ConstructorCache| '|OutputForm|
+                                   (LIST
+                                    (CONS NIL (CONS 1 (|OutputForm;|))))))
+                 (LETT G82846 T |OutputForm|))
+               (COND
+                 ((NOT G82846)
+                  (HREM |$ConstructorCache| '|OutputForm|)))))))))))
+
+(DEFUN |OutputForm;| ()
+  (PROG (|dv$| $ |pv$|)
+    (RETURN
+      (PROGN
+        (LETT |dv$| '(|OutputForm|) |OutputForm|)
+        (LETT $ (GETREFV 138) |OutputForm|)
+        (QSETREFV $ 0 |dv$|)
+        (QSETREFV $ 3
+            (LETT |pv$| (|buildPredVector| 0 0 NIL) |OutputForm|))
+        (|haddProp| |$ConstructorCache| '|OutputForm| NIL (CONS 1 $))
+        (|stuffDomainSlots| $)
+        (QSETREFV $ 6 (|List| $))
+        $))))
 
 (MAKEPROP
  (QUOTE |OutputForm|)
@@ -118661,55 +119480,49 @@ Note that this code is not included in the generated catdef.spad file.
 
 (|/VERSIONCHECK| 2) 
 
-(SETQ |$CategoryFrame| 
-  (|put| 
-    #1=(QUOTE |PositiveInteger|)
-    (QUOTE |SuperDomain|)
-    #2=(QUOTE (|NonNegativeInteger|))
-    (|put| 
-      #2# 
-      #3=(QUOTE |SubDomain|) 
-      (CONS 
-        (QUOTE (|PositiveInteger| |<| 0 |#1|))
-        (DELASC #1# (|get| #2# #3# |$CategoryFrame|)))
-      |$CategoryFrame|))) 
+(SETQ |$CategoryFrame|
+      (|put| '|PositiveInteger| '|SuperDomain| '(|NonNegativeInteger|)
+             (|put| '(|NonNegativeInteger|) '|SubDomain|
+                    (CONS '(|PositiveInteger| < 0 |#1|)
+                          (DELASC '|PositiveInteger|
+                                  (|get| '(|NonNegativeInteger|)
+                                         '|SubDomain| |$CategoryFrame|)))
+                    |$CategoryFrame|)))
+
+(DEFUN |PositiveInteger| ()
+  (PROG ()
+    (RETURN
+      (PROG (G96739)
+        (RETURN
+          (COND
+            ((LETT G96739 (HGET |$ConstructorCache| '|PositiveInteger|)
+                   |PositiveInteger|)
+             (|CDRwithIncrement| (CDAR G96739)))
+            ('T
+             (UNWIND-PROTECT
+               (PROG1 (CDDAR (HPUT |$ConstructorCache|
+                                   '|PositiveInteger|
+                                   (LIST
+                                    (CONS NIL
+                                     (CONS 1 (|PositiveInteger;|))))))
+                 (LETT G96739 T |PositiveInteger|))
+               (COND
+                 ((NOT G96739)
+                  (HREM |$ConstructorCache| '|PositiveInteger|)))))))))))
 
-(DEFUN |PositiveInteger| NIL 
-  (PROG NIL 
-    (RETURN 
-      (PROG (#1=#:G96739) 
-        (RETURN 
-          (COND 
-            ((LETT #1# 
-               (HGET |$ConstructorCache| (QUOTE |PositiveInteger|))
-               |PositiveInteger|)
-                 (|CDRwithIncrement| (CDAR #1#)))
-            ((QUOTE T) 
-              (|UNWIND-PROTECT| 
-                (PROG1 
-                  (CDDAR
-                   (HPUT |$ConstructorCache|
-                    (QUOTE |PositiveInteger|)
-                    (LIST (CONS NIL (CONS 1 (|PositiveInteger;|))))))
-                  (LETT #1# T |PositiveInteger|))
-                (COND 
-                  ((NOT #1#) 
-                     (HREM 
-                       |$ConstructorCache| 
-                       (QUOTE |PositiveInteger|)))))))))))) 
-
-(DEFUN |PositiveInteger;| NIL 
-  (PROG (|dv$| |$| |pv$|) 
-    (RETURN 
-      (PROGN 
-        (LETT |dv$| (QUOTE (|PositiveInteger|)) . #1=(|PositiveInteger|))
-        (LETT |$| (GETREFV 12) . #1#)
-        (QSETREFV |$| 0 |dv$|)
-        (QSETREFV |$| 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#))
-        (|haddProp| 
-           |$ConstructorCache| (QUOTE |PositiveInteger|) NIL (CONS 1 |$|))
-        (|stuffDomainSlots| |$|)
-        |$|)))) 
+(DEFUN |PositiveInteger;| ()
+  (PROG (|dv$| $ |pv$|)
+    (RETURN
+      (PROGN
+        (LETT |dv$| '(|PositiveInteger|) |PositiveInteger|)
+        (LETT $ (GETREFV 12) |PositiveInteger|)
+        (QSETREFV $ 0 |dv$|)
+        (QSETREFV $ 3
+            (LETT |pv$| (|buildPredVector| 0 0 NIL) |PositiveInteger|))
+        (|haddProp| |$ConstructorCache| '|PositiveInteger| NIL
+            (CONS 1 $))
+        (|stuffDomainSlots| $)
+        $))))
 
 (MAKEPROP 
   (QUOTE |PositiveInteger|)
@@ -118801,76 +119614,77 @@ Note that this code is not included in the generated catdef.spad file.
 
 (DEFUN |PRIMARR;setelt;$I2S;8| (|x| |i| |s| |$|) (SETELT |x| |i| |s|)) 
 
-(DEFUN |PRIMARR;fill!;$S$;9| (|x| |s| |$|)
- (PROG (|i| #1=#:G82338)
-  (RETURN
-   (SEQ
-    (SEQ
-     (LETT |i| 0 |PRIMARR;fill!;$S$;9|)
-     (LETT #1# (QVMAXINDEX |x|) |PRIMARR;fill!;$S$;9|)
-     G190
-     (COND ((QSGREATERP |i| #1#) (GO G191)))
-     (SEQ (EXIT (SETELT |x| |i| |s|)))
-     (LETT |i| (QSADD1 |i|) |PRIMARR;fill!;$S$;9|)
-     (GO G190)
-     G191
-    (EXIT NIL))
-   (EXIT |x|)))))
-
-(DEFUN |PrimitiveArray| (#1=#:G82348)
- (PROG NIL
-  (RETURN 
-   (PROG (#2=#:G82349)
+(DEFUN |PRIMARR;fill!;$S$;9| (|x| |s| $)
+  (PROG (|i| G82338)
     (RETURN
-     (COND
-      ((LETT #2# 
-        (|lassocShiftWithFunction|
-          (LIST (|devaluate| #1#))
-          (HGET |$ConstructorCache| (QUOTE |PrimitiveArray|))
-          (QUOTE |domainEqualList|))
-         |PrimitiveArray|)
-        (|CDRwithIncrement| #2#))
-      ((QUOTE T)
-        (|UNWIND-PROTECT|
-         (PROG1
-          (|PrimitiveArray;| #1#)
-          (LETT #2# T |PrimitiveArray|))
-         (COND
-          ((NOT #2#)
-            (HREM |$ConstructorCache| (QUOTE |PrimitiveArray|)))))))))))) 
+      (SEQ (SEQ (LETT |i| 0 |PRIMARR;fill!;$S$;9|)
+                (LETT G82338 (QVMAXINDEX |x|) |PRIMARR;fill!;$S$;9|)
+                G190 (COND ((QSGREATERP |i| G82338) (GO G191)))
+                (SEQ (EXIT (SETELT |x| |i| |s|)))
+                (LETT |i| (QSADD1 |i|) |PRIMARR;fill!;$S$;9|) (GO G190)
+                G191 (EXIT NIL))
+           (EXIT |x|)))))
+
+(DEFUN |PrimitiveArray| (G82348)
+  (PROG ()
+    (RETURN
+      (PROG (G82349)
+        (RETURN
+          (COND
+            ((LETT G82349
+                   (|lassocShiftWithFunction|
+                       (LIST (|devaluate| G82348))
+                       (HGET |$ConstructorCache| '|PrimitiveArray|)
+                       '|domainEqualList|)
+                   |PrimitiveArray|)
+             (|CDRwithIncrement| G82349))
+            ('T
+             (UNWIND-PROTECT
+               (PROG1 (|PrimitiveArray;| G82348)
+                 (LETT G82349 T |PrimitiveArray|))
+               (COND
+                 ((NOT G82349)
+                  (HREM |$ConstructorCache| '|PrimitiveArray|)))))))))))
 
 (DEFUN |PrimitiveArray;| (|#1|)
- (PROG (|DV$1| |dv$| |$| #1=#:G82347 |pv$|)
-  (RETURN
-   (PROGN 
-    (LETT |DV$1| (|devaluate| |#1|) . #2=(|PrimitiveArray|))
-    (LETT |dv$| (LIST (QUOTE |PrimitiveArray|) |DV$1|) . #2#)
-    (LETT |$| (GETREFV 35) . #2#)
-    (QSETREFV |$| 0 |dv$|)
-    (QSETREFV |$| 3
-     (LETT |pv$|
-      (|buildPredVector| 0 0
-       (LIST 
-        (|HasCategory| |#1| (QUOTE (|SetCategory|)))
-        (|HasCategory| |#1| (QUOTE (|ConvertibleTo| (|InputForm|))))
-        (LETT #1# (|HasCategory| |#1| (QUOTE (|OrderedSet|))) . #2#)
-        (OR #1# (|HasCategory| |#1| (QUOTE (|SetCategory|))))
-        (|HasCategory| (|Integer|) (QUOTE (|OrderedSet|)))
-        (AND (|HasCategory| |#1| (LIST (QUOTE |Evalable|) (|devaluate| |#1|)))
-             (|HasCategory| |#1| (QUOTE (|SetCategory|))))
-        (OR 
-         (AND 
-          (|HasCategory| |#1| (LIST (QUOTE |Evalable|) (|devaluate| |#1|)))
-          #1#)
-         (AND
-          (|HasCategory| |#1| (LIST (QUOTE |Evalable|) (|devaluate| |#1|)))
-          (|HasCategory| |#1| (QUOTE (|SetCategory|)))))))
-      . #2#))
-    (|haddProp| |$ConstructorCache|
-     (QUOTE |PrimitiveArray|) (LIST |DV$1|) (CONS 1 |$|))
-    (|stuffDomainSlots| |$|)
-    (QSETREFV |$| 6 |#1|)
-    |$|)))) 
+  (PROG (DV$1 |dv$| $ G82347 |pv$|)
+    (RETURN
+      (PROGN
+        (LETT DV$1 (|devaluate| |#1|) |PrimitiveArray|)
+        (LETT |dv$| (LIST '|PrimitiveArray| DV$1) |PrimitiveArray|)
+        (LETT $ (GETREFV 35) |PrimitiveArray|)
+        (QSETREFV $ 0 |dv$|)
+        (QSETREFV $ 3
+            (LETT |pv$|
+                  (|buildPredVector| 0 0
+                      (LIST (|HasCategory| |#1| '(|SetCategory|))
+                            (|HasCategory| |#1|
+                                '(|ConvertibleTo| (|InputForm|)))
+                            (LETT G82347
+                                  (|HasCategory| |#1| '(|OrderedSet|))
+                                  |PrimitiveArray|)
+                            (OR G82347
+                                (|HasCategory| |#1| '(|SetCategory|)))
+                            (|HasCategory| (|Integer|) '(|OrderedSet|))
+                            (AND (|HasCategory| |#1|
+                                     (LIST '|Evalable|
+                                      (|devaluate| |#1|)))
+                                 (|HasCategory| |#1| '(|SetCategory|)))
+                            (OR (AND (|HasCategory| |#1|
+                                      (LIST '|Evalable|
+                                       (|devaluate| |#1|)))
+                                     G82347)
+                                (AND (|HasCategory| |#1|
+                                      (LIST '|Evalable|
+                                       (|devaluate| |#1|)))
+                                     (|HasCategory| |#1|
+                                      '(|SetCategory|))))))
+                  |PrimitiveArray|))
+        (|haddProp| |$ConstructorCache| '|PrimitiveArray| (LIST DV$1)
+            (CONS 1 $))
+        (|stuffDomainSlots| $)
+        (QSETREFV $ 6 |#1|)
+        $))))
 
 (MAKEPROP (QUOTE |PrimitiveArray|) (QUOTE |infovec|)
  (LIST 
@@ -118973,49 +119787,49 @@ Note that this code is not included in the generated catdef.spad file.
   (LIST (SPADCALL (QCAR |p|) (QREFELT |$| 18)))
   (QREFELT |$| 20))) 
 
-(DEFUN |Reference| (#1=#:G82336)
- (PROG NIL
-  (RETURN
-   (PROG (#2=#:G82337)
+(DEFUN |Reference| (G82336)
+  (PROG ()
     (RETURN
-     (COND
-      ((LETT #2# 
-        (|lassocShiftWithFunction| 
-         (LIST (|devaluate| #1#))
-         (HGET |$ConstructorCache| (QUOTE |Reference|))
-         (QUOTE |domainEqualList|)) |Reference|)
-        (|CDRwithIncrement| #2#))
-      ((QUOTE T)
-       (|UNWIND-PROTECT|
-        (PROG1 (|Reference;| #1#) (LETT #2# T |Reference|))
-        (COND
-         ((NOT #2#) (HREM |$ConstructorCache| (QUOTE |Reference|)))))))))))) 
+      (PROG (G82337)
+        (RETURN
+          (COND
+            ((LETT G82337
+                   (|lassocShiftWithFunction|
+                       (LIST (|devaluate| G82336))
+                       (HGET |$ConstructorCache| '|Reference|)
+                       '|domainEqualList|)
+                   |Reference|)
+             (|CDRwithIncrement| G82337))
+            ('T
+             (UNWIND-PROTECT
+               (PROG1 (|Reference;| G82336)
+                 (LETT G82337 T |Reference|))
+               (COND
+                ((NOT G82337) (HREM |$ConstructorCache| '|Reference|)))))))))))
 
 (DEFUN |Reference;| (|#1|)
- (PROG (|DV$1| |dv$| |$| |pv$|)
-  (RETURN
-   (PROGN
-    (LETT |DV$1| (|devaluate| |#1|) . #1=(|Reference|))
-    (LETT |dv$| (LIST (QUOTE |Reference|) |DV$1|) . #1#)
-    (LETT |$| (GETREFV 23) . #1#)
-    (QSETREFV |$| 0 |dv$|)
-    (QSETREFV |$| 3
-     (LETT |pv$| 
-      (|buildPredVector| 0 0 
-        (LIST (|HasCategory| |#1| (QUOTE (|SetCategory|)))))
-      . #1#))
-    (|haddProp| 
-      |$ConstructorCache| 
-      (QUOTE |Reference|) 
-      (LIST |DV$1|) 
-      (CONS 1 |$|))
-    (|stuffDomainSlots| |$|)
-    (QSETREFV |$| 6 |#1|)
-    (QSETREFV |$| 7 (|Record| (|:| |value| |#1|)))
-    (COND 
-     ((|testBitVector| |pv$| 1)
-      (QSETREFV |$| 21 (CONS (|dispatchFunction| |REF;coerce;$Of;7|) |$|))))
-    |$|)))) 
+  (PROG (DV$1 |dv$| $ |pv$|)
+    (RETURN
+      (PROGN
+        (LETT DV$1 (|devaluate| |#1|) |Reference|)
+        (LETT |dv$| (LIST '|Reference| DV$1) |Reference|)
+        (LETT $ (GETREFV 23) |Reference|)
+        (QSETREFV $ 0 |dv$|)
+        (QSETREFV $ 3
+            (LETT |pv$|
+                  (|buildPredVector| 0 0
+                      (LIST (|HasCategory| |#1| '(|SetCategory|))))
+                  |Reference|))
+        (|haddProp| |$ConstructorCache| '|Reference| (LIST DV$1)
+            (CONS 1 $))
+        (|stuffDomainSlots| $)
+        (QSETREFV $ 6 |#1|)
+        (QSETREFV $ 7 (|Record| (|:| |value| |#1|)))
+        (COND
+          ((|testBitVector| |pv$| 1)
+           (QSETREFV $ 21
+               (CONS (|dispatchFunction| |REF;coerce;$Of;7|) $))))
+        $))))
 
 (MAKEPROP
  (QUOTE |Reference|)
@@ -119457,254 +120271,240 @@ Note that this code is not included in the generated catdef.spad file.
     ((QSLESSP |x| 0) (VECTOR -1 (QSMINUS |x|) -1))
     ((QUOTE T) (VECTOR 1 |x| 1)))) 
 
-(DEFUN |SingleInteger| NIL 
-  (PROG NIL 
-    (RETURN 
-      (PROG (#0=#:G1358) 
-        (RETURN 
-          (COND 
-            ((LETT #0# 
-                (HGET |$ConstructorCache| (QUOTE |SingleInteger|))
-                |SingleInteger|)
-              (|CDRwithIncrement| (CDAR #0#)))
-            ((QUOTE T) 
-              (UNWIND-PROTECT 
-                (PROG1 
-                  (CDDAR 
-                    (HPUT 
-                      |$ConstructorCache| 
-                      (QUOTE |SingleInteger|)
-                      (LIST (CONS NIL (CONS 1 (|SingleInteger;|))))))
-                  (LETT #0# T |SingleInteger|))
-                (COND 
-                  ((NOT #0#)
-                     (HREM |$ConstructorCache| 
-                       (QUOTE |SingleInteger|)))))))))))) 
-
-(DEFUN |SingleInteger;| NIL 
-  (PROG (|dv$| $ |pv$|) 
-    (RETURN 
-      (PROGN 
-        (LETT |dv$| (QUOTE (|SingleInteger|)) . #0=(|SingleInteger|))
-        (LETT $ (GETREFV 103) . #0#)
-        (QSETREFV $ 0 |dv$|)
-        (QSETREFV $ 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #0#))
-        (|haddProp| |$ConstructorCache| (QUOTE |SingleInteger|) NIL (CONS 1 $))
-        (|stuffDomainSlots| $) (QSETREFV $ 6 1) $)))) 
+(DEFUN |SingleInteger| ()
+  (PROG ()
+    (RETURN
+      (PROG (G1358)
+        (RETURN
+          (COND
+            ((LETT G1358 (HGET |$ConstructorCache| '|SingleInteger|)
+                   |SingleInteger|)
+             (|CDRwithIncrement| (CDAR G1358)))
+            ('T
+             (UNWIND-PROTECT
+               (PROG1 (CDDAR (HPUT |$ConstructorCache| '|SingleInteger|
+                                   (LIST
+                                    (CONS NIL
+                                     (CONS 1 (|SingleInteger;|))))))
+                 (LETT G1358 T |SingleInteger|))
+               (COND
+                 ((NOT G1358)
+                  (HREM |$ConstructorCache| '|SingleInteger|)))))))))))
 
-(MAKEPROP 
-  (QUOTE |SingleInteger|)
-  (QUOTE |infovec|)
-  (LIST 
-    (QUOTE 
-      #(NIL NIL NIL NIL NIL NIL 
-        (QUOTE |seed|)
-        (|Void|)
-        (|OpenMathDevice|)
-        (0 . |OMputApp|)
-        (|String|)
-        (5 . |OMputSymbol|)
-        (|Integer|)
-        (12 . |OMputInteger|)
-        (18 . |OMputEndApp|)
-        (|OpenMathEncoding|)
-        (23 . |OMencodingXML|)
-        (27 . |OMopenString|)
-        (33 . |OMputObject|)
-        (38 . |OMputEndObject|)
-        (43 . |OMclose|)
-        |SINT;OMwrite;$S;2| 
-        (|Boolean|)
-        |SINT;OMwrite;$BS;3|
-        |SINT;OMwrite;Omd$V;4|
-        |SINT;OMwrite;Omd$BV;5|
-        (|Matrix| 12)
-        (|Matrix| $)
-        |SINT;reducedSystem;MM;6|
-        (|OutputForm|)
-        (48 . |coerce|)
-        |SINT;coerce;$Of;7|
-        |SINT;convert;$I;8|
-        (53 . |coerce|)
-        |SINT;*;I2$;9|
-        (CONS IDENTITY (FUNCALL (|dispatchFunction| |SINT;Zero;$;10|) $))
-        (CONS IDENTITY (FUNCALL (|dispatchFunction| |SINT;One;$;11|) $))
-        |SINT;base;$;12|
-        |SINT;max;$;13|
-        |SINT;min;$;14|
-        |SINT;=;2$B;15|
-        |SINT;~;2$;16|
-        |SINT;not;2$;17|
-        |SINT;/\\;3$;18|
-        |SINT;\\/;3$;19|
-        |SINT;Not;2$;20|
-        |SINT;And;3$;21|
-        |SINT;Or;3$;22|
-        |SINT;xor;3$;23|
-        |SINT;<;2$B;24|
-        |SINT;inc;2$;25|
-        |SINT;dec;2$;26|
-        |SINT;-;2$;27|
-        |SINT;+;3$;28|
-        |SINT;-;3$;29|
-        |SINT;*;3$;30|
-        (|NonNegativeInteger|)
-        |SINT;**;$Nni$;31|
-        |SINT;quo;3$;32|
-        |SINT;rem;3$;33|
-        (|Record| (|:| |quotient| $) (|:| |remainder| $))
-        |SINT;divide;2$R;34|
-        |SINT;gcd;3$;35|
-        |SINT;abs;2$;36|
-        |SINT;odd?;$B;37|
-        |SINT;zero?;$B;38|
-        |SINT;max;3$;39|
-        |SINT;min;3$;40|
-        |SINT;hash;2$;41|
-        |SINT;length;2$;42|
-        |SINT;shift;3$;43|
-        |SINT;mulmod;4$;44|
-        |SINT;addmod;4$;45|
-        |SINT;submod;4$;46|
-        |SINT;negative?;$B;47|
-        (|Record| (|:| |mat| 26) (|:| |vec| (|Vector| 12)))
-        (|Vector| $)
-        |SINT;reducedSystem;MVR;48|
-        |SINT;positiveRemainder;3$;49|
-        |SINT;coerce;I$;50|
-        |SINT;random;$;51|
-        |SINT;random;2$;52|
-        (|Record| (|:| |unit| $) (|:| |canonical| $) (|:| |associate| $))
-        |SINT;unitNormal;$R;53|
-        (|Union| 85 (QUOTE "failed"))
-        (|Fraction| 12)
-        (|Union| $ (QUOTE "failed"))
-        (|Float|)
-        (|DoubleFloat|)
-        (|Pattern| 12)
-        (|PatternMatchResult| 12 $)
-        (|InputForm|)
-        (|Union| 12 (QUOTE "failed"))
-        (|Record| (|:| |coef| 94) (|:| |generator| $))
-        (|List| $)
-        (|Union| 94 (QUOTE "failed"))
-        (|Record| (|:| |coef1| $) (|:| |coef2| $) (|:| |generator| $))
-        (|Record| (|:| |coef1| $) (|:| |coef2| $))
-        (|Union| 97 (QUOTE "failed"))
-        (|Factored| $)
-        (|SparseUnivariatePolynomial| $)
-        (|PositiveInteger|)
-        (|SingleInteger|)))
-     (QUOTE 
-       #(~= 58 ~ 64 |zero?| 69 |xor| 74 |unitNormal| 80 |unitCanonical| 85 
-         |unit?| 90 |symmetricRemainder| 95 |subtractIfCan| 101 |submod| 107 
-         |squareFreePart| 114 |squareFree| 119 |sizeLess?| 124 |sign| 130 
-         |shift| 135 |sample| 141 |retractIfCan| 145 |retract| 150 |rem| 155 
-         |reducedSystem| 161 |recip| 172 |rationalIfCan| 177 |rational?| 182 
-         |rational| 187 |random| 192 |quo| 201 |principalIdeal| 207 
-         |prime?| 212 |powmod| 217 |positiveRemainder| 224 |positive?| 230 
-         |permutation| 235 |patternMatch| 241 |one?| 248 |odd?| 253 |not| 258
-         |nextItem| 263 |negative?| 268 |multiEuclidean| 273 |mulmod| 279
-         |min| 286 |max| 296 |mask| 306 |length| 311 |lcm| 316 |latex| 327
-         |invmod| 332 |init| 338 |inc| 342 |hash| 347 |gcdPolynomial| 357
-         |gcd| 363 |factorial| 374 |factor| 379 |extendedEuclidean| 384
-         |exquo| 397 |expressIdealMember| 403 |even?| 409 |euclideanSize| 414
-         |divide| 419 |differentiate| 425 |dec| 436 |copy| 441 |convert| 446
-         |coerce| 471 |characteristic| 491 |bit?| 495 |binomial| 501
-         |base| 507 |associates?| 511 |addmod| 517 |abs| 524 ^ 529 |\\/| 541
-         |Zero| 547 |Or| 551 |One| 557 |OMwrite| 561 |Not| 585 D 590
-         |And| 601 >= 607 > 613 = 619 <= 625 < 631 |/\\| 637 - 643 + 654
-          ** 660 * 672))
-     (QUOTE (
-       (|noetherian| . 0)
-       (|canonicalsClosed| . 0)
-       (|canonical| . 0)
-       (|canonicalUnitNormal| . 0)
-       (|multiplicativeValuation| . 0)
-       (|noZeroDivisors| . 0)
-       ((|commutative| "*") . 0)
-       (|rightUnitary| . 0)
-       (|leftUnitary| . 0)
-       (|unitsKnown| . 0)))
-     (CONS 
-       (|makeByteWordVec2| 1 
-         (QUOTE (0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
-                 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
-                 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)))
-       (CONS
-         (QUOTE 
-           #(|IntegerNumberSystem&| |EuclideanDomain&|
-             |UniqueFactorizationDomain&| NIL NIL |GcdDomain&|
-             |IntegralDomain&| |Algebra&| |Module&| NIL |Module&| NIL NIL
-             |Module&| NIL |DifferentialRing&| |OrderedRing&| NIL |Module&|
-             NIL |Module&| NIL NIL NIL NIL NIL NIL |Ring&| NIL NIL NIL NIL
-             NIL NIL NIL NIL NIL NIL NIL NIL NIL |AbelianGroup&| NIL NIL
-             |AbelianMonoid&| |Monoid&| NIL NIL NIL NIL |OrderedSet&|
-             |AbelianSemiGroup&| |SemiGroup&| |Logic&| NIL |SetCategory&| NIL
-             NIL NIL NIL |RetractableTo&| NIL NIL NIL |RetractableTo&| NIL NIL
-             NIL NIL NIL NIL |RetractableTo&| NIL |BasicType&| NIL))
-         (CONS
-           (QUOTE 
-             #((|IntegerNumberSystem|) (|EuclideanDomain|) 
-               (|UniqueFactorizationDomain|) (|PrincipalIdealDomain|) 
-               (|OrderedIntegralDomain|) (|GcdDomain|) (|IntegralDomain|) 
-               (|Algebra| $$) (|Module| 12) (|LinearlyExplicitRingOver| 12) 
-               (|Module| #0=#:G1062) (|LinearlyExplicitRingOver| #0#) 
-               (|CharacteristicZero|) (|Module| #1=#:G106217) 
-               (|LinearlyExplicitRingOver| #1#) (|DifferentialRing|) 
-               (|OrderedRing|) (|CommutativeRing|) (|Module| |t#1|) 
-               (|EntireRing|) (|Module| $$) (|BiModule| 12 12) 
-               (|BiModule| #0# #0#) (|BiModule| #1# #1#) 
-               (|OrderedAbelianGroup|) (|BiModule| |t#1| |t#1|) 
-               (|BiModule| $$ $$) (|Ring|) (|RightModule| 12) 
-               (|LeftModule| 12) (|RightModule| #0#) (|LeftModule| #0#) 
-               (|RightModule| #1#) (|LeftModule| #1#) 
-               (|OrderedCancellationAbelianMonoid|) (|RightModule| |t#1|) 
-               (|LeftModule| |t#1|) (|LeftModule| $$) (|Rng|) 
-               (|RightModule| $$) (|OrderedAbelianMonoid|) (|AbelianGroup|) 
-               (|OrderedAbelianSemiGroup|) (|CancellationAbelianMonoid|) 
-               (|AbelianMonoid|) (|Monoid|) (|PatternMatchable| 12) 
-               (|PatternMatchable| #:G1065) (|StepThrough|) 
-               (|PatternMatchable| #:G106220) (|OrderedSet|) 
-               (|AbelianSemiGroup|) (|SemiGroup|) (|Logic|) (|RealConstant|) 
-               (|SetCategory|) (|OpenMath|) (|CoercibleTo| #:G82356) 
-               (|ConvertibleTo| 89) (|ConvertibleTo| 91) (|RetractableTo| 12) 
-               (|ConvertibleTo| 12) (|ConvertibleTo| #:G1064) 
-               (|ConvertibleTo| #:G1063) (|RetractableTo| #:G1061) 
-               (|ConvertibleTo| #:G1060) (|ConvertibleTo| 87) 
-               (|ConvertibleTo| 88) (|CombinatorialFunctionCategory|) 
-               (|ConvertibleTo| #:G106219) (|ConvertibleTo| #:G106218) 
-               (|RetractableTo| #:G106216) (|ConvertibleTo| #:G106215) 
-               (|BasicType|) (|CoercibleTo| 29)))
-             (|makeByteWordVec2| 102 
-               (QUOTE 
-                 (1 8 7 0 9 3 8 7 0 10 10 11 2 8 7 0 12 13 1 8 7 0 14 0 15 0
-                  16 2 8 0 10 15 17 1 8 7 0 18 1 8 7 0 19 1 8 7 0 20 1 12 29
-                  0 30 1 0 0 12 33 2 0 22 0 0 1 1 0 0 0 41 1 0 22 0 65 2 0 0 
-                  0 0 48 1 0 82 0 83 1 0 0 0 1 1 0 22 0 1 2 0 0 0 0 1 2 0 86
-                  0 0 1 3 0 0 0 0 0 73 1 0 0 0 1 1 0 99 0 1 2 0 22 0 0 1 1 0
-                  12 0 1 2 0 0 0 0 70 0 0 0 1 1 0 92 0 1 1 0 12 0 1 2 0 0 0 0
-                  59 1 0 26 27 28 2 0 75 27 76 77 1 0 86 0 1 1 0 84 0 1 1 0
-                  22 0 1 1 0 85 0 1 1 0 0 0 81 0 0 0 80 2 0 0 0 0 58 1 0 93
-                  94 1 1 0 22 0 1 3 0 0 0 0 0 1 2 0 0 0 0 78 1 0 22 0 1 2 0 0
-                  0 0 1 3 0 90 0 89 90 1 1 0 22 0 1 1 0 22 0 64 1 0 0 0 42 1
-                  0 86 0 1 1 0 22 0 74 2 0 95 94 0 1 3 0 0 0 0 0 71 0 0 0 39
-                  2 0 0 0 0 67 0 0 0 38 2 0 0 0 0 66 1 0 0 0 1 1 0 0 0 69 1 0
-                  0 94 1 2 0 0 0 0 1 1 0 10 0 1 2 0 0 0 0 1 0 0 0 1 1 0 0 0 50
-                  1 0 0 0 68 1 0 102 0 1 2 0 100 100 100 1 1 0 0 94 1 2 0 0 0
-                  0 62 1 0 0 0 1 1 0 99 0 1 2 0 96 0 0 1 3 0 98 0 0 0 1 2 0 86
-                  0 0 1 2 0 95 94 0 1 1 0 22 0 1 1 0 56 0 1 2 0 60 0 0 61 1 0
-                  0 0 1 2 0 0 0 56 1 1 0 0 0 51 1 0 0 0 1 1 0 87 0 1 1 0 88 0
-                  1 1 0 89 0 1 1 0 91 0 1 1 0 12 0 32 1 0 0 12 79 1 0 0 0 1 1
-                  0 0 12 79 1 0 29 0 31 0 0 56 1 2 0 22 0 0 1 2 0 0 0 0 1 0 0
-                  0 37 2 0 22 0 0 1 3 0 0 0 0 0 72 1 0 0 0 63 2 0 0 0 56 1 2 0
-                  0 0 101 1 2 0 0 0 0 44 0 0 0 35 2 0 0 0 0 47 0 0 0 36 3 0 7
-                  8 0 22 25 2 0 10 0 22 23 2 0 7 8 0 24 1 0 10 0 21 1 0 0 0 45
-                  1 0 0 0 1 2 0 0 0 56 1 2 0 0 0 0 46 2 0 22 0 0 1 2 0 22 0 0
-                  1 2 0 22 0 0 40 2 0 22 0 0 1 2 0 22 0 0 49 2 0 0 0 0 43 1 0
-                  0 0 52 2 0 0 0 0 54 2 0 0 0 0 53 2 0 0 0 56 57 2 0 0 0 101 1
-                  2 0 0 0 0 55 2 0 0 12 0 34 2 0 0 56 0 1 2 0 0 101 0 1))))))
-     (QUOTE |lookupComplete|))) 
+(DEFUN |SingleInteger;| ()
+  (PROG (|dv$| $ |pv$|)
+    (RETURN
+      (PROGN
+        (LETT |dv$| '(|SingleInteger|) |SingleInteger|)
+        (LETT $ (GETREFV 103) |SingleInteger|)
+        (QSETREFV $ 0 |dv$|)
+        (QSETREFV $ 3
+            (LETT |pv$| (|buildPredVector| 0 0 NIL) |SingleInteger|))
+        (|haddProp| |$ConstructorCache| '|SingleInteger| NIL
+            (CONS 1 $))
+        (|stuffDomainSlots| $)
+        (QSETREFV $ 6 1)
+        $))))
+
+(MAKEPROP '|SingleInteger| '|infovec|
+    (LIST '#(NIL NIL NIL NIL NIL NIL '|seed| (|Void|)
+             (|OpenMathDevice|) (0 . |OMputApp|) (|String|)
+             (5 . |OMputSymbol|) (|Integer|) (12 . |OMputInteger|)
+             (18 . |OMputEndApp|) (|OpenMathEncoding|)
+             (23 . |OMencodingXML|) (27 . |OMopenString|)
+             (33 . |OMputObject|) (38 . |OMputEndObject|)
+             (43 . |OMclose|) |SINT;OMwrite;$S;2| (|Boolean|)
+             |SINT;OMwrite;$BS;3| |SINT;OMwrite;Omd$V;4|
+             |SINT;OMwrite;Omd$BV;5| (|Matrix| 12) (|Matrix| $)
+             |SINT;reducedSystem;MM;6| (|OutputForm|) (48 . |coerce|)
+             |SINT;coerce;$Of;7| |SINT;convert;$I;8| (53 . |coerce|)
+             |SINT;*;I2$;9|
+             (CONS IDENTITY
+                   (FUNCALL (|dispatchFunction| |SINT;Zero;$;10|) $))
+             (CONS IDENTITY
+                   (FUNCALL (|dispatchFunction| |SINT;One;$;11|) $))
+             |SINT;base;$;12| |SINT;max;$;13| |SINT;min;$;14|
+             |SINT;=;2$B;15| |SINT;~;2$;16| |SINT;not;2$;17|
+             |SINT;/\\;3$;18| |SINT;\\/;3$;19| |SINT;Not;2$;20|
+             |SINT;And;3$;21| |SINT;Or;3$;22| |SINT;xor;3$;23|
+             |SINT;<;2$B;24| |SINT;inc;2$;25| |SINT;dec;2$;26|
+             |SINT;-;2$;27| |SINT;+;3$;28| |SINT;-;3$;29|
+             |SINT;*;3$;30| (|NonNegativeInteger|) |SINT;**;$Nni$;31|
+             |SINT;quo;3$;32| |SINT;rem;3$;33|
+             (|Record| (|:| |quotient| $) (|:| |remainder| $))
+             |SINT;divide;2$R;34| |SINT;gcd;3$;35| |SINT;abs;2$;36|
+             |SINT;odd?;$B;37| |SINT;zero?;$B;38| |SINT;max;3$;39|
+             |SINT;min;3$;40| |SINT;hash;2$;41| |SINT;length;2$;42|
+             |SINT;shift;3$;43| |SINT;mulmod;4$;44| |SINT;addmod;4$;45|
+             |SINT;submod;4$;46| |SINT;negative?;$B;47|
+             (|Record| (|:| |mat| 26) (|:| |vec| (|Vector| 12)))
+             (|Vector| $) |SINT;reducedSystem;MVR;48|
+             |SINT;positiveRemainder;3$;49| |SINT;coerce;I$;50|
+             |SINT;random;$;51| |SINT;random;2$;52|
+             (|Record| (|:| |unit| $) (|:| |canonical| $)
+                 (|:| |associate| $))
+             |SINT;unitNormal;$R;53| (|Union| 85 '"failed")
+             (|Fraction| 12) (|Union| $ '"failed") (|Float|)
+             (|DoubleFloat|) (|Pattern| 12) (|PatternMatchResult| 12 $)
+             (|InputForm|) (|Union| 12 '"failed")
+             (|Record| (|:| |coef| 94) (|:| |generator| $)) (|List| $)
+             (|Union| 94 '"failed")
+             (|Record| (|:| |coef1| $) (|:| |coef2| $)
+                 (|:| |generator| $))
+             (|Record| (|:| |coef1| $) (|:| |coef2| $))
+             (|Union| 97 '"failed") (|Factored| $)
+             (|SparseUnivariatePolynomial| $) (|PositiveInteger|)
+             (|SingleInteger|))
+          '#(~= 58 ~ 64 |zero?| 69 |xor| 74 |unitNormal| 80
+             |unitCanonical| 85 |unit?| 90 |symmetricRemainder| 95
+             |subtractIfCan| 101 |submod| 107 |squareFreePart| 114
+             |squareFree| 119 |sizeLess?| 124 |sign| 130 |shift| 135
+             |sample| 141 |retractIfCan| 145 |retract| 150 |rem| 155
+             |reducedSystem| 161 |recip| 172 |rationalIfCan| 177
+             |rational?| 182 |rational| 187 |random| 192 |quo| 201
+             |principalIdeal| 207 |prime?| 212 |powmod| 217
+             |positiveRemainder| 224 |positive?| 230 |permutation| 235
+             |patternMatch| 241 |one?| 248 |odd?| 253 |not| 258
+             |nextItem| 263 |negative?| 268 |multiEuclidean| 273
+             |mulmod| 279 |min| 286 |max| 296 |mask| 306 |length| 311
+             |lcm| 316 |latex| 327 |invmod| 332 |init| 338 |inc| 342
+             |hash| 347 |gcdPolynomial| 357 |gcd| 363 |factorial| 374
+             |factor| 379 |extendedEuclidean| 384 |exquo| 397
+             |expressIdealMember| 403 |even?| 409 |euclideanSize| 414
+             |divide| 419 |differentiate| 425 |dec| 436 |copy| 441
+             |convert| 446 |coerce| 471 |characteristic| 491 |bit?| 495
+             |binomial| 501 |base| 507 |associates?| 511 |addmod| 517
+             |abs| 524 ^ 529 |\\/| 541 |Zero| 547 |Or| 551 |One| 557
+             |OMwrite| 561 |Not| 585 D 590 |And| 601 >= 607 > 613 = 619
+             <= 625 < 631 |/\\| 637 - 643 + 654 ** 660 * 672)
+          '((|noetherian| . 0) (|canonicalsClosed| . 0)
+            (|canonical| . 0) (|canonicalUnitNormal| . 0)
+            (|multiplicativeValuation| . 0) (|noZeroDivisors| . 0)
+            ((|commutative| "*") . 0) (|rightUnitary| . 0)
+            (|leftUnitary| . 0) (|unitsKnown| . 0))
+          (CONS (|makeByteWordVec2| 1
+                    '(0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+                      0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+                      0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
+                      0))
+                (CONS '#(|IntegerNumberSystem&| |EuclideanDomain&|
+                         |UniqueFactorizationDomain&| NIL NIL
+                         |GcdDomain&| |IntegralDomain&| |Algebra&|
+                         |Module&| NIL |Module&| NIL NIL |Module&| NIL
+                         |DifferentialRing&| |OrderedRing&| NIL
+                         |Module&| NIL |Module&| NIL NIL NIL NIL NIL
+                         NIL |Ring&| NIL NIL NIL NIL NIL NIL NIL NIL
+                         NIL NIL NIL NIL NIL |AbelianGroup&| NIL NIL
+                         |AbelianMonoid&| |Monoid&| NIL NIL NIL NIL
+                         |OrderedSet&| |AbelianSemiGroup&| |SemiGroup&|
+                         |Logic&| NIL |SetCategory&| NIL NIL NIL NIL
+                         |RetractableTo&| NIL NIL NIL |RetractableTo&|
+                         NIL NIL NIL NIL NIL NIL |RetractableTo&| NIL
+                         |BasicType&| NIL)
+                      (CONS '#((|IntegerNumberSystem|)
+                               (|EuclideanDomain|)
+                               (|UniqueFactorizationDomain|)
+                               (|PrincipalIdealDomain|)
+                               (|OrderedIntegralDomain|) (|GcdDomain|)
+                               (|IntegralDomain|) (|Algebra| $$)
+                               (|Module| 12)
+                               (|LinearlyExplicitRingOver| 12)
+                               (|Module| G1062)
+                               (|LinearlyExplicitRingOver| G1062)
+                               (|CharacteristicZero|)
+                               (|Module| G106217)
+                               (|LinearlyExplicitRingOver| G106217)
+                               (|DifferentialRing|) (|OrderedRing|)
+                               (|CommutativeRing|) (|Module| |t#1|)
+                               (|EntireRing|) (|Module| $$)
+                               (|BiModule| 12 12)
+                               (|BiModule| G1062 G1062)
+                               (|BiModule| G106217 G106217)
+                               (|OrderedAbelianGroup|)
+                               (|BiModule| |t#1| |t#1|)
+                               (|BiModule| $$ $$) (|Ring|)
+                               (|RightModule| 12) (|LeftModule| 12)
+                               (|RightModule| G1062)
+                               (|LeftModule| G1062)
+                               (|RightModule| G106217)
+                               (|LeftModule| G106217)
+                               (|OrderedCancellationAbelianMonoid|)
+                               (|RightModule| |t#1|)
+                               (|LeftModule| |t#1|) (|LeftModule| $$)
+                               (|Rng|) (|RightModule| $$)
+                               (|OrderedAbelianMonoid|)
+                               (|AbelianGroup|)
+                               (|OrderedAbelianSemiGroup|)
+                               (|CancellationAbelianMonoid|)
+                               (|AbelianMonoid|) (|Monoid|)
+                               (|PatternMatchable| 12)
+                               (|PatternMatchable| G1065)
+                               (|StepThrough|)
+                               (|PatternMatchable| G106220)
+                               (|OrderedSet|) (|AbelianSemiGroup|)
+                               (|SemiGroup|) (|Logic|) (|RealConstant|)
+                               (|SetCategory|) (|OpenMath|)
+                               (|CoercibleTo| G82356)
+                               (|ConvertibleTo| 89)
+                               (|ConvertibleTo| 91)
+                               (|RetractableTo| 12)
+                               (|ConvertibleTo| 12)
+                               (|ConvertibleTo| G1064)
+                               (|ConvertibleTo| G1063)
+                               (|RetractableTo| G1061)
+                               (|ConvertibleTo| G1060)
+                               (|ConvertibleTo| 87)
+                               (|ConvertibleTo| 88)
+                               (|CombinatorialFunctionCategory|)
+                               (|ConvertibleTo| G106219)
+                               (|ConvertibleTo| G106218)
+                               (|RetractableTo| G106216)
+                               (|ConvertibleTo| G106215) (|BasicType|)
+                               (|CoercibleTo| 29))
+                            (|makeByteWordVec2| 102
+                                '(1 8 7 0 9 3 8 7 0 10 10 11 2 8 7 0 12
+                                  13 1 8 7 0 14 0 15 0 16 2 8 0 10 15
+                                  17 1 8 7 0 18 1 8 7 0 19 1 8 7 0 20 1
+                                  12 29 0 30 1 0 0 12 33 2 0 22 0 0 1 1
+                                  0 0 0 41 1 0 22 0 65 2 0 0 0 0 48 1 0
+                                  82 0 83 1 0 0 0 1 1 0 22 0 1 2 0 0 0
+                                  0 1 2 0 86 0 0 1 3 0 0 0 0 0 73 1 0 0
+                                  0 1 1 0 99 0 1 2 0 22 0 0 1 1 0 12 0
+                                  1 2 0 0 0 0 70 0 0 0 1 1 0 92 0 1 1 0
+                                  12 0 1 2 0 0 0 0 59 1 0 26 27 28 2 0
+                                  75 27 76 77 1 0 86 0 1 1 0 84 0 1 1 0
+                                  22 0 1 1 0 85 0 1 1 0 0 0 81 0 0 0 80
+                                  2 0 0 0 0 58 1 0 93 94 1 1 0 22 0 1 3
+                                  0 0 0 0 0 1 2 0 0 0 0 78 1 0 22 0 1 2
+                                  0 0 0 0 1 3 0 90 0 89 90 1 1 0 22 0 1
+                                  1 0 22 0 64 1 0 0 0 42 1 0 86 0 1 1 0
+                                  22 0 74 2 0 95 94 0 1 3 0 0 0 0 0 71
+                                  0 0 0 39 2 0 0 0 0 67 0 0 0 38 2 0 0
+                                  0 0 66 1 0 0 0 1 1 0 0 0 69 1 0 0 94
+                                  1 2 0 0 0 0 1 1 0 10 0 1 2 0 0 0 0 1
+                                  0 0 0 1 1 0 0 0 50 1 0 0 0 68 1 0 102
+                                  0 1 2 0 100 100 100 1 1 0 0 94 1 2 0
+                                  0 0 0 62 1 0 0 0 1 1 0 99 0 1 2 0 96
+                                  0 0 1 3 0 98 0 0 0 1 2 0 86 0 0 1 2 0
+                                  95 94 0 1 1 0 22 0 1 1 0 56 0 1 2 0
+                                  60 0 0 61 1 0 0 0 1 2 0 0 0 56 1 1 0
+                                  0 0 51 1 0 0 0 1 1 0 87 0 1 1 0 88 0
+                                  1 1 0 89 0 1 1 0 91 0 1 1 0 12 0 32 1
+                                  0 0 12 79 1 0 0 0 1 1 0 0 12 79 1 0
+                                  29 0 31 0 0 56 1 2 0 22 0 0 1 2 0 0 0
+                                  0 1 0 0 0 37 2 0 22 0 0 1 3 0 0 0 0 0
+                                  72 1 0 0 0 63 2 0 0 0 56 1 2 0 0 0
+                                  101 1 2 0 0 0 0 44 0 0 0 35 2 0 0 0 0
+                                  47 0 0 0 36 3 0 7 8 0 22 25 2 0 10 0
+                                  22 23 2 0 7 8 0 24 1 0 10 0 21 1 0 0
+                                  0 45 1 0 0 0 1 2 0 0 0 56 1 2 0 0 0 0
+                                  46 2 0 22 0 0 1 2 0 22 0 0 1 2 0 22 0
+                                  0 40 2 0 22 0 0 1 2 0 22 0 0 49 2 0 0
+                                  0 0 43 1 0 0 0 52 2 0 0 0 0 54 2 0 0
+                                  0 0 53 2 0 0 0 56 57 2 0 0 0 101 1 2
+                                  0 0 0 0 55 2 0 0 12 0 34 2 0 0 56 0 1
+                                  2 0 0 101 0 1)))))
+          '|lookupComplete|))
 
 (MAKEPROP (QUOTE |SingleInteger|) (QUOTE NILADIC) T) 
 
@@ -119724,89 +120524,785 @@ Note that this code is not included in the generated catdef.spad file.
 
 (|/VERSIONCHECK| 2) 
 
-(DEFUN |SYMBOL;writeOMSym| (|dev| |x| |$|) (COND ((SPADCALL |x| (QREFELT |$| 21)) (|error| "Cannot convert a scripted symbol to OpenMath")) ((QUOTE T) (SPADCALL |dev| |x| (QREFELT |$| 25))))) 
-
-(DEFUN |SYMBOL;OMwrite;$S;2| (|x| |$|) (PROG (|sp| |dev| |s|) (RETURN (SEQ (LETT |s| "" |SYMBOL;OMwrite;$S;2|) (LETT |sp| (|OM-STRINGTOSTRINGPTR| |s|) |SYMBOL;OMwrite;$S;2|) (LETT |dev| (SPADCALL |sp| (SPADCALL (QREFELT |$| 27)) (QREFELT |$| 29)) |SYMBOL;OMwrite;$S;2|) (SPADCALL |dev| (QREFELT |$| 30)) (|SYMBOL;writeOMSym| |dev| |x| |$|) (SPADCALL |dev| (QREFELT |$| 31)) (SPADCALL |dev| (QREFELT |$| 32)) (LETT |s| (|OM-STRINGPTRTOSTRING| |sp|) |SYMBOL;OMwrite;$S;2|) (EXIT |s|))))) 
-
-(DEFUN |SYMBOL;OMwrite;$BS;3| (|x| |wholeObj| |$|) (PROG (|sp| |dev| |s|) (RETURN (SEQ (LETT |s| "" |SYMBOL;OMwrite;$BS;3|) (LETT |sp| (|OM-STRINGTOSTRINGPTR| |s|) |SYMBOL;OMwrite;$BS;3|) (LETT |dev| (SPADCALL |sp| (SPADCALL (QREFELT |$| 27)) (QREFELT |$| 29)) |SYMBOL;OMwrite;$BS;3|) (COND (|wholeObj| (SPADCALL |dev| (QREFELT |$| 30)))) (|SYMBOL;writeOMSym| |dev| |x| |$|) (COND (|wholeObj| (SPADCALL |dev| (QREFELT |$| 31)))) (SPADCALL |dev| (QREFELT |$| 32)) (LETT |s| (|OM-STRINGPTRTOSTRING| |sp|) |SYMBOL;OMwrite;$BS;3|) (EXIT |s|))))) 
-
-(DEFUN |SYMBOL;OMwrite;Omd$V;4| (|dev| |x| |$|) (SEQ (SPADCALL |dev| (QREFELT |$| 30)) (|SYMBOL;writeOMSym| |dev| |x| |$|) (EXIT (SPADCALL |dev| (QREFELT |$| 31))))) 
+(DEFUN |SYMBOL;writeOMSym| (|dev| |x| $)
+  (COND
+    ((SPADCALL |x| (QREFELT $ 21))
+     (|error| "Cannot convert a scripted symbol to OpenMath"))
+    ('T (SPADCALL |dev| |x| (QREFELT $ 25)))))
 
-(DEFUN |SYMBOL;OMwrite;Omd$BV;5| (|dev| |x| |wholeObj| |$|) (SEQ (COND (|wholeObj| (SPADCALL |dev| (QREFELT |$| 30)))) (|SYMBOL;writeOMSym| |dev| |x| |$|) (EXIT (COND (|wholeObj| (SPADCALL |dev| (QREFELT |$| 31))))))) 
+(DEFUN |SYMBOL;OMwrite;$S;2| (|x| $)
+  (PROG (|sp| |dev| |s|)
+    (RETURN
+      (SEQ (LETT |s| "" |SYMBOL;OMwrite;$S;2|)
+           (LETT |sp| (OM-STRINGTOSTRINGPTR |s|) |SYMBOL;OMwrite;$S;2|)
+           (LETT |dev|
+                 (SPADCALL |sp| (SPADCALL (QREFELT $ 27))
+                     (QREFELT $ 29))
+                 |SYMBOL;OMwrite;$S;2|)
+           (SPADCALL |dev| (QREFELT $ 30))
+           (|SYMBOL;writeOMSym| |dev| |x| $)
+           (SPADCALL |dev| (QREFELT $ 31))
+           (SPADCALL |dev| (QREFELT $ 32))
+           (LETT |s| (OM-STRINGPTRTOSTRING |sp|) |SYMBOL;OMwrite;$S;2|)
+           (EXIT |s|)))))
+
+(DEFUN |SYMBOL;OMwrite;$BS;3| (|x| |wholeObj| $)
+  (PROG (|sp| |dev| |s|)
+    (RETURN
+      (SEQ (LETT |s| "" |SYMBOL;OMwrite;$BS;3|)
+           (LETT |sp| (OM-STRINGTOSTRINGPTR |s|)
+                 |SYMBOL;OMwrite;$BS;3|)
+           (LETT |dev|
+                 (SPADCALL |sp| (SPADCALL (QREFELT $ 27))
+                     (QREFELT $ 29))
+                 |SYMBOL;OMwrite;$BS;3|)
+           (COND (|wholeObj| (SPADCALL |dev| (QREFELT $ 30))))
+           (|SYMBOL;writeOMSym| |dev| |x| $)
+           (COND (|wholeObj| (SPADCALL |dev| (QREFELT $ 31))))
+           (SPADCALL |dev| (QREFELT $ 32))
+           (LETT |s| (OM-STRINGPTRTOSTRING |sp|)
+                 |SYMBOL;OMwrite;$BS;3|)
+           (EXIT |s|)))))
+
+(DEFUN |SYMBOL;OMwrite;Omd$V;4| (|dev| |x| $)
+  (SEQ (SPADCALL |dev| (QREFELT $ 30))
+       (|SYMBOL;writeOMSym| |dev| |x| $)
+       (EXIT (SPADCALL |dev| (QREFELT $ 31)))))
+
+(DEFUN |SYMBOL;OMwrite;Omd$BV;5| (|dev| |x| |wholeObj| $)
+  (SEQ (COND (|wholeObj| (SPADCALL |dev| (QREFELT $ 30))))
+       (|SYMBOL;writeOMSym| |dev| |x| $)
+       (EXIT (COND (|wholeObj| (SPADCALL |dev| (QREFELT $ 31)))))))
 
 (DEFUN |SYMBOL;convert;$If;6| (|s| |$|) (SPADCALL |s| (QREFELT |$| 44))) 
 
-(PUT (QUOTE |SYMBOL;convert;2$;7|) (QUOTE |SPADreplace|) (QUOTE (XLAM (|s|) |s|))) 
+(PUT '|SYMBOL;convert;2$;7| '|SPADreplace| '(XLAM (|s|) |s|))
 
 (DEFUN |SYMBOL;convert;2$;7| (|s| |$|) |s|) 
 
 (DEFUN |SYMBOL;coerce;S$;8| (|s| |$|) (VALUES (INTERN |s|))) 
 
-(PUT (QUOTE |SYMBOL;=;2$B;9|) (QUOTE |SPADreplace|) (QUOTE EQUAL)) 
+(PUT '|SYMBOL;=;2$B;9| '|SPADreplace| 'EQUAL)
 
 (DEFUN |SYMBOL;=;2$B;9| (|x| |y| |$|) (EQUAL |x| |y|)) 
 
-(PUT (QUOTE |SYMBOL;<;2$B;10|) (QUOTE |SPADreplace|) (QUOTE (XLAM (|x| |y|) (GGREATERP |y| |x|)))) 
+(PUT '|SYMBOL;<;2$B;10| '|SPADreplace|
+     '(XLAM (|x| |y|) (GGREATERP |y| |x|)))
 
 (DEFUN |SYMBOL;<;2$B;10| (|x| |y| |$|) (GGREATERP |y| |x|)) 
 
 (DEFUN |SYMBOL;coerce;$Of;11| (|x| |$|) (SPADCALL |x| (QREFELT |$| 51))) 
 
-(DEFUN |SYMBOL;subscript;$L$;12| (|sy| |lx| |$|) (SPADCALL |sy| (LIST |lx| NIL NIL NIL NIL) (QREFELT |$| 54))) 
+(DEFUN |SYMBOL;subscript;$L$;12| (|sy| |lx| $)
+  (SPADCALL |sy| (LIST |lx| NIL NIL NIL NIL) (QREFELT $ 54)))
 
-(DEFUN |SYMBOL;elt;$L$;13| (|sy| |lx| |$|) (SPADCALL |sy| |lx| (QREFELT |$| 56))) 
+(DEFUN |SYMBOL;elt;$L$;13| (|sy| |lx| $)
+  (SPADCALL |sy| |lx| (QREFELT $ 56)))
 
-(DEFUN |SYMBOL;superscript;$L$;14| (|sy| |lx| |$|) (SPADCALL |sy| (LIST NIL |lx| NIL NIL NIL) (QREFELT |$| 54))) 
+(DEFUN |SYMBOL;superscript;$L$;14| (|sy| |lx| $)
+  (SPADCALL |sy| (LIST NIL |lx| NIL NIL NIL) (QREFELT $ 54)))
 
-(DEFUN |SYMBOL;argscript;$L$;15| (|sy| |lx| |$|) (SPADCALL |sy| (LIST NIL NIL NIL NIL |lx|) (QREFELT |$| 54))) 
+(DEFUN |SYMBOL;argscript;$L$;15| (|sy| |lx| $)
+  (SPADCALL |sy| (LIST NIL NIL NIL NIL |lx|) (QREFELT $ 54)))
 
-(DEFUN |SYMBOL;patternMatch;$P2Pmr;16| (|x| |p| |l| |$|) (SPADCALL |x| |p| |l| (QREFELT |$| 63))) 
+(DEFUN |SYMBOL;patternMatch;$P2Pmr;16| (|x| |p| |l| $)
+  (SPADCALL |x| |p| |l| (QREFELT $ 63)))
 
-(DEFUN |SYMBOL;patternMatch;$P2Pmr;17| (|x| |p| |l| |$|) (SPADCALL |x| |p| |l| (QREFELT |$| 69))) 
+(DEFUN |SYMBOL;patternMatch;$P2Pmr;17| (|x| |p| |l| $)
+  (SPADCALL |x| |p| |l| (QREFELT $ 69)))
 
 (DEFUN |SYMBOL;convert;$P;18| (|x| |$|) (SPADCALL |x| (QREFELT |$| 72))) 
 
 (DEFUN |SYMBOL;convert;$P;19| (|x| |$|) (SPADCALL |x| (QREFELT |$| 74))) 
 
-(DEFUN |SYMBOL;syprefix| (|sc| |$|) (PROG (|ns| #1=#:G108218 |n| #2=#:G108219) (RETURN (SEQ (LETT |ns| (LIST (LENGTH (QVELT |sc| 3)) (LENGTH (QVELT |sc| 2)) (LENGTH (QVELT |sc| 1)) (LENGTH (QVELT |sc| 0))) |SYMBOL;syprefix|) (SEQ G190 (COND ((NULL (COND ((|<| (LENGTH |ns|) 2) (QUOTE NIL)) ((QUOTE T) (ZEROP (|SPADfirst| |ns|))))) (GO G191))) (SEQ (EXIT (LETT |ns| (CDR |ns|) |SYMBOL;syprefix|))) NIL (GO G190) G191 (EXIT NIL)) (EXIT (SPADCALL (CONS (STRCONC (QREFELT |$| 37) (|SYMBOL;istring| (LENGTH (QVELT |sc| 4)) |$|)) (PROGN (LETT #1# NIL |SYMBOL;syprefix|) (SEQ (LETT |n| NIL |SYMBOL;syprefix|) (LETT #2# (NREVERSE |ns|) |SYMBOL;syprefix|) G190 (COND ((OR (ATOM #2#) (PROGN (LETT |n| (CAR #2#) |SYMBOL;syprefix|) NIL)) (GO G191))) (SEQ (EXIT (LETT #1# (CONS (|SYMBOL;istring| |n| |$|) #1#) |SYMBOL;syprefix|))) (LETT #2# (CDR #2#) |SYMBOL;syprefix|) (GO G190) G191 (EXIT (NREVERSE0 #1#))))) (QREFELT |$| 77))))))) 
-
-(DEFUN |SYMBOL;syscripts| (|sc| |$|) (PROG (|all|) (RETURN (SEQ (LETT |all| (QVELT |sc| 3) |SYMBOL;syscripts|) (LETT |all| (SPADCALL (QVELT |sc| 2) |all| (QREFELT |$| 78)) |SYMBOL;syscripts|) (LETT |all| (SPADCALL (QVELT |sc| 1) |all| (QREFELT |$| 78)) |SYMBOL;syscripts|) (LETT |all| (SPADCALL (QVELT |sc| 0) |all| (QREFELT |$| 78)) |SYMBOL;syscripts|) (EXIT (SPADCALL |all| (QVELT |sc| 4) (QREFELT |$| 78))))))) 
-
-(DEFUN |SYMBOL;script;$L$;22| (|sy| |ls| |$|) (PROG (|sc|) (RETURN (SEQ (LETT |sc| (VECTOR NIL NIL NIL NIL NIL) |SYMBOL;script;$L$;22|) (COND ((NULL (NULL |ls|)) (SEQ (QSETVELT |sc| 0 (|SPADfirst| |ls|)) (EXIT (LETT |ls| (CDR |ls|) |SYMBOL;script;$L$;22|))))) (COND ((NULL (NULL |ls|)) (SEQ (QSETVELT |sc| 1 (|SPADfirst| |ls|)) (EXIT (LETT |ls| (CDR |ls|) |SYMBOL;script;$L$;22|))))) (COND ((NULL (NULL |ls|)) (SEQ (QSETVELT |sc| 2 (|SPADfirst| |ls|)) (EXIT (LETT |ls| (CDR |ls|) |SYMBOL;script;$L$;22|))))) (COND ((NULL (NULL |ls|)) (SEQ (QSETVELT |sc| 3 (|SPADfirst| |ls|)) (EXIT (LETT |ls| (CDR |ls|) |SYMBOL;script;$L$;22|))))) (COND ((NULL (NULL |ls|)) (SEQ (QSETVELT |sc| 4 (|SPADfirst| |ls|)) (EXIT (LETT |ls| (CDR |ls|) |SYMBOL;script;$L$;22|))))) (EXIT (SPADCALL |sy| |sc| (QREFELT |$| 80))))))) 
-
-(DEFUN |SYMBOL;script;$R$;23| (|sy| |sc| |$|) (COND ((SPADCALL |sy| (QREFELT |$| 21)) (|error| "Cannot add scripts to a scripted symbol")) ((QUOTE T) (CONS (SPADCALL (SPADCALL (STRCONC (|SYMBOL;syprefix| |sc| |$|) (SPADCALL (SPADCALL |sy| (QREFELT |$| 81)) (QREFELT |$| 82))) (QREFELT |$| 47)) (QREFELT |$| 52)) (|SYMBOL;syscripts| |sc| |$|))))) 
-
-(DEFUN |SYMBOL;string;$S;24| (|e| |$|) (COND ((NULL (SPADCALL |e| (QREFELT |$| 21))) (PNAME |e|)) ((QUOTE T) (|error| "Cannot form string from non-atomic symbols.")))) 
-
-(DEFUN |SYMBOL;latex;$S;25| (|e| |$|) (PROG (|ss| |lo| |sc| |s|) (RETURN (SEQ (LETT |s| (PNAME (SPADCALL |e| (QREFELT |$| 81))) |SYMBOL;latex;$S;25|) (COND ((|<| 1 (QCSIZE |s|)) (COND ((NULL (SPADCALL (SPADCALL |s| 1 (QREFELT |$| 83)) (SPADCALL "\\" (QREFELT |$| 40)) (QREFELT |$| 84))) (LETT |s| (STRCONC "\\mbox{\\it " (STRCONC |s| "}")) |SYMBOL;latex;$S;25|))))) (COND ((NULL (SPADCALL |e| (QREFELT |$| 21))) (EXIT |s|))) (LETT |ss| (SPADCALL |e| (QREFELT |$| 85)) |SYMBOL;latex;$S;25|) (LETT |lo| (QVELT |ss| 0) |SYMBOL;latex;$S;25|) (COND ((NULL (NULL |lo|)) (SEQ (LETT |sc| "_{" |SYMBOL;latex;$S;25|) (SEQ G190 (COND ((NULL (COND ((NULL |lo|) (QUOTE NIL)) ((QUOTE T) (QUOTE T)))) (GO G191))) (SEQ (LETT |sc| (STRCONC |sc| (SPADCALL (|SPADfirst| |lo|) (QREFELT |$| 86))) |SYMBOL;latex;$S;25|) (LETT |lo| (CDR |lo|) |SYMBOL;latex;$S;25|) (EXIT (COND ((NULL (NULL |lo|)) (LETT |sc| (STRCONC |sc| ", ") |SYMBOL;latex;$S;25|))))) NIL (GO G190) G191 (EXIT NIL)) (LETT |sc| (STRCONC |sc| "}") |SYMBOL;latex;$S;25|) (EXIT (LETT |s| (STRCONC |s| |sc|) |SYMBOL;latex;$S;25|))))) (LETT |lo| (QVELT |ss| 1) |SYMBOL;latex;$S;25|) (COND ((NULL (NULL |lo|)) (SEQ (LETT |sc| "^{" |SYMBOL;latex;$S;25|) (SEQ G190 (COND ((NULL (COND ((NULL |lo|) (QUOTE NIL)) ((QUOTE T) (QUOTE T)))) (GO G191))) (SEQ (LETT |sc| (STRCONC |sc| (SPADCALL (|SPADfirst| |lo|) (QREFELT |$| 86))) |SYMBOL;latex;$S;25|) (LETT |lo| (CDR |lo|) |SYMBOL;latex;$S;25|) (EXIT (COND ((NULL (NULL |lo|)) (LETT |sc| (STRCONC |sc| ", ") |SYMBOL;latex;$S;25|))))) NIL (GO G190) G191 (EXIT NIL)) (LETT |sc| (STRCONC |sc| "}") |SYMBOL;latex;$S;25|) (EXIT (LETT |s| (STRCONC |s| |sc|) |SYMBOL;latex;$S;25|))))) (LETT |lo| (QVELT |ss| 2) |SYMBOL;latex;$S;25|) (COND ((NULL (NULL |lo|)) (SEQ (LETT |sc| "{}^{" |SYMBOL;latex;$S;25|) (SEQ G190 (COND ((NULL (COND ((NULL |lo|) (QUOTE NIL)) ((QUOTE T) (QUOTE T)))) (GO G191))) (SEQ (LETT |sc| (STRCONC |sc| (SPADCALL (|SPADfirst| |lo|) (QREFELT |$| 86))) |SYMBOL;latex;$S;25|) (LETT |lo| (CDR |lo|) |SYMBOL;latex;$S;25|) (EXIT (COND ((NULL (NULL |lo|)) (LETT |sc| (STRCONC |sc| ", ") |SYMBOL;latex;$S;25|))))) NIL (GO G190) G191 (EXIT NIL)) (LETT |sc| (STRCONC |sc| "}") |SYMBOL;latex;$S;25|) (EXIT (LETT |s| (STRCONC |sc| |s|) |SYMBOL;latex;$S;25|))))) (LETT |lo| (QVELT |ss| 3) |SYMBOL;latex;$S;25|) (COND ((NULL (NULL |lo|)) (SEQ (LETT |sc| "{}_{" |SYMBOL;latex;$S;25|) (SEQ G190 (COND ((NULL (COND ((NULL |lo|) (QUOTE NIL)) ((QUOTE T) (QUOTE T)))) (GO G191))) (SEQ (LETT |sc| (STRCONC |sc| (SPADCALL (|SPADfirst| |lo|) (QREFELT |$| 86))) |SYMBOL;latex;$S;25|) (LETT |lo| (CDR |lo|) |SYMBOL;latex;$S;25|) (EXIT (COND ((NULL (NULL |lo|)) (LETT |sc| (STRCONC |sc| ", ") |SYMBOL;latex;$S;25|))))) NIL (GO G190) G191 (EXIT NIL)) (LETT |sc| (STRCONC |sc| "}") |SYMBOL;latex;$S;25|) (EXIT (LETT |s| (STRCONC |sc| |s|) |SYMBOL;latex;$S;25|))))) (LETT |lo| (QVELT |ss| 4) |SYMBOL;latex;$S;25|) (COND ((NULL (NULL |lo|)) (SEQ (LETT |sc| "\\left( {" |SYMBOL;latex;$S;25|) (SEQ G190 (COND ((NULL (COND ((NULL |lo|) (QUOTE NIL)) ((QUOTE T) (QUOTE T)))) (GO G191))) (SEQ (LETT |sc| (STRCONC |sc| (SPADCALL (|SPADfirst| |lo|) (QREFELT |$| 86))) |SYMBOL;latex;$S;25|) (LETT |lo| (CDR |lo|) |SYMBOL;latex;$S;25|) (EXIT (COND ((NULL (NULL |lo|)) (LETT |sc| (STRCONC |sc| ", ") |SYMBOL;latex;$S;25|))))) NIL (GO G190) G191 (EXIT NIL)) (LETT |sc| (STRCONC |sc| "} \\right)") |SYMBOL;latex;$S;25|) (EXIT (LETT |s| (STRCONC |s| |sc|) |SYMBOL;latex;$S;25|))))) (EXIT |s|))))) 
-
-(DEFUN |SYMBOL;anyRadix| (|n| |s| |$|) (PROG (|qr| |ns| #1=#:G108274) (RETURN (SEQ (EXIT (SEQ (LETT |ns| "" |SYMBOL;anyRadix|) (EXIT (SEQ G190 NIL (SEQ (LETT |qr| (DIVIDE2 |n| (QCSIZE |s|)) |SYMBOL;anyRadix|) (LETT |n| (QCAR |qr|) |SYMBOL;anyRadix|) (LETT |ns| (SPADCALL (SPADCALL |s| (|+| (QCDR |qr|) (SPADCALL |s| (QREFELT |$| 88))) (QREFELT |$| 83)) |ns| (QREFELT |$| 89)) |SYMBOL;anyRadix|) (EXIT (COND ((ZEROP |n|) (PROGN (LETT #1# |ns| |SYMBOL;anyRadix|) (GO #1#)))))) NIL (GO G190) G191 (EXIT NIL))))) #1# (EXIT #1#))))) 
-
-(DEFUN |SYMBOL;new;$;27| (|$|) (PROG (|sym|) (RETURN (SEQ (LETT |sym| (|SYMBOL;anyRadix| (SPADCALL (QREFELT |$| 9) (QREFELT |$| 90)) (QREFELT |$| 18) |$|) |SYMBOL;new;$;27|) (SPADCALL (QREFELT |$| 9) (|+| (SPADCALL (QREFELT |$| 9) (QREFELT |$| 90)) 1) (QREFELT |$| 91)) (EXIT (SPADCALL (STRCONC "%" |sym|) (QREFELT |$| 47))))))) 
-
-(DEFUN |SYMBOL;new;2$;28| (|x| |$|) (PROG (|u| |n| |xx|) (RETURN (SEQ (LETT |n| (SEQ (LETT |u| (SPADCALL |x| (QREFELT |$| 12) (QREFELT |$| 94)) |SYMBOL;new;2$;28|) (EXIT (COND ((QEQCAR |u| 1) 0) ((QUOTE T) (|+| (QCDR |u|) 1))))) |SYMBOL;new;2$;28|) (SPADCALL (QREFELT |$| 12) |x| |n| (QREFELT |$| 95)) (LETT |xx| (COND ((NULL (SPADCALL |x| (QREFELT |$| 21))) (SPADCALL |x| (QREFELT |$| 82))) ((QUOTE T) (SPADCALL (SPADCALL |x| (QREFELT |$| 81)) (QREFELT |$| 82)))) |SYMBOL;new;2$;28|) (LETT |xx| (STRCONC "%" |xx|) |SYMBOL;new;2$;28|) (LETT |xx| (COND ((NULL (|<| (SPADCALL (SPADCALL |xx| (SPADCALL |xx| (QREFELT |$| 96)) (QREFELT |$| 83)) (QREFELT |$| 17) (QREFELT |$| 97)) (SPADCALL (QREFELT |$| 17) (QREFELT |$| 88)))) (STRCONC |xx| (|SYMBOL;anyRadix| |n| (QREFELT |$| 19) |$|))) ((QUOTE T) (STRCONC |xx| (|SYMBOL;anyRadix| |n| (QREFELT |$| 17) |$|)))) |SYMBOL;new;2$;28|) (COND ((NULL (SPADCALL |x| (QREFELT |$| 21))) (EXIT (SPADCALL |xx| (QREFELT |$| 47))))) (EXIT (SPADCALL (SPADCALL |xx| (QREFELT |$| 47)) (SPADCALL |x| (QREFELT |$| 85)) (QREFELT |$| 80))))))) 
-
-(DEFUN |SYMBOL;resetNew;V;29| (|$|) (PROG (|k| #1=#:G108297) (RETURN (SEQ (SPADCALL (QREFELT |$| 9) 0 (QREFELT |$| 91)) (SEQ (LETT |k| NIL |SYMBOL;resetNew;V;29|) (LETT #1# (SPADCALL (QREFELT |$| 12) (QREFELT |$| 100)) |SYMBOL;resetNew;V;29|) G190 (COND ((OR (ATOM #1#) (PROGN (LETT |k| (CAR #1#) |SYMBOL;resetNew;V;29|) NIL)) (GO G191))) (SEQ (EXIT (SPADCALL |k| (QREFELT |$| 12) (QREFELT |$| 101)))) (LETT #1# (CDR #1#) |SYMBOL;resetNew;V;29|) (GO G190) G191 (EXIT NIL)) (EXIT (SPADCALL (QREFELT |$| 102))))))) 
-
-(DEFUN |SYMBOL;scripted?;$B;30| (|sy| |$|) (COND ((ATOM |sy|) (QUOTE NIL)) ((QUOTE T) (QUOTE T)))) 
+(DEFUN |SYMBOL;syprefix| (|sc| $)
+  (PROG (|ns| G108218 |n| G108219)
+    (RETURN
+      (SEQ (LETT |ns|
+                 (LIST (LENGTH (QVELT |sc| 3)) (LENGTH (QVELT |sc| 2))
+                       (LENGTH (QVELT |sc| 1)) (LENGTH (QVELT |sc| 0)))
+                 |SYMBOL;syprefix|)
+           (SEQ G190
+                (COND
+                  ((NULL (COND
+                           ((< (LENGTH |ns|) 2) 'NIL)
+                           ('T (ZEROP (|SPADfirst| |ns|)))))
+                   (GO G191)))
+                (SEQ (EXIT (LETT |ns| (CDR |ns|) |SYMBOL;syprefix|)))
+                NIL (GO G190) G191 (EXIT NIL))
+           (EXIT (SPADCALL
+                     (CONS (STRCONC (QREFELT $ 37)
+                                    (|SYMBOL;istring|
+                                     (LENGTH (QVELT |sc| 4)) $))
+                           (PROGN
+                             (LETT G108218 NIL |SYMBOL;syprefix|)
+                             (SEQ (LETT |n| NIL |SYMBOL;syprefix|)
+                                  (LETT G108219 (NREVERSE |ns|)
+                                        |SYMBOL;syprefix|)
+                                  G190
+                                  (COND
+                                    ((OR (ATOM G108219)
+                                      (PROGN
+                                        (LETT |n| (CAR G108219)
+                                         |SYMBOL;syprefix|)
+                                        NIL))
+                                     (GO G191)))
+                                  (SEQ (EXIT
+                                        (LETT G108218
+                                         (CONS (|SYMBOL;istring| |n| $)
+                                          G108218)
+                                         |SYMBOL;syprefix|)))
+                                  (LETT G108219 (CDR G108219)
+                                        |SYMBOL;syprefix|)
+                                  (GO G190) G191
+                                  (EXIT (NREVERSE0 G108218)))))
+                     (QREFELT $ 77)))))))
+
+(DEFUN |SYMBOL;syscripts| (|sc| $)
+  (PROG (|all|)
+    (RETURN
+      (SEQ (LETT |all| (QVELT |sc| 3) |SYMBOL;syscripts|)
+           (LETT |all| (SPADCALL (QVELT |sc| 2) |all| (QREFELT $ 78))
+                 |SYMBOL;syscripts|)
+           (LETT |all| (SPADCALL (QVELT |sc| 1) |all| (QREFELT $ 78))
+                 |SYMBOL;syscripts|)
+           (LETT |all| (SPADCALL (QVELT |sc| 0) |all| (QREFELT $ 78))
+                 |SYMBOL;syscripts|)
+           (EXIT (SPADCALL |all| (QVELT |sc| 4) (QREFELT $ 78)))))))
+
+(DEFUN |SYMBOL;script;$L$;22| (|sy| |ls| $)
+  (PROG (|sc|)
+    (RETURN
+      (SEQ (LETT |sc| (VECTOR NIL NIL NIL NIL NIL)
+                 |SYMBOL;script;$L$;22|)
+           (COND
+             ((NULL (NULL |ls|))
+              (SEQ (QSETVELT |sc| 0 (|SPADfirst| |ls|))
+                   (EXIT (LETT |ls| (CDR |ls|) |SYMBOL;script;$L$;22|)))))
+           (COND
+             ((NULL (NULL |ls|))
+              (SEQ (QSETVELT |sc| 1 (|SPADfirst| |ls|))
+                   (EXIT (LETT |ls| (CDR |ls|) |SYMBOL;script;$L$;22|)))))
+           (COND
+             ((NULL (NULL |ls|))
+              (SEQ (QSETVELT |sc| 2 (|SPADfirst| |ls|))
+                   (EXIT (LETT |ls| (CDR |ls|) |SYMBOL;script;$L$;22|)))))
+           (COND
+             ((NULL (NULL |ls|))
+              (SEQ (QSETVELT |sc| 3 (|SPADfirst| |ls|))
+                   (EXIT (LETT |ls| (CDR |ls|) |SYMBOL;script;$L$;22|)))))
+           (COND
+             ((NULL (NULL |ls|))
+              (SEQ (QSETVELT |sc| 4 (|SPADfirst| |ls|))
+                   (EXIT (LETT |ls| (CDR |ls|) |SYMBOL;script;$L$;22|)))))
+           (EXIT (SPADCALL |sy| |sc| (QREFELT $ 80)))))))
 
-(DEFUN |SYMBOL;name;2$;31| (|sy| |$|) (PROG (|str| |i| #1=#:G108304 #2=#:G108303 #3=#:G108301) (RETURN (SEQ (EXIT (COND ((NULL (SPADCALL |sy| (QREFELT |$| 21))) |sy|) ((QUOTE T) (SEQ (LETT |str| (SPADCALL (SPADCALL (SPADCALL |sy| (QREFELT |$| 104)) (QREFELT |$| 105)) (QREFELT |$| 82)) |SYMBOL;name;2$;31|) (SEQ (EXIT (SEQ (LETT |i| (|+| (QREFELT |$| 38) 1) |SYMBOL;name;2$;31|) (LETT #1# (QCSIZE |str|) |SYMBOL;name;2$;31|) G190 (COND ((|>| |i| #1#) (GO G191))) (SEQ (EXIT (COND ((NULL (SPADCALL (SPADCALL |str| |i| (QREFELT |$| 83)) (QREFELT |$| 106))) (PROGN (LETT #3# (PROGN (LETT #2# (SPADCALL (SPADCALL |str| (SPADCALL |i| (QCSIZE |str|) (QREFELT |$| 108)) (QREFELT |$| 109)) (QREFELT |$| 47)) |SYMBOL;name;2$;31|) (GO #2#)) |SYMBOL;name;2$;31|) (GO #3#)))))) (LETT |i| (|+| |i| 1) |SYMBOL;name;2$;31|) (GO G190) G191 (EXIT NIL))) #3# (EXIT #3#)) (EXIT (|error| "Improper scripted symbol")))))) #2# (EXIT #2#))))) 
+(DEFUN |SYMBOL;script;$R$;23| (|sy| |sc| $)
+  (COND
+    ((SPADCALL |sy| (QREFELT $ 21))
+     (|error| "Cannot add scripts to a scripted symbol"))
+    ('T
+     (CONS (SPADCALL
+               (SPADCALL
+                   (STRCONC (|SYMBOL;syprefix| |sc| $)
+                            (SPADCALL (SPADCALL |sy| (QREFELT $ 81))
+                                (QREFELT $ 82)))
+                   (QREFELT $ 47))
+               (QREFELT $ 52))
+           (|SYMBOL;syscripts| |sc| $)))))
+
+(DEFUN |SYMBOL;string;$S;24| (|e| $)
+  (COND
+    ((NULL (SPADCALL |e| (QREFELT $ 21))) (PNAME |e|))
+    ('T (|error| "Cannot form string from non-atomic symbols."))))
 
-(DEFUN |SYMBOL;scripts;$R;32| (|sy| |$|) (PROG (|lscripts| |str| |nstr| |j| #1=#:G108307 |nscripts| |m| |n| #2=#:G108316 |i| #3=#:G108317 |a| #4=#:G108318 |allscripts|) (RETURN (SEQ (COND ((NULL (SPADCALL |sy| (QREFELT |$| 21))) (VECTOR NIL NIL NIL NIL NIL)) ((QUOTE T) (SEQ (LETT |nscripts| (LIST 0 0 0 0 0) |SYMBOL;scripts;$R;32|) (LETT |lscripts| (LIST NIL NIL NIL NIL NIL) |SYMBOL;scripts;$R;32|) (LETT |str| (SPADCALL (SPADCALL (SPADCALL |sy| (QREFELT |$| 104)) (QREFELT |$| 105)) (QREFELT |$| 82)) |SYMBOL;scripts;$R;32|) (LETT |nstr| (QCSIZE |str|) |SYMBOL;scripts;$R;32|) (LETT |m| (SPADCALL |nscripts| (QREFELT |$| 111)) |SYMBOL;scripts;$R;32|) (SEQ (LETT |j| (|+| (QREFELT |$| 38) 1) |SYMBOL;scripts;$R;32|) (LETT |i| |m| |SYMBOL;scripts;$R;32|) G190 (COND ((OR (|>| |j| |nstr|) (NULL (SPADCALL (SPADCALL |str| |j| (QREFELT |$| 83)) (QREFELT |$| 106)))) (GO G191))) (SEQ (EXIT (SPADCALL |nscripts| |i| (PROG1 (LETT #1# (|-| (SPADCALL (SPADCALL |str| |j| (QREFELT |$| 83)) (QREFELT |$| 41)) (QREFELT |$| 42)) |SYMBOL;scripts;$R;32|) (|check-subtype| (|>=| #1# 0) (QUOTE (|NonNegativeInteger|)) #1#)) (QREFELT |$| 113)))) (LETT |i| (PROG1 (|+| |i| 1) (LETT |j| (|+| |j| 1) |SYMBOL;scripts;$R;32|)) |SYMBOL;scripts;$R;32|) (GO G190) G191 (EXIT NIL)) (LETT |nscripts| (SPADCALL (CDR |nscripts|) (|SPADfirst| |nscripts|) (QREFELT |$| 114)) |SYMBOL;scripts;$R;32|) (LETT |allscripts| (SPADCALL (SPADCALL |sy| (QREFELT |$| 104)) (QREFELT |$| 115)) |SYMBOL;scripts;$R;32|) (LETT |m| (SPADCALL |lscripts| (QREFELT |$| 116)) |SYMBOL;scripts;$R;32|) (SEQ (LETT |n| NIL |SYMBOL;scripts;$R;32|) (LETT #2# |nscripts| |SYMBOL;scripts;$R;32|) (LETT |i| |m| |SYMBOL;scripts;$R;32|) G190 (COND ((OR (ATOM #2#) (PROGN (LETT |n| (CAR #2#) |SYMBOL;scripts;$R;32|) NIL)) (GO G191))) (SEQ (EXIT (COND ((|<| (SPADCALL |allscripts| (QREFELT |$| 117)) |n|) (|error| "Improper script count in symbol")) ((QUOTE T) (SEQ (SPADCALL |lscripts| |i| (PROGN (LETT #3# NIL |SYMBOL;scripts;$R;32|) (SEQ (LETT |a| NIL |SYMBOL;scripts;$R;32|) (LETT #4# (SPADCALL |allscripts| |n| (QREFELT |$| 118)) |SYMBOL;scripts;$R;32|) G190 (COND ((OR (ATOM #4#) (PROGN (LETT |a| (CAR #4#) |SYMBOL;scripts;$R;32|) NIL)) (GO G191))) (SEQ (EXIT (LETT #3# (CONS (SPADCALL |a| (QREFELT |$| 52)) #3#) |SYMBOL;scripts;$R;32|))) (LETT #4# (CDR #4#) |SYMBOL;scripts;$R;32|) (GO G190) G191 (EXIT (NREVERSE0 #3#)))) (QREFELT |$| 119)) (EXIT (LETT |allscripts| (SPADCALL |allscripts| |n| (QREFELT |$| 120)) |SYMBOL;scripts;$R;32|))))))) (LETT |i| (PROG1 (|+| |i| 1) (LETT #2# (CDR #2#) |SYMBOL;scripts;$R;32|)) |SYMBOL;scripts;$R;32|) (GO G190) G191 (EXIT NIL)) (EXIT (VECTOR (SPADCALL |lscripts| |m| (QREFELT |$| 121)) (SPADCALL |lscripts| (|+| |m| 1) (QREFELT |$| 121)) (SPADCALL |lscripts| (|+| |m| 2) (QREFELT |$| 121)) (SPADCALL |lscripts| (|+| |m| 3) (QREFELT |$| 121)) (SPADCALL |lscripts| (|+| |m| 4) (QREFELT |$| 121))))))))))) 
+(DEFUN |SYMBOL;latex;$S;25| (|e| $)
+  (PROG (|ss| |lo| |sc| |s|)
+    (RETURN
+      (SEQ (LETT |s| (PNAME (SPADCALL |e| (QREFELT $ 81)))
+                 |SYMBOL;latex;$S;25|)
+           (COND
+             ((< 1 (QCSIZE |s|))
+              (COND
+                ((NULL (SPADCALL (SPADCALL |s| 1 (QREFELT $ 83))
+                           (SPADCALL "\\" (QREFELT $ 40))
+                           (QREFELT $ 84)))
+                 (LETT |s| (STRCONC "\\mbox{\\it " (STRCONC |s| "}"))
+                       |SYMBOL;latex;$S;25|)))))
+           (COND ((NULL (SPADCALL |e| (QREFELT $ 21))) (EXIT |s|)))
+           (LETT |ss| (SPADCALL |e| (QREFELT $ 85))
+                 |SYMBOL;latex;$S;25|)
+           (LETT |lo| (QVELT |ss| 0) |SYMBOL;latex;$S;25|)
+           (COND
+             ((NULL (NULL |lo|))
+              (SEQ (LETT |sc| "_{" |SYMBOL;latex;$S;25|)
+                   (SEQ G190
+                        (COND
+                          ((NULL (COND ((NULL |lo|) 'NIL) ('T 'T)))
+                           (GO G191)))
+                        (SEQ (LETT |sc|
+                                   (STRCONC |sc|
+                                    (SPADCALL (|SPADfirst| |lo|)
+                                     (QREFELT $ 86)))
+                                   |SYMBOL;latex;$S;25|)
+                             (LETT |lo| (CDR |lo|)
+                                   |SYMBOL;latex;$S;25|)
+                             (EXIT (COND
+                                     ((NULL (NULL |lo|))
+                                      (LETT |sc| (STRCONC |sc| ", ")
+                                       |SYMBOL;latex;$S;25|)))))
+                        NIL (GO G190) G191 (EXIT NIL))
+                   (LETT |sc| (STRCONC |sc| "}") |SYMBOL;latex;$S;25|)
+                   (EXIT (LETT |s| (STRCONC |s| |sc|)
+                               |SYMBOL;latex;$S;25|)))))
+           (LETT |lo| (QVELT |ss| 1) |SYMBOL;latex;$S;25|)
+           (COND
+             ((NULL (NULL |lo|))
+              (SEQ (LETT |sc| "^{" |SYMBOL;latex;$S;25|)
+                   (SEQ G190
+                        (COND
+                          ((NULL (COND ((NULL |lo|) 'NIL) ('T 'T)))
+                           (GO G191)))
+                        (SEQ (LETT |sc|
+                                   (STRCONC |sc|
+                                    (SPADCALL (|SPADfirst| |lo|)
+                                     (QREFELT $ 86)))
+                                   |SYMBOL;latex;$S;25|)
+                             (LETT |lo| (CDR |lo|)
+                                   |SYMBOL;latex;$S;25|)
+                             (EXIT (COND
+                                     ((NULL (NULL |lo|))
+                                      (LETT |sc| (STRCONC |sc| ", ")
+                                       |SYMBOL;latex;$S;25|)))))
+                        NIL (GO G190) G191 (EXIT NIL))
+                   (LETT |sc| (STRCONC |sc| "}") |SYMBOL;latex;$S;25|)
+                   (EXIT (LETT |s| (STRCONC |s| |sc|)
+                               |SYMBOL;latex;$S;25|)))))
+           (LETT |lo| (QVELT |ss| 2) |SYMBOL;latex;$S;25|)
+           (COND
+             ((NULL (NULL |lo|))
+              (SEQ (LETT |sc| "{}^{" |SYMBOL;latex;$S;25|)
+                   (SEQ G190
+                        (COND
+                          ((NULL (COND ((NULL |lo|) 'NIL) ('T 'T)))
+                           (GO G191)))
+                        (SEQ (LETT |sc|
+                                   (STRCONC |sc|
+                                    (SPADCALL (|SPADfirst| |lo|)
+                                     (QREFELT $ 86)))
+                                   |SYMBOL;latex;$S;25|)
+                             (LETT |lo| (CDR |lo|)
+                                   |SYMBOL;latex;$S;25|)
+                             (EXIT (COND
+                                     ((NULL (NULL |lo|))
+                                      (LETT |sc| (STRCONC |sc| ", ")
+                                       |SYMBOL;latex;$S;25|)))))
+                        NIL (GO G190) G191 (EXIT NIL))
+                   (LETT |sc| (STRCONC |sc| "}") |SYMBOL;latex;$S;25|)
+                   (EXIT (LETT |s| (STRCONC |sc| |s|)
+                               |SYMBOL;latex;$S;25|)))))
+           (LETT |lo| (QVELT |ss| 3) |SYMBOL;latex;$S;25|)
+           (COND
+             ((NULL (NULL |lo|))
+              (SEQ (LETT |sc| "{}_{" |SYMBOL;latex;$S;25|)
+                   (SEQ G190
+                        (COND
+                          ((NULL (COND ((NULL |lo|) 'NIL) ('T 'T)))
+                           (GO G191)))
+                        (SEQ (LETT |sc|
+                                   (STRCONC |sc|
+                                    (SPADCALL (|SPADfirst| |lo|)
+                                     (QREFELT $ 86)))
+                                   |SYMBOL;latex;$S;25|)
+                             (LETT |lo| (CDR |lo|)
+                                   |SYMBOL;latex;$S;25|)
+                             (EXIT (COND
+                                     ((NULL (NULL |lo|))
+                                      (LETT |sc| (STRCONC |sc| ", ")
+                                       |SYMBOL;latex;$S;25|)))))
+                        NIL (GO G190) G191 (EXIT NIL))
+                   (LETT |sc| (STRCONC |sc| "}") |SYMBOL;latex;$S;25|)
+                   (EXIT (LETT |s| (STRCONC |sc| |s|)
+                               |SYMBOL;latex;$S;25|)))))
+           (LETT |lo| (QVELT |ss| 4) |SYMBOL;latex;$S;25|)
+           (COND
+             ((NULL (NULL |lo|))
+              (SEQ (LETT |sc| "\\left( {" |SYMBOL;latex;$S;25|)
+                   (SEQ G190
+                        (COND
+                          ((NULL (COND ((NULL |lo|) 'NIL) ('T 'T)))
+                           (GO G191)))
+                        (SEQ (LETT |sc|
+                                   (STRCONC |sc|
+                                    (SPADCALL (|SPADfirst| |lo|)
+                                     (QREFELT $ 86)))
+                                   |SYMBOL;latex;$S;25|)
+                             (LETT |lo| (CDR |lo|)
+                                   |SYMBOL;latex;$S;25|)
+                             (EXIT (COND
+                                     ((NULL (NULL |lo|))
+                                      (LETT |sc| (STRCONC |sc| ", ")
+                                       |SYMBOL;latex;$S;25|)))))
+                        NIL (GO G190) G191 (EXIT NIL))
+                   (LETT |sc| (STRCONC |sc| "} \\right)")
+                         |SYMBOL;latex;$S;25|)
+                   (EXIT (LETT |s| (STRCONC |s| |sc|)
+                               |SYMBOL;latex;$S;25|)))))
+           (EXIT |s|)))))
+
+(DEFUN |SYMBOL;anyRadix| (|n| |s| $)
+  (PROG (|qr| |ns| G108274)
+    (RETURN
+      (SEQ (EXIT (SEQ (LETT |ns| "" |SYMBOL;anyRadix|)
+                      (EXIT (SEQ G190 NIL
+                                 (SEQ (LETT |qr|
+                                       (DIVIDE2 |n| (QCSIZE |s|))
+                                       |SYMBOL;anyRadix|)
+                                      (LETT |n| (QCAR |qr|)
+                                       |SYMBOL;anyRadix|)
+                                      (LETT |ns|
+                                       (SPADCALL
+                                        (SPADCALL |s|
+                                         (+ (QCDR |qr|)
+                                          (SPADCALL |s| (QREFELT $ 88)))
+                                         (QREFELT $ 83))
+                                        |ns| (QREFELT $ 89))
+                                       |SYMBOL;anyRadix|)
+                                      (EXIT
+                                       (COND
+                                         ((ZEROP |n|)
+                                          (PROGN
+                                            (LETT G108274 |ns|
+                                             |SYMBOL;anyRadix|)
+                                            (GO G108274))))))
+                                 NIL (GO G190) G191 (EXIT NIL)))))
+           G108274 (EXIT G108274)))))
+
+(DEFUN |SYMBOL;new;$;27| ($)
+  (PROG (|sym|)
+    (RETURN
+      (SEQ (LETT |sym|
+                 (|SYMBOL;anyRadix|
+                     (SPADCALL (QREFELT $ 9) (QREFELT $ 90))
+                     (QREFELT $ 18) $)
+                 |SYMBOL;new;$;27|)
+           (SPADCALL (QREFELT $ 9)
+               (+ (SPADCALL (QREFELT $ 9) (QREFELT $ 90)) 1)
+               (QREFELT $ 91))
+           (EXIT (SPADCALL (STRCONC "%" |sym|) (QREFELT $ 47)))))))
+
+(DEFUN |SYMBOL;new;2$;28| (|x| $)
+  (PROG (|u| |n| |xx|)
+    (RETURN
+      (SEQ (LETT |n|
+                 (SEQ (LETT |u|
+                            (SPADCALL |x| (QREFELT $ 12)
+                                (QREFELT $ 94))
+                            |SYMBOL;new;2$;28|)
+                      (EXIT (COND
+                              ((QEQCAR |u| 1) 0)
+                              ('T (+ (QCDR |u|) 1)))))
+                 |SYMBOL;new;2$;28|)
+           (SPADCALL (QREFELT $ 12) |x| |n| (QREFELT $ 95))
+           (LETT |xx|
+                 (COND
+                   ((NULL (SPADCALL |x| (QREFELT $ 21)))
+                    (SPADCALL |x| (QREFELT $ 82)))
+                   ('T
+                    (SPADCALL (SPADCALL |x| (QREFELT $ 81))
+                        (QREFELT $ 82))))
+                 |SYMBOL;new;2$;28|)
+           (LETT |xx| (STRCONC "%" |xx|) |SYMBOL;new;2$;28|)
+           (LETT |xx|
+                 (COND
+                   ((NULL (< (SPADCALL
+                                 (SPADCALL |xx|
+                                     (SPADCALL |xx| (QREFELT $ 96))
+                                     (QREFELT $ 83))
+                                 (QREFELT $ 17) (QREFELT $ 97))
+                             (SPADCALL (QREFELT $ 17) (QREFELT $ 88))))
+                    (STRCONC |xx|
+                             (|SYMBOL;anyRadix| |n| (QREFELT $ 19) $)))
+                   ('T
+                    (STRCONC |xx|
+                             (|SYMBOL;anyRadix| |n| (QREFELT $ 17) $))))
+                 |SYMBOL;new;2$;28|)
+           (COND
+             ((NULL (SPADCALL |x| (QREFELT $ 21)))
+              (EXIT (SPADCALL |xx| (QREFELT $ 47)))))
+           (EXIT (SPADCALL (SPADCALL |xx| (QREFELT $ 47))
+                     (SPADCALL |x| (QREFELT $ 85)) (QREFELT $ 80)))))))
 
-(DEFUN |SYMBOL;istring| (|n| |$|) (COND ((|<| 9 |n|) (|error| "Can have at most 9 scripts of each kind")) ((QUOTE T) (ELT (QREFELT |$| 16) (|+| |n| 0))))) 
+(DEFUN |SYMBOL;resetNew;V;29| ($)
+  (PROG (|k| G108297)
+    (RETURN
+      (SEQ (SPADCALL (QREFELT $ 9) 0 (QREFELT $ 91))
+           (SEQ (LETT |k| NIL |SYMBOL;resetNew;V;29|)
+                (LETT G108297 (SPADCALL (QREFELT $ 12) (QREFELT $ 100))
+                      |SYMBOL;resetNew;V;29|)
+                G190
+                (COND
+                  ((OR (ATOM G108297)
+                       (PROGN
+                         (LETT |k| (CAR G108297)
+                               |SYMBOL;resetNew;V;29|)
+                         NIL))
+                   (GO G191)))
+                (SEQ (EXIT (SPADCALL |k| (QREFELT $ 12)
+                               (QREFELT $ 101))))
+                (LETT G108297 (CDR G108297) |SYMBOL;resetNew;V;29|)
+                (GO G190) G191 (EXIT NIL))
+           (EXIT (SPADCALL (QREFELT $ 102)))))))
+
+(DEFUN |SYMBOL;scripted?;$B;30| (|sy| $)
+  (COND ((ATOM |sy|) 'NIL) ('T 'T)))
+
+(DEFUN |SYMBOL;name;2$;31| (|sy| $)
+  (PROG (|str| |i| G108304 G108303 G108301)
+    (RETURN
+      (SEQ (EXIT (COND
+                   ((NULL (SPADCALL |sy| (QREFELT $ 21))) |sy|)
+                   ('T
+                    (SEQ (LETT |str|
+                               (SPADCALL
+                                   (SPADCALL
+                                    (SPADCALL |sy| (QREFELT $ 104))
+                                    (QREFELT $ 105))
+                                   (QREFELT $ 82))
+                               |SYMBOL;name;2$;31|)
+                         (SEQ (EXIT (SEQ
+                                     (LETT |i| (+ (QREFELT $ 38) 1)
+                                      |SYMBOL;name;2$;31|)
+                                     (LETT G108304 (QCSIZE |str|)
+                                      |SYMBOL;name;2$;31|)
+                                     G190
+                                     (COND
+                                       ((> |i| G108304) (GO G191)))
+                                     (SEQ
+                                      (EXIT
+                                       (COND
+                                         ((NULL
+                                           (SPADCALL
+                                            (SPADCALL |str| |i|
+                                             (QREFELT $ 83))
+                                            (QREFELT $ 106)))
+                                          (PROGN
+                                            (LETT G108301
+                                             (PROGN
+                                               (LETT G108303
+                                                (SPADCALL
+                                                 (SPADCALL |str|
+                                                  (SPADCALL |i|
+                                                   (QCSIZE |str|)
+                                                   (QREFELT $ 108))
+                                                  (QREFELT $ 109))
+                                                 (QREFELT $ 47))
+                                                |SYMBOL;name;2$;31|)
+                                               (GO G108303))
+                                             |SYMBOL;name;2$;31|)
+                                            (GO G108301))))))
+                                     (LETT |i| (+ |i| 1)
+                                      |SYMBOL;name;2$;31|)
+                                     (GO G190) G191 (EXIT NIL)))
+                              G108301 (EXIT G108301))
+                         (EXIT (|error| "Improper scripted symbol"))))))
+           G108303 (EXIT G108303)))))
+
+(DEFUN |SYMBOL;scripts;$R;32| (|sy| $)
+  (PROG (|lscripts| |str| |nstr| |j| G108307 |nscripts| |m| |n| G108316
+            |i| G108317 |a| G108318 |allscripts|)
+    (RETURN
+      (SEQ (COND
+             ((NULL (SPADCALL |sy| (QREFELT $ 21)))
+              (VECTOR NIL NIL NIL NIL NIL))
+             ('T
+              (SEQ (LETT |nscripts| (LIST 0 0 0 0 0)
+                         |SYMBOL;scripts;$R;32|)
+                   (LETT |lscripts| (LIST NIL NIL NIL NIL NIL)
+                         |SYMBOL;scripts;$R;32|)
+                   (LETT |str|
+                         (SPADCALL
+                             (SPADCALL (SPADCALL |sy| (QREFELT $ 104))
+                                 (QREFELT $ 105))
+                             (QREFELT $ 82))
+                         |SYMBOL;scripts;$R;32|)
+                   (LETT |nstr| (QCSIZE |str|) |SYMBOL;scripts;$R;32|)
+                   (LETT |m| (SPADCALL |nscripts| (QREFELT $ 111))
+                         |SYMBOL;scripts;$R;32|)
+                   (SEQ (LETT |j| (+ (QREFELT $ 38) 1)
+                              |SYMBOL;scripts;$R;32|)
+                        (LETT |i| |m| |SYMBOL;scripts;$R;32|) G190
+                        (COND
+                          ((OR (> |j| |nstr|)
+                               (NULL (SPADCALL
+                                      (SPADCALL |str| |j|
+                                       (QREFELT $ 83))
+                                      (QREFELT $ 106))))
+                           (GO G191)))
+                        (SEQ (EXIT (SPADCALL |nscripts| |i|
+                                    (PROG1
+                                     (LETT G108307
+                                      (-
+                                       (SPADCALL
+                                        (SPADCALL |str| |j|
+                                         (QREFELT $ 83))
+                                        (QREFELT $ 41))
+                                       (QREFELT $ 42))
+                                      |SYMBOL;scripts;$R;32|)
+                                      (|check-subtype| (>= G108307 0)
+                                       '(|NonNegativeInteger|) G108307))
+                                    (QREFELT $ 113))))
+                        (LETT |i|
+                              (PROG1 (+ |i| 1)
+                                (LETT |j| (+ |j| 1)
+                                      |SYMBOL;scripts;$R;32|))
+                              |SYMBOL;scripts;$R;32|)
+                        (GO G190) G191 (EXIT NIL))
+                   (LETT |nscripts|
+                         (SPADCALL (CDR |nscripts|)
+                             (|SPADfirst| |nscripts|) (QREFELT $ 114))
+                         |SYMBOL;scripts;$R;32|)
+                   (LETT |allscripts|
+                         (SPADCALL (SPADCALL |sy| (QREFELT $ 104))
+                             (QREFELT $ 115))
+                         |SYMBOL;scripts;$R;32|)
+                   (LETT |m| (SPADCALL |lscripts| (QREFELT $ 116))
+                         |SYMBOL;scripts;$R;32|)
+                   (SEQ (LETT |n| NIL |SYMBOL;scripts;$R;32|)
+                        (LETT G108316 |nscripts|
+                              |SYMBOL;scripts;$R;32|)
+                        (LETT |i| |m| |SYMBOL;scripts;$R;32|) G190
+                        (COND
+                          ((OR (ATOM G108316)
+                               (PROGN
+                                 (LETT |n| (CAR G108316)
+                                       |SYMBOL;scripts;$R;32|)
+                                 NIL))
+                           (GO G191)))
+                        (SEQ (EXIT (COND
+                                     ((<
+                                       (SPADCALL |allscripts|
+                                        (QREFELT $ 117))
+                                       |n|)
+                                      (|error|
+                                       "Improper script count in symbol"))
+                                     ('T
+                                      (SEQ
+                                       (SPADCALL |lscripts| |i|
+                                        (PROGN
+                                          (LETT G108317 NIL
+                                           |SYMBOL;scripts;$R;32|)
+                                          (SEQ
+                                           (LETT |a| NIL
+                                            |SYMBOL;scripts;$R;32|)
+                                           (LETT G108318
+                                            (SPADCALL |allscripts| |n|
+                                             (QREFELT $ 118))
+                                            |SYMBOL;scripts;$R;32|)
+                                           G190
+                                           (COND
+                                             ((OR (ATOM G108318)
+                                               (PROGN
+                                                 (LETT |a|
+                                                  (CAR G108318)
+                                                  |SYMBOL;scripts;$R;32|)
+                                                 NIL))
+                                              (GO G191)))
+                                           (SEQ
+                                            (EXIT
+                                             (LETT G108317
+                                              (CONS
+                                               (SPADCALL |a|
+                                                (QREFELT $ 52))
+                                               G108317)
+                                              |SYMBOL;scripts;$R;32|)))
+                                           (LETT G108318 (CDR G108318)
+                                            |SYMBOL;scripts;$R;32|)
+                                           (GO G190) G191
+                                           (EXIT (NREVERSE0 G108317))))
+                                        (QREFELT $ 119))
+                                       (EXIT
+                                        (LETT |allscripts|
+                                         (SPADCALL |allscripts| |n|
+                                          (QREFELT $ 120))
+                                         |SYMBOL;scripts;$R;32|)))))))
+                        (LETT |i|
+                              (PROG1 (+ |i| 1)
+                                (LETT G108316 (CDR G108316)
+                                      |SYMBOL;scripts;$R;32|))
+                              |SYMBOL;scripts;$R;32|)
+                        (GO G190) G191 (EXIT NIL))
+                   (EXIT (VECTOR (SPADCALL |lscripts| |m|
+                                     (QREFELT $ 121))
+                                 (SPADCALL |lscripts| (+ |m| 1)
+                                     (QREFELT $ 121))
+                                 (SPADCALL |lscripts| (+ |m| 2)
+                                     (QREFELT $ 121))
+                                 (SPADCALL |lscripts| (+ |m| 3)
+                                     (QREFELT $ 121))
+                                 (SPADCALL |lscripts| (+ |m| 4)
+                                     (QREFELT $ 121)))))))))))
+
+(DEFUN |SYMBOL;istring| (|n| $)
+  (COND
+    ((< 9 |n|) (|error| "Can have at most 9 scripts of each kind"))
+    ('T (ELT (QREFELT $ 16) (+ |n| 0)))))
 
-(DEFUN |SYMBOL;list;$L;34| (|sy| |$|) (COND ((NULL (SPADCALL |sy| (QREFELT |$| 21))) (|error| "Cannot convert a symbol to a list if it is not subscripted")) ((QUOTE T) |sy|))) 
+(DEFUN |SYMBOL;list;$L;34| (|sy| $)
+  (COND
+    ((NULL (SPADCALL |sy| (QREFELT $ 21)))
+     (|error| "Cannot convert a symbol to a list if it is not subscripted"))
+    ('T |sy|)))
 
 (DEFUN |SYMBOL;sample;$;35| (|$|) (SPADCALL "aSymbol" (QREFELT |$| 47))) 
 
-(DEFUN |Symbol| NIL (PROG NIL (RETURN (PROG (#1=#:G108325) (RETURN (COND ((LETT #1# (HGET |$ConstructorCache| (QUOTE |Symbol|)) |Symbol|) (|CDRwithIncrement| (CDAR #1#))) ((QUOTE T) (|UNWIND-PROTECT| (PROG1 (CDDAR (HPUT |$ConstructorCache| (QUOTE |Symbol|) (LIST (CONS NIL (CONS 1 (|Symbol;|)))))) (LETT #1# T |Symbol|)) (COND ((NOT #1#) (HREM |$ConstructorCache| (QUOTE |Symbol|)))))))))))) 
-
-(DEFUN |Symbol;| NIL (PROG (|dv$| |$| |pv$|) (RETURN (PROGN (LETT |dv$| (QUOTE (|Symbol|)) . #1=(|Symbol|)) (LETT |$| (GETREFV 124) . #1#) (QSETREFV |$| 0 |dv$|) (QSETREFV |$| 3 (LETT |pv$| (|buildPredVector| 0 0 NIL) . #1#)) (|haddProp| |$ConstructorCache| (QUOTE |Symbol|) NIL (CONS 1 |$|)) (|stuffDomainSlots| |$|) (QSETREFV |$| 9 (SPADCALL 0 (QREFELT |$| 8))) (QSETREFV |$| 12 (SPADCALL (QREFELT |$| 11))) (QSETREFV |$| 16 (SPADCALL (LIST #2="0" "1" "2" "3" "4" "5" "6" "7" "8" "9") (QREFELT |$| 15))) (QSETREFV |$| 17 "0123456789") (QSETREFV |$| 18 "ABCDEFGHIJKLMNOPQRSTUVWXYZ") (QSETREFV |$| 19 "abcdefghijklmnopqrstuvwxyz") (QSETREFV |$| 37 "*") (QSETREFV |$| 38 (QCSIZE (QREFELT |$| 37))) (QSETREFV |$| 42 (SPADCALL (SPADCALL #2# (QREFELT |$| 40)) (QREFELT |$| 41))) |$|)))) 
+(DEFUN |Symbol| ()
+  (PROG ()
+    (RETURN
+      (PROG (G108325)
+        (RETURN
+          (COND
+            ((LETT G108325 (HGET |$ConstructorCache| '|Symbol|)
+                   |Symbol|)
+             (|CDRwithIncrement| (CDAR G108325)))
+            ('T
+             (UNWIND-PROTECT
+               (PROG1 (CDDAR (HPUT |$ConstructorCache| '|Symbol|
+                                   (LIST
+                                    (CONS NIL (CONS 1 (|Symbol;|))))))
+                 (LETT G108325 T |Symbol|))
+               (COND
+                 ((NOT G108325) (HREM |$ConstructorCache| '|Symbol|)))))))))))
 
-(MAKEPROP (QUOTE |Symbol|) (QUOTE |infovec|) (LIST (QUOTE #(NIL NIL NIL NIL NIL NIL (|Integer|) (|Reference| 6) (0 . |ref|) (QUOTE |count|) (|AssociationList| |$$| 6) (5 . |empty|) (QUOTE |xcount|) (|List| 28) (|PrimitiveArray| 28) (9 . |construct|) (QUOTE |istrings|) (QUOTE |nums|) (QUOTE ALPHAS) (QUOTE |alphas|) (|Boolean|) |SYMBOL;scripted?;$B;30| (|Void|) (|Symbol|) (|OpenMathDevice|) (14 . |OMputVariable|) (|OpenMathEncoding|) (20 . |OMencodingXML|) (|String|) (24 . |OMopenString|) (30 . |OMputObject|) (35 . |OMputEndObject|) (40 . |OMclose|) |SYMBOL;OMwrite;$S;2| |SYMBOL;OMwrite;$BS;3| |SYMBOL;OMwrite;Omd$V;4| |SYMBOL;OMwrite;Omd$BV;5| (QUOTE |hd|) (QUOTE |lhd|) (|Character|) (45 . |char|) (50 . |ord|) (QUOTE |ord0|) (|InputForm|) (55 . |convert|) |SYMBOL;convert;$If;6| |SYMBOL;convert;2$;7| |SYMBOL;coerce;S$;8| |SYMBOL;=;2$B;9| |SYMBOL;<;2$B;10| (|OutputForm|) (60 . |outputForm|) |SYMBOL;coerce;$Of;11| (|List| 55) |SYMBOL;script;$L$;22| (|List| 50) |SYMBOL;subscript;$L$;12| |SYMBOL;elt;$L$;13| |SYMBOL;superscript;$L$;14| |SYMBOL;argscript;$L$;15| (|PatternMatchResult| 6 23) (|Pattern| 6) (|PatternMatchSymbol| 6) (65 . |patternMatch|) (|PatternMatchResult| 6 |$|) |SYMBOL;patternMatch;$P2Pmr;16| (|PatternMatchResult| (|Float|) 23) (|Pattern| (|Float|)) (|PatternMatchSymbol| (|Float|)) (72 . |patternMatch|) (|PatternMatchResult| (|Float|) |$|) |SYMBOL;patternMatch;$P2Pmr;17| (79 . |coerce|) |SYMBOL;convert;$P;18| (84 . |coerce|) |SYMBOL;convert;$P;19| (|List| |$|) (89 . |concat|) (94 . |concat|) (|Record| (|:| |sub| 55) (|:| |sup| 55) (|:| |presup| 55) (|:| |presub| 55) (|:| |args| 55)) |SYMBOL;script;$R$;23| |SYMBOL;name;2$;31| |SYMBOL;string;$S;24| (100 . |elt|) (106 . |=|) |SYMBOL;scripts;$R;32| (112 . |latex|) |SYMBOL;latex;$S;25| (117 . |minIndex|) (122 . |concat|) (128 . |elt|) (133 . |setelt|) |SYMBOL;new;$;27| (|Union| 6 (QUOTE "failed")) (139 . |search|) (145 . |setelt|) (152 . |maxIndex|) (157 . |position|) |SYMBOL;new;2$;28| (|List| |$$|) (163 . |keys|) (168 . |remove!|) (174 . |void|) |SYMBOL;resetNew;V;29| |SYMBOL;list;$L;34| (178 . |first|) (183 . |digit?|) (|UniversalSegment| 6) (188 . SEGMENT) (194 . |elt|) (|List| 112) (200 . |minIndex|) (|NonNegativeInteger|) (205 . |setelt|) (212 . |concat|) (218 . |rest|) (223 . |minIndex|) (228 . |#|) (233 . |first|) (239 . |setelt|) (246 . |rest|) (252 . |elt|) (CONS IDENTITY (FUNCALL (|dispatchFunction| |SYMBOL;sample;$;35|) |$|)) (|SingleInteger|))) (QUOTE #(|~=| 258 |superscript| 264 |subscript| 270 |string| 276 |scripts| 281 |scripted?| 286 |script| 291 |sample| 303 |resetNew| 307 |patternMatch| 311 |new| 325 |name| 334 |min| 339 |max| 345 |list| 351 |latex| 356 |hash| 361 |elt| 366 |convert| 372 |coerce| 392 |argscript| 402 |OMwrite| 408 |>=| 432 |>| 438 |=| 444 |<=| 450 |<| 456)) (QUOTE NIL) (CONS (|makeByteWordVec2| 1 (QUOTE (0 0 0 0 0 0 0 0 0 0 0))) (CONS (QUOTE #(|OrderedSet&| NIL NIL |SetCategory&| |BasicType&| NIL NIL NIL NIL NIL NIL)) (CONS (QUOTE #((|OrderedSet|) (|PatternMatchable| (|Float|)) (|PatternMatchable| 6) (|SetCategory|) (|BasicType|) (|ConvertibleTo| 67) (|ConvertibleTo| 61) (|ConvertibleTo| 23) (|OpenMath|) (|ConvertibleTo| 43) (|CoercibleTo| 50))) (|makeByteWordVec2| 123 (QUOTE (1 7 0 6 8 0 10 0 11 1 14 0 13 15 2 24 22 0 23 25 0 26 0 27 2 24 0 28 26 29 1 24 22 0 30 1 24 22 0 31 1 24 22 0 32 1 39 0 28 40 1 39 6 0 41 1 43 0 23 44 1 50 0 23 51 3 62 60 23 61 60 63 3 68 66 23 67 66 69 1 67 0 23 72 1 61 0 23 74 1 28 0 76 77 2 55 0 0 0 78 2 28 39 0 6 83 2 39 20 0 0 84 1 50 28 0 86 1 28 6 0 88 2 28 0 39 0 89 1 7 6 0 90 2 7 6 0 6 91 2 10 93 2 0 94 3 10 6 0 2 6 95 1 28 6 0 96 2 28 6 39 0 97 1 10 99 0 100 2 10 93 2 0 101 0 22 0 102 1 99 2 0 105 1 39 20 0 106 2 107 0 6 6 108 2 28 0 0 107 109 1 110 6 0 111 3 110 112 0 6 112 113 2 110 0 0 112 114 1 99 0 0 115 1 53 6 0 116 1 99 112 0 117 2 99 0 0 112 118 3 53 55 0 6 55 119 2 99 0 0 112 120 2 53 55 0 6 121 2 0 20 0 0 1 2 0 0 0 55 58 2 0 0 0 55 56 1 0 28 0 82 1 0 79 0 85 1 0 20 0 21 2 0 0 0 53 54 2 0 0 0 79 80 0 0 0 122 0 0 22 103 3 0 64 0 61 64 65 3 0 70 0 67 70 71 1 0 0 0 98 0 0 0 92 1 0 0 0 81 2 0 0 0 0 1 2 0 0 0 0 1 1 0 76 0 104 1 0 28 0 87 1 0 123 0 1 2 0 0 0 55 57 1 0 61 0 75 1 0 67 0 73 1 0 23 0 46 1 0 43 0 45 1 0 0 28 47 1 0 50 0 52 2 0 0 0 55 59 3 0 22 24 0 20 36 2 0 28 0 20 34 2 0 22 24 0 35 1 0 28 0 33 2 0 20 0 0 1 2 0 20 0 0 1 2 0 20 0 0 48 2 0 20 0 0 1 2 0 20 0 0 49)))))) (QUOTE |lookupComplete|))) 
+(DEFUN |Symbol;| ()
+  (PROG (|dv$| $ |pv$|)
+    (RETURN
+      (PROGN
+        (LETT |dv$| '(|Symbol|) |Symbol|)
+        (LETT $ (GETREFV 124) |Symbol|)
+        (QSETREFV $ 0 |dv$|)
+        (QSETREFV $ 3
+            (LETT |pv$| (|buildPredVector| 0 0 NIL) |Symbol|))
+        (|haddProp| |$ConstructorCache| '|Symbol| NIL (CONS 1 $))
+        (|stuffDomainSlots| $)
+        (QSETREFV $ 9 (SPADCALL 0 (QREFELT $ 8)))
+        (QSETREFV $ 12 (SPADCALL (QREFELT $ 11)))
+        (QSETREFV $ 16
+            (SPADCALL (LIST "0" "1" "2" "3" "4" "5" "6" "7" "8" "9")
+                (QREFELT $ 15)))
+        (QSETREFV $ 17 "0123456789")
+        (QSETREFV $ 18 "ABCDEFGHIJKLMNOPQRSTUVWXYZ")
+        (QSETREFV $ 19 "abcdefghijklmnopqrstuvwxyz")
+        (QSETREFV $ 37 "*")
+        (QSETREFV $ 38 (QCSIZE (QREFELT $ 37)))
+        (QSETREFV $ 42
+            (SPADCALL (SPADCALL "0" (QREFELT $ 40)) (QREFELT $ 41)))
+        $))))
+
+(MAKEPROP '|Symbol| '|infovec|
+    (LIST '#(NIL NIL NIL NIL NIL NIL (|Integer|) (|Reference| 6)
+             (0 . |ref|) '|count| (|AssociationList| $$ 6)
+             (5 . |empty|) '|xcount| (|List| 28) (|PrimitiveArray| 28)
+             (9 . |construct|) '|istrings| '|nums| 'ALPHAS '|alphas|
+             (|Boolean|) |SYMBOL;scripted?;$B;30| (|Void|) (|Symbol|)
+             (|OpenMathDevice|) (14 . |OMputVariable|)
+             (|OpenMathEncoding|) (20 . |OMencodingXML|) (|String|)
+             (24 . |OMopenString|) (30 . |OMputObject|)
+             (35 . |OMputEndObject|) (40 . |OMclose|)
+             |SYMBOL;OMwrite;$S;2| |SYMBOL;OMwrite;$BS;3|
+             |SYMBOL;OMwrite;Omd$V;4| |SYMBOL;OMwrite;Omd$BV;5| '|hd|
+             '|lhd| (|Character|) (45 . |char|) (50 . |ord|) '|ord0|
+             (|InputForm|) (55 . |convert|) |SYMBOL;convert;$If;6|
+             |SYMBOL;convert;2$;7| |SYMBOL;coerce;S$;8|
+             |SYMBOL;=;2$B;9| |SYMBOL;<;2$B;10| (|OutputForm|)
+             (60 . |outputForm|) |SYMBOL;coerce;$Of;11| (|List| 55)
+             |SYMBOL;script;$L$;22| (|List| 50)
+             |SYMBOL;subscript;$L$;12| |SYMBOL;elt;$L$;13|
+             |SYMBOL;superscript;$L$;14| |SYMBOL;argscript;$L$;15|
+             (|PatternMatchResult| 6 23) (|Pattern| 6)
+             (|PatternMatchSymbol| 6) (65 . |patternMatch|)
+             (|PatternMatchResult| 6 $) |SYMBOL;patternMatch;$P2Pmr;16|
+             (|PatternMatchResult| (|Float|) 23) (|Pattern| (|Float|))
+             (|PatternMatchSymbol| (|Float|)) (72 . |patternMatch|)
+             (|PatternMatchResult| (|Float|) $)
+             |SYMBOL;patternMatch;$P2Pmr;17| (79 . |coerce|)
+             |SYMBOL;convert;$P;18| (84 . |coerce|)
+             |SYMBOL;convert;$P;19| (|List| $) (89 . |concat|)
+             (94 . |concat|)
+             (|Record| (|:| |sub| 55) (|:| |sup| 55) (|:| |presup| 55)
+                 (|:| |presub| 55) (|:| |args| 55))
+             |SYMBOL;script;$R$;23| |SYMBOL;name;2$;31|
+             |SYMBOL;string;$S;24| (100 . |elt|) (106 . =)
+             |SYMBOL;scripts;$R;32| (112 . |latex|)
+             |SYMBOL;latex;$S;25| (117 . |minIndex|) (122 . |concat|)
+             (128 . |elt|) (133 . |setelt|) |SYMBOL;new;$;27|
+             (|Union| 6 '"failed") (139 . |search|) (145 . |setelt|)
+             (152 . |maxIndex|) (157 . |position|) |SYMBOL;new;2$;28|
+             (|List| $$) (163 . |keys|) (168 . |remove!|)
+             (174 . |void|) |SYMBOL;resetNew;V;29| |SYMBOL;list;$L;34|
+             (178 . |first|) (183 . |digit?|) (|UniversalSegment| 6)
+             (188 . SEGMENT) (194 . |elt|) (|List| 112)
+             (200 . |minIndex|) (|NonNegativeInteger|) (205 . |setelt|)
+             (212 . |concat|) (218 . |rest|) (223 . |minIndex|)
+             (228 . |#|) (233 . |first|) (239 . |setelt|)
+             (246 . |rest|) (252 . |elt|)
+             (CONS IDENTITY
+                   (FUNCALL (|dispatchFunction| |SYMBOL;sample;$;35|)
+                            $))
+             (|SingleInteger|))
+          '#(~= 258 |superscript| 264 |subscript| 270 |string| 276
+             |scripts| 281 |scripted?| 286 |script| 291 |sample| 303
+             |resetNew| 307 |patternMatch| 311 |new| 325 |name| 334
+             |min| 339 |max| 345 |list| 351 |latex| 356 |hash| 361
+             |elt| 366 |convert| 372 |coerce| 392 |argscript| 402
+             |OMwrite| 408 >= 432 > 438 = 444 <= 450 < 456)
+          'NIL
+          (CONS (|makeByteWordVec2| 1 '(0 0 0 0 0 0 0 0 0 0 0))
+                (CONS '#(|OrderedSet&| NIL NIL |SetCategory&|
+                         |BasicType&| NIL NIL NIL NIL NIL NIL)
+                      (CONS '#((|OrderedSet|)
+                               (|PatternMatchable| (|Float|))
+                               (|PatternMatchable| 6) (|SetCategory|)
+                               (|BasicType|) (|ConvertibleTo| 67)
+                               (|ConvertibleTo| 61)
+                               (|ConvertibleTo| 23) (|OpenMath|)
+                               (|ConvertibleTo| 43) (|CoercibleTo| 50))
+                            (|makeByteWordVec2| 123
+                                '(1 7 0 6 8 0 10 0 11 1 14 0 13 15 2 24
+                                  22 0 23 25 0 26 0 27 2 24 0 28 26 29
+                                  1 24 22 0 30 1 24 22 0 31 1 24 22 0
+                                  32 1 39 0 28 40 1 39 6 0 41 1 43 0 23
+                                  44 1 50 0 23 51 3 62 60 23 61 60 63 3
+                                  68 66 23 67 66 69 1 67 0 23 72 1 61 0
+                                  23 74 1 28 0 76 77 2 55 0 0 0 78 2 28
+                                  39 0 6 83 2 39 20 0 0 84 1 50 28 0 86
+                                  1 28 6 0 88 2 28 0 39 0 89 1 7 6 0 90
+                                  2 7 6 0 6 91 2 10 93 2 0 94 3 10 6 0
+                                  2 6 95 1 28 6 0 96 2 28 6 39 0 97 1
+                                  10 99 0 100 2 10 93 2 0 101 0 22 0
+                                  102 1 99 2 0 105 1 39 20 0 106 2 107
+                                  0 6 6 108 2 28 0 0 107 109 1 110 6 0
+                                  111 3 110 112 0 6 112 113 2 110 0 0
+                                  112 114 1 99 0 0 115 1 53 6 0 116 1
+                                  99 112 0 117 2 99 0 0 112 118 3 53 55
+                                  0 6 55 119 2 99 0 0 112 120 2 53 55 0
+                                  6 121 2 0 20 0 0 1 2 0 0 0 55 58 2 0
+                                  0 0 55 56 1 0 28 0 82 1 0 79 0 85 1 0
+                                  20 0 21 2 0 0 0 53 54 2 0 0 0 79 80 0
+                                  0 0 122 0 0 22 103 3 0 64 0 61 64 65
+                                  3 0 70 0 67 70 71 1 0 0 0 98 0 0 0 92
+                                  1 0 0 0 81 2 0 0 0 0 1 2 0 0 0 0 1 1
+                                  0 76 0 104 1 0 28 0 87 1 0 123 0 1 2
+                                  0 0 0 55 57 1 0 61 0 75 1 0 67 0 73 1
+                                  0 23 0 46 1 0 43 0 45 1 0 0 28 47 1 0
+                                  50 0 52 2 0 0 0 55 59 3 0 22 24 0 20
+                                  36 2 0 28 0 20 34 2 0 22 24 0 35 1 0
+                                  28 0 33 2 0 20 0 0 1 2 0 20 0 0 1 2 0
+                                  20 0 0 48 2 0 20 0 0 1 2 0 20 0 0 49)))))
+          '|lookupComplete|))
+
+(MAKEPROP '|Symbol| 'NILADIC T)
 
-(MAKEPROP (QUOTE |Symbol|) (QUOTE NILADIC) T) 
 @
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section{VECTOR.lsp BOOTSTRAP} 
@@ -119832,71 +121328,76 @@ Note that this code is not included in the generated catdef.spad file.
    (SPADCALL (SPADCALL |x| (QREFELT |$| 15)) (QREFELT |$| 16)))
   (QREFELT |$| 18))) 
 
-(DEFUN |Vector| (#1=#:G84134)
- (PROG NIL
-  (RETURN
-   (PROG (#2=#:G84135)
+(DEFUN |Vector| (G84134)
+  (PROG ()
     (RETURN
-     (COND
-      ((LETT #2#
-        (|lassocShiftWithFunction| (LIST (|devaluate| #1#)) (HGET |$ConstructorCache| (QUOTE |Vector|)) (QUOTE |domainEqualList|))
-        |Vector|)
-         (|CDRwithIncrement| #2#))
-      ((QUOTE T)
-       (|UNWIND-PROTECT|
-        (PROG1
-         (|Vector;| #1#)
-         (LETT #2# T |Vector|))
-        (COND ((NOT #2#) (HREM |$ConstructorCache| (QUOTE |Vector|)))))))))))) 
+      (PROG (G84135)
+        (RETURN
+          (COND
+            ((LETT G84135
+                   (|lassocShiftWithFunction|
+                       (LIST (|devaluate| G84134))
+                       (HGET |$ConstructorCache| '|Vector|)
+                       '|domainEqualList|)
+                   |Vector|)
+             (|CDRwithIncrement| G84135))
+            ('T
+             (UNWIND-PROTECT
+               (PROG1 (|Vector;| G84134) (LETT G84135 T |Vector|))
+               (COND
+                 ((NOT G84135) (HREM |$ConstructorCache| '|Vector|)))))))))))
 
 (DEFUN |Vector;| (|#1|)
- (PROG (|DV$1| |dv$| |$| #1=#:G84133 |pv$|)
-  (RETURN
-   (PROGN
-    (LETT |DV$1| (|devaluate| |#1|) . #2=(|Vector|))
-    (LETT |dv$| (LIST (QUOTE |Vector|) |DV$1|) . #2#)
-    (LETT |$| (GETREFV 36) . #2#)
-    (QSETREFV |$| 0 |dv$|)
-    (QSETREFV |$| 3
-     (LETT |pv$|
-      (|buildPredVector| 0 0
-       (LIST
-        (|HasCategory| |#1| (QUOTE (|SetCategory|)))
-        (|HasCategory| |#1| (QUOTE (|ConvertibleTo| (|InputForm|))))
-        (LETT #1# (|HasCategory| |#1| (QUOTE (|OrderedSet|))) . #2#)
-        (OR #1# (|HasCategory| |#1| (QUOTE (|SetCategory|))))
-        (|HasCategory| (|Integer|) (QUOTE (|OrderedSet|)))
-        (|HasCategory| |#1| (QUOTE (|AbelianSemiGroup|)))
-        (|HasCategory| |#1| (QUOTE (|AbelianMonoid|)))
-        (|HasCategory| |#1| (QUOTE (|AbelianGroup|)))
-        (|HasCategory| |#1| (QUOTE (|Monoid|)))
-        (|HasCategory| |#1| (QUOTE (|Ring|)))
-        (AND
-         (|HasCategory| |#1| (QUOTE (|RadicalCategory|)))
-         (|HasCategory| |#1| (QUOTE (|Ring|))))
-        (AND
-         (|HasCategory| |#1| (LIST (QUOTE |Evalable|) (|devaluate| |#1|)))
-         (|HasCategory| |#1| (QUOTE (|SetCategory|))))
-        (OR
-         (AND
-          (|HasCategory| |#1| (LIST (QUOTE |Evalable|) (|devaluate| |#1|)))
-          #1#)
-         (AND
-          (|HasCategory| |#1| (LIST (QUOTE |Evalable|) (|devaluate| |#1|)))
-          (|HasCategory| |#1| (QUOTE (|SetCategory|)))))))
-      . #2#))
-    (|haddProp|
-     |$ConstructorCache|
-     (QUOTE |Vector|)
-     (LIST |DV$1|)
-     (CONS 1 |$|))
-    (|stuffDomainSlots| |$|)
-    (QSETREFV |$| 6 |#1|)
-    (COND
-     ((|testBitVector| |pv$| 2)
-       (QSETREFV |$| 19
-         (CONS (|dispatchFunction| |VECTOR;convert;$If;2|) |$|))))
-    |$|)))) 
+  (PROG (DV$1 |dv$| $ G84133 |pv$|)
+    (RETURN
+      (PROGN
+        (LETT DV$1 (|devaluate| |#1|) |Vector|)
+        (LETT |dv$| (LIST '|Vector| DV$1) |Vector|)
+        (LETT $ (GETREFV 36) |Vector|)
+        (QSETREFV $ 0 |dv$|)
+        (QSETREFV $ 3
+            (LETT |pv$|
+                  (|buildPredVector| 0 0
+                      (LIST (|HasCategory| |#1| '(|SetCategory|))
+                            (|HasCategory| |#1|
+                                '(|ConvertibleTo| (|InputForm|)))
+                            (LETT G84133
+                                  (|HasCategory| |#1| '(|OrderedSet|))
+                                  |Vector|)
+                            (OR G84133
+                                (|HasCategory| |#1| '(|SetCategory|)))
+                            (|HasCategory| (|Integer|) '(|OrderedSet|))
+                            (|HasCategory| |#1| '(|AbelianSemiGroup|))
+                            (|HasCategory| |#1| '(|AbelianMonoid|))
+                            (|HasCategory| |#1| '(|AbelianGroup|))
+                            (|HasCategory| |#1| '(|Monoid|))
+                            (|HasCategory| |#1| '(|Ring|))
+                            (AND (|HasCategory| |#1|
+                                     '(|RadicalCategory|))
+                                 (|HasCategory| |#1| '(|Ring|)))
+                            (AND (|HasCategory| |#1|
+                                     (LIST '|Evalable|
+                                      (|devaluate| |#1|)))
+                                 (|HasCategory| |#1| '(|SetCategory|)))
+                            (OR (AND (|HasCategory| |#1|
+                                      (LIST '|Evalable|
+                                       (|devaluate| |#1|)))
+                                     G84133)
+                                (AND (|HasCategory| |#1|
+                                      (LIST '|Evalable|
+                                       (|devaluate| |#1|)))
+                                     (|HasCategory| |#1|
+                                      '(|SetCategory|))))))
+                  |Vector|))
+        (|haddProp| |$ConstructorCache| '|Vector| (LIST DV$1)
+            (CONS 1 $))
+        (|stuffDomainSlots| $)
+        (QSETREFV $ 6 |#1|)
+        (COND
+          ((|testBitVector| |pv$| 2)
+           (QSETREFV $ 19
+               (CONS (|dispatchFunction| |VECTOR;convert;$If;2|) $))))
+        $))))
 
 (MAKEPROP
  (QUOTE |Vector|)
diff --git a/changelog b/changelog
index 0fde41b..69b830a 100644
--- a/changelog
+++ b/changelog
@@ -1,3 +1,5 @@
+20091114 tpd src/axiom-website/patches.html 20091114.01.tpd.patch
+20091114 tpd books/bookvol10.3 clean up bootstrap lisp code format
 20091112 tpd src/axiom-website/patches.html 20091112.04.tpd.patch
 20091112 tpd src/interp/nci.lisp merge osyscmd
 20091112 tpd src/interp/osyscmd.lisp removed, merged with nci
diff --git a/src/axiom-website/patches.html b/src/axiom-website/patches.html
index 4424e56..6d631b2 100644
--- a/src/axiom-website/patches.html
+++ b/src/axiom-website/patches.html
@@ -2255,5 +2255,7 @@ src/interp/i-syscmd remove unused parseFromString<br/>
 bookvol5 tree shake nci and osyscmd functions<br/>
 <a href="patches/20091112.04.tpd.patch">20091112.04.tpd.patch</a>
 src/interp/nci.lisp merge and remove osyscmd.lisp<br/>
+<a href="patches/20091114.01.tpd.patch">20091114.01.tpd.patch</a>
+books/bookvol10.3 clean up bootstrap lisp code format<br/>
  </body>
 </html>
