diff --git a/changelog b/changelog
index dad6010..c57185c 100644
--- a/changelog
+++ b/changelog
@@ -1,3 +1,5 @@
+20091006 tpd src/axiom-website/patches.html 20091006.05.tpd.patch
+20091006 tpd src/interp/g-util.lisp cleanup
 20091006 tpd src/axiom-website/patches.html 20091006.04.tpd.patch
 20091006 tpd src/interp/hypertex.lisp cleanup
 20091006 tpd src/axiom-website/patches.html 20091006.03.tpd.patch
diff --git a/src/axiom-website/patches.html b/src/axiom-website/patches.html
index 2e8b13f..cb0ad00 100644
--- a/src/axiom-website/patches.html
+++ b/src/axiom-website/patches.html
@@ -2115,5 +2115,7 @@ src/interp/i-code.lisp cleanup<br/>
 src/interp/i-analy.lisp cleanup<br/>
 <a href="patches/20091006.04.tpd.patch">20091006.04.tpd.patch</a>
 src/interp/hypertex.lisp cleanup<br/>
+<a href="patches/20091006.05.tpd.patch">20091006.05.tpd.patch</a>
+src/interp/g-util.lisp cleanup<br/>
  </body>
 </html>
diff --git a/src/interp/g-util.lisp.pamphlet b/src/interp/g-util.lisp.pamphlet
index 3ab1f6b..65b95a2 100644
--- a/src/interp/g-util.lisp.pamphlet
+++ b/src/interp/g-util.lisp.pamphlet
@@ -20,16 +20,17 @@
 ;    x
 
 (DEFUN |PPtoFile| (|x| |fname|)
- (PROG (|stream|)
-  (RETURN
-   (PROGN 
-    (SPADLET |stream|
-     (DEFIOSTREAM
-      (CONS
-       (CONS (QUOTE MODE) (QUOTE OUTPUT))
-       (CONS (CONS (QUOTE FILE) |fname|) NIL))
-       80 0))
-    (PRETTYPRINT |x| |stream|) (SHUT |stream|) |x|)))) 
+  (PROG (|stream|)
+    (RETURN
+      (PROGN
+        (SPADLET |stream|
+                 (DEFIOSTREAM
+                     (CONS (CONS 'MODE 'OUTPUT)
+                           (CONS (CONS 'FILE |fname|) NIL))
+                     80 0))
+        (PRETTYPRINT |x| |stream|)
+        (SHUT |stream|)
+        |x|))))
 
 ;bool x ==
 ;    NULL NULL x
@@ -52,22 +53,20 @@
 ;pairList(u,v) == [[x,:y] for x in u for y in v]
 
 (DEFUN |pairList| (|u| |v|)
- (PROG NIL
-  (RETURN
-   (SEQ
-    (PROG (#0=#:G1403)
-     (SPADLET #0# NIL)
-     (RETURN
-      (DO ((#1=#:G1404 |u| (CDR #1#))
-           (|x| NIL)
-           (#2=#:G1405 |v| (CDR #2#))
-           (|y| NIL))
-          ((OR (ATOM #1#)
-               (PROGN (SETQ |x| (CAR #1#)) NIL)
-               (ATOM #2#)
-               (PROGN (SETQ |y| (CAR #2#)) NIL))
-            (NREVERSE0 #0#))
-      (SEQ (EXIT (SETQ #0# (CONS (CONS |x| |y|) #0#))))))))))) 
+  (PROG ()
+    (RETURN
+      (SEQ (PROG (G1403)
+             (SPADLET G1403 NIL)
+             (RETURN
+               (DO ((G1404 |u| (CDR G1404)) (|x| NIL)
+                    (G1405 |v| (CDR G1405)) (|y| NIL))
+                   ((OR (ATOM G1404)
+                        (PROGN (SETQ |x| (CAR G1404)) NIL)
+                        (ATOM G1405)
+                        (PROGN (SETQ |y| (CAR G1405)) NIL))
+                    (NREVERSE0 G1403))
+                 (SEQ (EXIT (SETQ G1403
+                                  (CONS (CONS |x| |y|) G1403)))))))))))
 
 ;GETALIST(alist,prop) == CDR assoc(prop,alist)
 
@@ -84,17 +83,16 @@
 ;  alist
 
 (DEFUN PUTALIST (|alist| |prop| |val|)
- (PROG (|pair|)
-  (RETURN
-   (COND
-    ((NULL |alist|) (CONS (CONS |prop| |val|) NIL))
-    ((SPADLET |pair| (|assoc| |prop| |alist|))
-     (COND
-      ((BOOT-EQUAL (CDR |pair|) |val|) |alist|)
-      ((QUOTE T) (QRPLACD |pair| |val|) |alist|)))
-    ((QUOTE T)
-     (QRPLACD (LASTPAIR |alist|) (CONS (CONS |prop| |val|) NIL))
-     |alist|))))) 
+  (PROG (|pair|)
+    (RETURN
+      (COND
+        ((NULL |alist|) (CONS (CONS |prop| |val|) NIL))
+        ((SPADLET |pair| (|assoc| |prop| |alist|))
+         (COND
+           ((BOOT-EQUAL (CDR |pair|) |val|) |alist|)
+           ('T (QRPLACD |pair| |val|) |alist|)))
+        ('T (QRPLACD (LASTPAIR |alist|) (CONS (CONS |prop| |val|) NIL))
+         |alist|)))))
 
 ;REMALIST(alist,prop) ==
 ;  null alist => alist
@@ -115,41 +113,34 @@
 ;  alist
 
 (DEFUN REMALIST (|alist| |prop|)
- (PROG (|ISTMP#1| |p| |r| |l| |ok|)
-  (RETURN
-   (SEQ
-    (COND
-     ((NULL |alist|) |alist|)
-     ((AND
-       (PAIRP |alist|)
-        (PROGN
-         (SPADLET |ISTMP#1| (QCAR |alist|))
-         (AND (PAIRP |ISTMP#1|) (EQUAL (QCAR |ISTMP#1|) |prop|)))
-        (PROGN (SPADLET |r| (QCDR |alist|)) (QUOTE T)))
-      (COND
-       ((NULL |r|) NIL)
-       ((QUOTE T)
-        (QRPLACA |alist| (CAR |r|))
-        (QRPLACD |alist| (CDR |r|))
-        |alist|)))
-     ((NULL (CDR |alist|)) |alist|)
-     ((QUOTE T)
-      (SPADLET |l| |alist|)
-      (SPADLET |ok| (QUOTE T))
-      (DO ()
-          ((NULL |ok|)
-            NIL)
-       (SEQ
-        (EXIT
-         (PROGN
-          (SPADLET |p| (CAADR |l|))
-          (SPADLET |r| (CDDR |l|))
-          (COND
-           ((BOOT-EQUAL |p| |prop|) (SPADLET |ok| NIL) (QRPLACD |l| |r|))
-           ((OR (NULL (SPADLET |l| (QCDR |l|))) (NULL (CDR |l|)))
-            (SPADLET |ok| NIL))
-           ((QUOTE T) NIL))))))
-      |alist|)))))) 
+  (PROG (|ISTMP#1| |p| |r| |l| |ok|)
+    (RETURN
+      (SEQ (COND
+             ((NULL |alist|) |alist|)
+             ((AND (PAIRP |alist|)
+                   (PROGN
+                     (SPADLET |ISTMP#1| (QCAR |alist|))
+                     (AND (PAIRP |ISTMP#1|)
+                          (EQUAL (QCAR |ISTMP#1|) |prop|)))
+                   (PROGN (SPADLET |r| (QCDR |alist|)) 'T))
+              (COND
+                ((NULL |r|) NIL)
+                ('T (QRPLACA |alist| (CAR |r|))
+                 (QRPLACD |alist| (CDR |r|)) |alist|)))
+             ((NULL (CDR |alist|)) |alist|)
+             ('T (SPADLET |l| |alist|) (SPADLET |ok| 'T)
+              (DO () ((NULL |ok|) NIL)
+                (SEQ (EXIT (PROGN
+                             (SPADLET |p| (CAADR |l|))
+                             (SPADLET |r| (CDDR |l|))
+                             (COND
+                               ((BOOT-EQUAL |p| |prop|)
+                                (SPADLET |ok| NIL) (QRPLACD |l| |r|))
+                               ((OR (NULL (SPADLET |l| (QCDR |l|)))
+                                    (NULL (CDR |l|)))
+                                (SPADLET |ok| NIL))
+                               ('T NIL))))))
+              |alist|))))))
 
 ;deleteLassoc(x,y) ==
 ;  y is [[a,:.],:y'] =>
@@ -158,21 +149,19 @@
 ;  y
 
 (DEFUN |deleteLassoc| (|x| |y|)
- (PROG (|ISTMP#1| |a| |y'|)
-  (RETURN
-   (COND
-    ((AND
-      (PAIRP |y|)
-      (PROGN
-       (SPADLET |ISTMP#1| (QCAR |y|))
-       (AND
-        (PAIRP |ISTMP#1|)
-        (PROGN (SPADLET |a| (QCAR |ISTMP#1|)) (QUOTE T))))
-      (PROGN (SPADLET |y'| (QCDR |y|)) (QUOTE T)))
-     (COND
-      ((EQ |x| |a|) |y'|)
-      ((QUOTE T) (CONS (CAR |y|) (|deleteLassoc| |x| |y'|)))))
-    ((QUOTE T) |y|))))) 
+  (PROG (|ISTMP#1| |a| |y'|)
+    (RETURN
+      (COND
+        ((AND (PAIRP |y|)
+              (PROGN
+                (SPADLET |ISTMP#1| (QCAR |y|))
+                (AND (PAIRP |ISTMP#1|)
+                     (PROGN (SPADLET |a| (QCAR |ISTMP#1|)) 'T)))
+              (PROGN (SPADLET |y'| (QCDR |y|)) 'T))
+         (COND
+           ((EQ |x| |a|) |y'|)
+           ('T (CONS (CAR |y|) (|deleteLassoc| |x| |y'|)))))
+        ('T |y|)))))
 
 ;deleteAssoc(x,y) ==
 ;  y is [[a,:.],:y'] =>
@@ -181,21 +170,19 @@
 ;  y
 
 (DEFUN |deleteAssoc| (|x| |y|)
- (PROG (|ISTMP#1| |a| |y'|)
-  (RETURN
-   (COND
-    ((AND
-      (PAIRP |y|)
-      (PROGN
-       (SPADLET |ISTMP#1| (QCAR |y|))
-       (AND
-        (PAIRP |ISTMP#1|)
-        (PROGN (SPADLET |a| (QCAR |ISTMP#1|)) (QUOTE T))))
-      (PROGN (SPADLET |y'| (QCDR |y|)) (QUOTE T)))
-     (COND
-      ((BOOT-EQUAL |a| |x|) (|deleteAssoc| |x| |y'|))
-      ((QUOTE T) (CONS (CAR |y|) (|deleteAssoc| |x| |y'|)))))
-    ((QUOTE T) |y|))))) 
+  (PROG (|ISTMP#1| |a| |y'|)
+    (RETURN
+      (COND
+        ((AND (PAIRP |y|)
+              (PROGN
+                (SPADLET |ISTMP#1| (QCAR |y|))
+                (AND (PAIRP |ISTMP#1|)
+                     (PROGN (SPADLET |a| (QCAR |ISTMP#1|)) 'T)))
+              (PROGN (SPADLET |y'| (QCDR |y|)) 'T))
+         (COND
+           ((BOOT-EQUAL |a| |x|) (|deleteAssoc| |x| |y'|))
+           ('T (CONS (CAR |y|) (|deleteAssoc| |x| |y'|)))))
+        ('T |y|)))))
 
 ;deleteAssocWOC(x,y) ==
 ;  null y => y
@@ -208,39 +195,34 @@
 ;    nil
 
 (DEFUN |deleteAssocWOC,fn| (|x| |y|)
- (PROG (|h| |t| |ISTMP#1| |a| |t1|)
-  (RETURN
-   (SEQ
-    (PROGN
-     (SPADLET |h| (CAR |y|))
-     (SPADLET |t| (CDR |y|))
-     |y|
-     (SEQ
-      (IF 
-       (AND (PAIRP |t|)
-            (PROGN
-             (SPADLET |ISTMP#1| (QCAR |t|))
-             (AND
-              (PAIRP |ISTMP#1|)
-              (PROGN (SPADLET |a| (QCAR |ISTMP#1|)) (QUOTE T))))
-            (PROGN (SPADLET |t1| (QCDR |t|)) (QUOTE T)))
-       (EXIT
-        (SEQ
-         (IF (BOOT-EQUAL |x| |a|) (EXIT (RPLACD |y| |t1|)))
-         (EXIT (|deleteAssocWOC,fn| |x| |t|)))))
-      (EXIT NIL))))))) 
+  (PROG (|h| |t| |ISTMP#1| |a| |t1|)
+    (RETURN
+      (SEQ (PROGN
+             (SPADLET |h| (CAR |y|))
+             (SPADLET |t| (CDR |y|))
+             |y|
+             (SEQ (IF (AND (PAIRP |t|)
+                           (PROGN
+                             (SPADLET |ISTMP#1| (QCAR |t|))
+                             (AND (PAIRP |ISTMP#1|)
+                                  (PROGN
+                                    (SPADLET |a| (QCAR |ISTMP#1|))
+                                    'T)))
+                           (PROGN (SPADLET |t1| (QCDR |t|)) 'T))
+                      (EXIT (SEQ (IF (BOOT-EQUAL |x| |a|)
+                                     (EXIT (RPLACD |y| |t1|)))
+                                 (EXIT (|deleteAssocWOC,fn| |x| |t|)))))
+                  (EXIT NIL)))))))
 
 (DEFUN |deleteAssocWOC| (|x| |y|)
- (PROG (|a| |t|)
-  (RETURN 
-   (COND
-    ((NULL |y|) |y|)
-    ((QUOTE T)
-     (SPADLET |a| (CAAR |y|))
-     (SPADLET |t| (CDR |y|))
-     (COND
-      ((BOOT-EQUAL |x| |a|) |t|)
-      ((QUOTE T) (|deleteAssocWOC,fn| |x| |y|) |y|))))))) 
+  (PROG (|a| |t|)
+    (RETURN
+      (COND
+        ((NULL |y|) |y|)
+        ('T (SPADLET |a| (CAAR |y|)) (SPADLET |t| (CDR |y|))
+         (COND
+           ((BOOT-EQUAL |x| |a|) |t|)
+           ('T (|deleteAssocWOC,fn| |x| |y|) |y|)))))))
 
 ;insertWOC(x,y) ==
 ;  null y => [x]
@@ -252,33 +234,30 @@
 ;    fn(x,t)
 
 (DEFUN |insertWOC,fn| (|x| |y|)
- (PROG (|h| |t|)
-  (RETURN
-   (SEQ
-    (PROGN
-     (SPADLET |h| (CAR |y|))
-     (SPADLET |t| (CDR |y|))
-     |y|
-     (SEQ
-      (IF (BOOT-EQUAL |x| |h|) (EXIT NIL))
-      (IF (NULL |t|)
-       (EXIT (SEQ (RPLACD |y| (CONS |h| |t|)) (EXIT (RPLACA |y| |x|)))))
-      (EXIT (|insertWOC,fn| |x| |t|)))))))) 
+  (PROG (|h| |t|)
+    (RETURN
+      (SEQ (PROGN
+             (SPADLET |h| (CAR |y|))
+             (SPADLET |t| (CDR |y|))
+             |y|
+             (SEQ (IF (BOOT-EQUAL |x| |h|) (EXIT NIL))
+                  (IF (NULL |t|)
+                      (EXIT (SEQ (RPLACD |y| (CONS |h| |t|))
+                                 (EXIT (RPLACA |y| |x|)))))
+                  (EXIT (|insertWOC,fn| |x| |t|))))))))
 
 (DEFUN |insertWOC| (|x| |y|)
- (COND
-  ((NULL |y|) (CONS |x| NIL))
-  ((QUOTE T) (|insertWOC,fn| |x| |y|) |y|))) 
+  (COND ((NULL |y|) (CONS |x| NIL)) ('T (|insertWOC,fn| |x| |y|) |y|)))
 
 ;fillerSpaces(n,:charPart) ==
 ;  n <= 0 => '""
 ;  MAKE_-FULL_-CVEC(n,IFCAR charPart or '" ")
 
-(DEFUN |fillerSpaces| (&REST #0=#:G1406 &AUX |charPart| |n|)
- (DSETQ (|n| . |charPart|) #0#)
- (COND
-  ((<= |n| 0) (MAKESTRING ""))
-  ((QUOTE T) (MAKE-FULL-CVEC |n| (OR (IFCAR |charPart|) (MAKESTRING " ")))))) 
+(DEFUN |fillerSpaces| (&REST G1406 &AUX |charPart| |n|)
+  (DSETQ (|n| . |charPart|) G1406)
+  (COND
+    ((<= |n| 0) (MAKESTRING ""))
+    ('T (MAKE-FULL-CVEC |n| (OR (IFCAR |charPart|) (MAKESTRING " "))))))
 
 ;centerString(text,width,fillchar) ==
 ;  wid := entryWidth text
@@ -292,24 +271,24 @@
 ;  [fill1,text,fill2]
 
 (DEFUN |centerString| (|text| |width| |fillchar|)
- (PROG (|wid| |f| |fill2| |fill1|)
-  (RETURN
-   (SEQ
-    (PROGN
-     (SPADLET |wid| (|entryWidth| |text|))
-     (COND
-      ((>= |wid| |width|) |text|)
-      ((QUOTE T)
-       (SPADLET |f| (DIVIDE (SPADDIFFERENCE |width| |wid|) 2))
-       (SPADLET |fill1| (QUOTE ||))
-       (DO ((#0=#:G1407 (ELT |f| 0)) (|i| 1 (QSADD1 |i|)))
-           ((QSGREATERP |i| #0#) NIL)
-        (SEQ (EXIT (SPADLET |fill1| (STRCONC |fillchar| |fill1|)))))
-       (SPADLET |fill2| |fill1|)
-       (COND
-        ((NEQUAL (ELT |f| 1) 0)
-         (SPADLET |fill1| (STRCONC |fillchar| |fill1|))))
-       (CONS |fill1| (CONS |text| (CONS |fill2| NIL)))))))))) 
+  (PROG (|wid| |f| |fill2| |fill1|)
+    (RETURN
+      (SEQ (PROGN
+             (SPADLET |wid| (|entryWidth| |text|))
+             (COND
+               ((>= |wid| |width|) |text|)
+               ('T
+                (SPADLET |f| (DIVIDE (SPADDIFFERENCE |width| |wid|) 2))
+                (SPADLET |fill1| '||)
+                (DO ((G1407 (ELT |f| 0)) (|i| 1 (QSADD1 |i|)))
+                    ((QSGREATERP |i| G1407) NIL)
+                  (SEQ (EXIT (SPADLET |fill1|
+                                      (STRCONC |fillchar| |fill1|)))))
+                (SPADLET |fill2| |fill1|)
+                (COND
+                  ((NEQUAL (ELT |f| 1) 0)
+                   (SPADLET |fill1| (STRCONC |fillchar| |fill1|))))
+                (CONS |fill1| (CONS |text| (CONS |fill2| NIL))))))))))
 
 ;stringPrefix?(pref,str) ==
 ;  -- sees if the first #pref letters of str are pref
@@ -325,25 +304,20 @@
 ;  ok
 
 (DEFUN |stringPrefix?| (|pref| |str|)
- (PROG (|lp| |ok| |i|)
-  (RETURN
-   (SEQ
-    (COND
-     ((NULL (AND (STRINGP |pref|) (STRINGP |str|))) NIL)
-     ((EQL (SPADLET |lp| (QCSIZE |pref|)) 0) (QUOTE T))
-     ((> |lp| (QCSIZE |str|)) NIL)
-     ((QUOTE T)
-      (SPADLET |ok| (QUOTE T))
-      (SPADLET |i| 0)
-      (DO () 
-          ((NULL (AND |ok| (> |lp| |i|)))
-            NIL)
-       (SEQ
-        (EXIT
-         (COND
-          ((NULL (EQ (SCHAR |pref| |i|) (SCHAR |str| |i|))) (SPADLET |ok| NIL))
-          ((QUOTE T) (SPADLET |i| (PLUS |i| 1)))))))
-      |ok|)))))) 
+  (PROG (|lp| |ok| |i|)
+    (RETURN
+      (SEQ (COND
+             ((NULL (AND (STRINGP |pref|) (STRINGP |str|))) NIL)
+             ((EQL (SPADLET |lp| (QCSIZE |pref|)) 0) 'T)
+             ((> |lp| (QCSIZE |str|)) NIL)
+             ('T (SPADLET |ok| 'T) (SPADLET |i| 0)
+              (DO () ((NULL (AND |ok| (> |lp| |i|))) NIL)
+                (SEQ (EXIT (COND
+                             ((NULL (EQ (SCHAR |pref| |i|)
+                                     (SCHAR |str| |i|)))
+                              (SPADLET |ok| NIL))
+                             ('T (SPADLET |i| (PLUS |i| 1)))))))
+              |ok|))))))
 
 ;stringChar2Integer(str,pos) ==
 ;  -- replaces GETSTRINGDIGIT in UT LISP
@@ -356,19 +330,16 @@
 ;  DIG2FIX d
 
 (DEFUN |stringChar2Integer| (|str| |pos|)
- (PROG (|d|)
-  (RETURN
-   (PROGN
-    (COND ((IDENTP |str|) (SPADLET |str| (PNAME |str|))))
-    (COND
-     ((NULL
-       (AND (STRINGP |str|)
-            (INTEGERP |pos|)
-            (>= |pos| 0)
-            (> (QCSIZE |str|) |pos|)))
-       NIL)
-     ((NULL (DIGITP (SPADLET |d| (SCHAR |str| |pos|)))) NIL)
-     ((QUOTE T) (DIG2FIX |d|))))))) 
+  (PROG (|d|)
+    (RETURN
+      (PROGN
+        (COND ((IDENTP |str|) (SPADLET |str| (PNAME |str|))))
+        (COND
+          ((NULL (AND (STRINGP |str|) (INTEGERP |pos|) (>= |pos| 0)
+                      (> (QCSIZE |str|) |pos|)))
+           NIL)
+          ((NULL (DIGITP (SPADLET |d| (SCHAR |str| |pos|)))) NIL)
+          ('T (DIG2FIX |d|)))))))
 
 ;dropLeadingBlanks str ==
 ;  str := object2String str
@@ -383,48 +354,44 @@
 ;  '""
 
 (DEFUN |dropLeadingBlanks| (|str|)
- (PROG (|l| |nb| |i|)
-  (RETURN
-   (SEQ
-    (PROGN
-     (SPADLET |str| (|object2String| |str|))
-     (SPADLET |l| (QCSIZE |str|))
-     (SPADLET |nb| NIL)
-     (SPADLET |i| 0)
-     (DO () 
-         ((NULL (AND (> |l| |i|) (NULL |nb|)))
-           NIL)
-      (SEQ
-       (EXIT
-        (COND
-         ((NEQUAL (SCHAR |str| |i|) (QUOTE | |)) (SPADLET |nb| |i|))
-         ((QUOTE T) (SPADLET |i| (PLUS |i| 1)))))))
-     (COND
-      ((EQL |nb| 0) |str|)
-      (|nb| (SUBSTRING |str| |nb| NIL))
-      ((QUOTE T) (MAKESTRING "")))))))) 
+  (PROG (|l| |nb| |i|)
+    (RETURN
+      (SEQ (PROGN
+             (SPADLET |str| (|object2String| |str|))
+             (SPADLET |l| (QCSIZE |str|))
+             (SPADLET |nb| NIL)
+             (SPADLET |i| 0)
+             (DO () ((NULL (AND (> |l| |i|) (NULL |nb|))) NIL)
+               (SEQ (EXIT (COND
+                            ((NEQUAL (SCHAR |str| |i|) '| |)
+                             (SPADLET |nb| |i|))
+                            ('T (SPADLET |i| (PLUS |i| 1)))))))
+             (COND
+               ((EQL |nb| 0) |str|)
+               (|nb| (SUBSTRING |str| |nb| NIL))
+               ('T (MAKESTRING ""))))))))
 
 ;concat(:l) == concatList l
 
-(DEFUN |concat| (&REST #0=#:G1408 &AUX |l|)
- (DSETQ |l| #0#)
- (|concatList| |l|)) 
+(DEFUN |concat| (&REST G1408 &AUX |l|)
+  (DSETQ |l| G1408)
+  (|concatList| |l|))
 
 ;concatList [x,:y] ==
 ;  null y => x
 ;  null x => concatList y
 ;  concat1(x,concatList y)
 
-(DEFUN |concatList| (#0=#:G1409)
- (PROG (|x| |y|)
-  (RETURN
-   (PROGN
-    (SPADLET |x| (CAR #0#))
-    (SPADLET |y| (CDR #0#))
-    (COND
-     ((NULL |y|) |x|)
-     ((NULL |x|) (|concatList| |y|))
-     ((QUOTE T) (|concat1| |x| (|concatList| |y|)))))))) 
+(DEFUN |concatList| (G1409)
+  (PROG (|x| |y|)
+    (RETURN
+      (PROGN
+        (SPADLET |x| (CAR G1409))
+        (SPADLET |y| (CDR G1409))
+        (COND
+          ((NULL |y|) |x|)
+          ((NULL |x|) (|concatList| |y|))
+          ('T (|concat1| |x| (|concatList| |y|))))))))
 
 ;concat1(x,y) ==
 ;  null x => y
@@ -434,16 +401,16 @@
 ;  [:x,:y]
 
 (DEFUN |concat1| (|x| |y|)
- (COND
-  ((NULL |x|) |y|)
-  ((ATOM |x|)
-   (COND
+  (COND
+    ((NULL |x|) |y|)
+    ((ATOM |x|)
+     (COND
+       ((NULL |y|) |x|)
+       ((ATOM |y|) (CONS |x| (CONS |y| NIL)))
+       ('T (CONS |x| |y|))))
     ((NULL |y|) |x|)
-    ((ATOM |y|) (CONS |x| (CONS |y| NIL)))
-    ((QUOTE T) (CONS |x| |y|))))
-  ((NULL |y|) |x|)
-  ((ATOM |y|) (APPEND |x| (CONS |y| NIL)))
-  ((QUOTE T) (APPEND |x| |y|)))) 
+    ((ATOM |y|) (APPEND |x| (CONS |y| NIL)))
+    ('T (APPEND |x| |y|))))
 
 ;ravel a == a
 
@@ -451,7 +418,9 @@
 
 ;reshape(a,b) == a
 
-(DEFUN |reshape| (|a| |b|) |a|) 
+(DEFUN |reshape| (|a| |b|)
+ (declare (ignore |b|))
+ |a|) 
 
 ;boolODDP x == ODDP x
 
@@ -462,20 +431,21 @@
 ;  freeOfSharpVars first x and freeOfSharpVars rest x
 
 (DEFUN |freeOfSharpVars| (|x|)
- (COND
-  ((ATOM |x|) (NULL (|isSharpVarWithNum| |x|)))
-  ((QUOTE T)
-   (AND (|freeOfSharpVars| (CAR |x|)) (|freeOfSharpVars| (CDR |x|)))))) 
+  (COND
+    ((ATOM |x|) (NULL (|isSharpVarWithNum| |x|)))
+    ('T
+     (AND (|freeOfSharpVars| (CAR |x|)) (|freeOfSharpVars| (CDR |x|))))))
 
 ;listOfSharpVars x ==
 ;  atom x => (isSharpVarWithNum x => LIST x; nil)
 ;  setUnion(listOfSharpVars first x,listOfSharpVars rest x)
 
 (DEFUN |listOfSharpVars| (|x|)
- (COND
-  ((ATOM |x|) (COND ((|isSharpVarWithNum| |x|) (LIST |x|)) ((QUOTE T) NIL)))
-  ((QUOTE T)
-   (|union| (|listOfSharpVars| (CAR |x|)) (|listOfSharpVars| (CDR |x|)))))) 
+  (COND
+    ((ATOM |x|) (COND ((|isSharpVarWithNum| |x|) (LIST |x|)) ('T NIL)))
+    ('T
+     (|union| (|listOfSharpVars| (CAR |x|))
+              (|listOfSharpVars| (CDR |x|))))))
 
 ;listOfPatternIds x ==
 ;  isPatternVar x => [x]
@@ -484,12 +454,13 @@
 ;  UNIONQ(listOfPatternIds first x,listOfPatternIds rest x)
 
 (DEFUN |listOfPatternIds| (|x|)
- (COND
-  ((|isPatternVar| |x|) (CONS |x| NIL))
-  ((ATOM |x|) NIL)
-  ((AND (PAIRP |x|) (EQ (QCAR |x|) (QUOTE QUOTE))) NIL)
-  ((QUOTE T)
-   (UNIONQ (|listOfPatternIds| (CAR |x|)) (|listOfPatternIds| (CDR |x|)))))) 
+  (COND
+    ((|isPatternVar| |x|) (CONS |x| NIL))
+    ((ATOM |x|) NIL)
+    ((AND (PAIRP |x|) (EQ (QCAR |x|) 'QUOTE)) NIL)
+    ('T
+     (UNIONQ (|listOfPatternIds| (CAR |x|))
+             (|listOfPatternIds| (CDR |x|))))))
 
 ;isPatternVar v ==
 ;  -- a pattern variable consists of a star followed by a star or digit(s)
@@ -497,11 +468,11 @@
 ;    _*11 _*12 _*13 _*14 _*15 _*16 _*17 _*18 _*19 _*20)) and true
 
 (DEFUN |isPatternVar| (|v|)
- (AND
-  (IDENTP |v|)
-  (MEMQ |v| (QUOTE (** *1 *2 *3 *4 *5 *6 *7 *8 *9 *10 *11 *12 *13 *14 *15 
-                    *16 *17 *18 *19 *20)))
-  (QUOTE T))) 
+  (AND (IDENTP |v|)
+       (MEMQ |v|
+             '(** *1 *2 *3 *4 *5 *6 *7 *8 *9 *10 *11 *12 *13 *14 *15
+                  *16 *17 *18 *19 *20))
+       'T))
 
 ;removeZeroOne x ==
 ;  -- replace all occurrences of (Zero) and (One) with
@@ -512,11 +483,12 @@
 ;  [removeZeroOne first x,:removeZeroOne rest x]
 
 (DEFUN |removeZeroOne| (|x|)
- (COND 
-  ((BOOT-EQUAL |x| |$Zero|) 0)
-  ((BOOT-EQUAL |x| |$One|) 1)
-  ((ATOM |x|) |x|)
-  ((QUOTE T) (CONS (|removeZeroOne| (CAR |x|)) (|removeZeroOne| (CDR |x|)))))) 
+  (DECLARE (SPECIAL |$One| |$Zero|))
+  (COND
+    ((BOOT-EQUAL |x| |$Zero|) 0)
+    ((BOOT-EQUAL |x| |$One|) 1)
+    ((ATOM |x|) |x|)
+    ('T (CONS (|removeZeroOne| (CAR |x|)) (|removeZeroOne| (CDR |x|))))))
 
 ;removeZeroOneDestructively t ==
 ;  -- replace all occurrences of (Zero) and (One) with
@@ -528,14 +500,14 @@
 ;    removeZeroOneDestructively rest t)
 
 (DEFUN |removeZeroOneDestructively| (|t|)
- (COND
-  ((BOOT-EQUAL |t| |$Zero|) 0)
-  ((BOOT-EQUAL |t| |$One|) 1)
-  ((ATOM |t|) |t|)
-  ((QUOTE T)
-   (RPLNODE |t|
-     (|removeZeroOneDestructively| (CAR |t|))
-     (|removeZeroOneDestructively| (CDR |t|)))))) 
+  (DECLARE (SPECIAL |$One| |$Zero|))
+  (COND
+    ((BOOT-EQUAL |t| |$Zero|) 0)
+    ((BOOT-EQUAL |t| |$One|) 1)
+    ((ATOM |t|) |t|)
+    ('T
+     (RPLNODE |t| (|removeZeroOneDestructively| (CAR |t|))
+              (|removeZeroOneDestructively| (CDR |t|))))))
 
 ;flattenSexpr s ==
 ;  null s => s
@@ -545,17 +517,15 @@
 ;  [:flattenSexpr f,:flattenSexpr r]
 
 (DEFUN |flattenSexpr| (|s|)
- (PROG (|f| |r|)
-  (RETURN
-   (COND
-    ((NULL |s|) |s|)
-    ((ATOM |s|) |s|)
-    ((QUOTE T)
-     (SPADLET |f| (CAR |s|))
-     (SPADLET |r| (CDR |s|))
-     (COND
-      ((ATOM |f|) (CONS |f| (|flattenSexpr| |r|)))
-      ((QUOTE T) (APPEND (|flattenSexpr| |f|) (|flattenSexpr| |r|))))))))) 
+  (PROG (|f| |r|)
+    (RETURN
+      (COND
+        ((NULL |s|) |s|)
+        ((ATOM |s|) |s|)
+        ('T (SPADLET |f| (CAR |s|)) (SPADLET |r| (CDR |s|))
+         (COND
+           ((ATOM |f|) (CONS |f| (|flattenSexpr| |r|)))
+           ('T (APPEND (|flattenSexpr| |f|) (|flattenSexpr| |r|)))))))))
 
 ;isLowerCaseLetter c == charRangeTest CHAR2NUM c
 
@@ -591,30 +561,24 @@
 ;  false
 
 (DEFUN |charRangeTest| (|n|)
- (COND
-  ((QSLESSP 153 |n|)
-   (COND
-    ((QSLESSP 169 |n|) NIL)
-    ((QSLESSP 161 |n|) (QUOTE T))
-    ((QUOTE T) NIL)))
-  ((QSLESSP 128 |n|)
-   (COND
-    ((QSLESSP 144 |n|) (QUOTE T))
-    ((QSLESSP 138 |n|) NIL)
-    ((QUOTE T) (QUOTE T))))
-  ((QUOTE T) NIL))) 
+  (COND
+    ((QSLESSP 153 |n|)
+     (COND ((QSLESSP 169 |n|) NIL) ((QSLESSP 161 |n|) 'T) ('T NIL)))
+    ((QSLESSP 128 |n|)
+     (COND ((QSLESSP 144 |n|) 'T) ((QSLESSP 138 |n|) NIL) ('T 'T)))
+    ('T NIL)))
 
 ;update() ==
 ;  OBEY
 ;    STRCONC('"SPADEDIT ",STRINGIMAGE _/VERSION,'" ",STRINGIMAGE _/WSNAME,'" A")
 ;  _/UPDATE()
 
-(DEFUN |update| NIL
- (PROGN
-  (OBEY
-   (STRCONC
-    "SPADEDIT " (STRINGIMAGE /VERSION) " " (STRINGIMAGE /WSNAME) " A"))
-  (/UPDATE))) 
+(DEFUN |update| ()
+  (declare (special /VERSION /WSNAME))
+  (PROGN
+    (OBEY (STRCONC "SPADEDIT " (STRINGIMAGE /VERSION) " "
+                   (STRINGIMAGE /WSNAME) " A"))
+    (/UPDATE)))
 
 ;listSort(pred,list,:optional) ==
 ;   NOT functionp pred => error "listSort: first arg must be a function"
@@ -624,23 +588,23 @@
 ;   NOT functionp key => error "listSort: last arg must be a function"
 ;   mergeSort(pred,key,list,LENGTH list)
 
-(DEFUN |listSort| (&REST #0=#:G1410 &AUX |optional| LIST |pred|)
- (DSETQ (|pred| LIST . |optional|) #0#)
- (PROG (|key|)
-  (RETURN
-   (COND
-    ((NULL (|functionp| |pred|))
-     (|error| (QUOTE |listSort: first arg must be a function|)))
-    ((NULL (LISTP LIST))
-     (|error| (QUOTE |listSort: second argument must be a list|)))
-    ((NULL |optional|)
-     (|mergeSort| |pred| (|function| |Identity|) LIST (LENGTH LIST)))
-    ((QUOTE T)
-     (SPADLET |key| (CAR |optional|))
-     (COND
-      ((NULL (|functionp| |key|))
-       (|error| (QUOTE |listSort: last arg must be a function|)))
-      ((QUOTE T) (|mergeSort| |pred| |key| LIST (LENGTH LIST))))))))) 
+(DEFUN |listSort| (&REST G1410 &AUX |optional| LIST |pred|)
+  (DSETQ (|pred| LIST . |optional|) G1410)
+  (PROG (|key|)
+    (RETURN
+      (COND
+        ((NULL (|functionp| |pred|))
+         (|error| '|listSort: first arg must be a function|))
+        ((NULL (LISTP LIST))
+         (|error| '|listSort: second argument must be a list|))
+        ((NULL |optional|)
+         (|mergeSort| |pred| (|function| |Identity|) LIST
+             (LENGTH LIST)))
+        ('T (SPADLET |key| (CAR |optional|))
+         (COND
+           ((NULL (|functionp| |key|))
+            (|error| '|listSort: last arg must be a function|))
+           ('T (|mergeSort| |pred| |key| LIST (LENGTH LIST)))))))))
 
 ;MSORT list == listSort(function GLESSEQP, COPY_-LIST list)
 
@@ -669,34 +633,31 @@
 ;   r
 
 (DEFUN |mergeInPlace| (|f| |g| |p| |q|)
- (PROG (|r| |t|)
-  (RETURN
-   (SEQ
-    (PROGN
-     (COND ((NULL |p|) (RETURN |p|)))
-     (COND ((NULL |q|) (RETURN |q|)))
-     (COND
-      ((FUNCALL |f| (FUNCALL |g| (QCAR |p|)) (FUNCALL |g| (QCAR |q|)))
-       (SPADLET |r| (SPADLET |t| |p|)) (SPADLET |p| (QCDR |p|)))
-      ((QUOTE T)
-       (SPADLET |r| (SPADLET |t| |q|)) (SPADLET |q| (QCDR |q|))))
-     (DO () 
-         ((NULL (AND (NULL (NULL |p|)) (NULL (NULL |q|)))) NIL)
-      (SEQ
-       (EXIT
-        (COND
-         ((FUNCALL |f| (FUNCALL |g| (QCAR |p|)) (FUNCALL |g| (QCAR |q|)))
-          (QRPLACD |t| |p|)
-          (SPADLET |t| |p|)
-          (SPADLET |p| (QCDR |p|)))
-         ((QUOTE T)
-          (QRPLACD |t| |q|)
-          (SPADLET |t| |q|)
-          (SPADLET |q| (QCDR |q|)))))))
-     (COND
-      ((NULL |p|) (QRPLACD |t| |q|))
-      ((QUOTE T) (QRPLACD |t| |p|)))
-     |r|))))) 
+  (PROG (|r| |t|)
+    (RETURN
+      (SEQ (PROGN
+             (COND ((NULL |p|) (RETURN |p|)))
+             (COND ((NULL |q|) (RETURN |q|)))
+             (COND
+               ((FUNCALL |f| (FUNCALL |g| (QCAR |p|))
+                         (FUNCALL |g| (QCAR |q|)))
+                (SPADLET |r| (SPADLET |t| |p|))
+                (SPADLET |p| (QCDR |p|)))
+               ('T (SPADLET |r| (SPADLET |t| |q|))
+                (SPADLET |q| (QCDR |q|))))
+             (DO ()
+                 ((NULL (AND (NULL (NULL |p|)) (NULL (NULL |q|)))) NIL)
+               (SEQ (EXIT (COND
+                            ((FUNCALL |f| (FUNCALL |g| (QCAR |p|))
+                                      (FUNCALL |g| (QCAR |q|)))
+                             (QRPLACD |t| |p|) (SPADLET |t| |p|)
+                             (SPADLET |p| (QCDR |p|)))
+                            ('T (QRPLACD |t| |q|) (SPADLET |t| |q|)
+                             (SPADLET |q| (QCDR |q|)))))))
+             (COND
+               ((NULL |p|) (QRPLACD |t| |q|))
+               ('T (QRPLACD |t| |p|)))
+             |r|)))))
 
 ;mergeSort(f,g,p,n) ==
 ;   if EQ(n,2) and FUNCALL(f,FUNCALL(g,QCADR p),FUNCALL(g,QCAR p)) then
@@ -716,29 +677,28 @@
 ;   mergeInPlace(f,g,p,q)
 
 (DEFUN |mergeSort| (|f| |g| |p| |n|)
- (PROG (|l| |t| |q|)
-  (RETURN
-   (SEQ
-    (PROGN
-     (COND
-      ((AND
-         (EQ |n| 2)
-         (FUNCALL |f| (FUNCALL |g| (QCADR |p|)) (FUNCALL |g| (QCAR |p|))))
-       (SPADLET |t| |p|)
-       (SPADLET |p| (QCDR |p|))
-       (QRPLACD |p| |t|)
-       (QRPLACD |t| NIL)))
-     (COND ((QSLESSP |n| 3) (RETURN |p|)))
-     (SPADLET |l| (QSQUOTIENT |n| 2))
-     (SPADLET |t| |p|)
-     (DO ((#0=#:G1411 (SPADDIFFERENCE |l| 1)) (|i| 1 (QSADD1 |i|)))
-         ((QSGREATERP |i| #0#) NIL)
-       (SEQ (EXIT (SPADLET |t| (QCDR |t|)))))
-     (SPADLET |q| (CDR |t|))
-     (QRPLACD |t| NIL)
-     (SPADLET |p| (|mergeSort| |f| |g| |p| |l|))
-     (SPADLET |q| (|mergeSort| |f| |g| |q| (QSDIFFERENCE |n| |l|)))
-     (|mergeInPlace| |f| |g| |p| |q|)))))) 
+  (PROG (|l| |t| |q|)
+    (RETURN
+      (SEQ (PROGN
+             (COND
+               ((AND (EQ |n| 2)
+                     (FUNCALL |f| (FUNCALL |g| (QCADR |p|))
+                              (FUNCALL |g| (QCAR |p|))))
+                (SPADLET |t| |p|) (SPADLET |p| (QCDR |p|))
+                (QRPLACD |p| |t|) (QRPLACD |t| NIL)))
+             (COND ((QSLESSP |n| 3) (RETURN |p|)))
+             (SPADLET |l| (QSQUOTIENT |n| 2))
+             (SPADLET |t| |p|)
+             (DO ((G1411 (SPADDIFFERENCE |l| 1))
+                  (|i| 1 (QSADD1 |i|)))
+                 ((QSGREATERP |i| G1411) NIL)
+               (SEQ (EXIT (SPADLET |t| (QCDR |t|)))))
+             (SPADLET |q| (CDR |t|))
+             (QRPLACD |t| NIL)
+             (SPADLET |p| (|mergeSort| |f| |g| |p| |l|))
+             (SPADLET |q|
+                      (|mergeSort| |f| |g| |q| (QSDIFFERENCE |n| |l|)))
+             (|mergeInPlace| |f| |g| |p| |q|))))))
 
 ;spadThrow() ==
 ;  if $interpOnly and $mapName then
@@ -746,11 +706,12 @@
 ;  THROW("SPAD__READER",nil)
 
 (DEFUN |spadThrow| ()
- (PROGN
-  (COND
-   ((AND |$interpOnly| |$mapName|)
-     (|putHist| |$mapName| (QUOTE |localModemap|) NIL |$e|)))
-  (THROW (QUOTE SPAD_READER) NIL))) 
+  (DECLARE (SPECIAL |$e| |$mapName| |$interpOnly|))
+  (PROGN
+    (COND
+      ((AND |$interpOnly| |$mapName|)
+       (|putHist| |$mapName| '|localModemap| NIL |$e|)))
+    (THROW 'SPAD_READER NIL)))
 
 ;spadThrowBrightly x ==
 ;  sayBrightly x
@@ -768,25 +729,20 @@
 ;  ['"(",:args,'") -> ",:target]
 
 (DEFUN |formatUnabbreviatedSig| (|sig|)
- (PROG (|target| |args|)
-  (RETURN
-   (COND
-    ((NULL |sig|) (CONS (QUOTE |() -> ()|) NIL))
-    ((QUOTE T)
-     (SPADLET |target| (CAR |sig|))
-     (SPADLET |args| (CDR |sig|))
-     (SPADLET |target| (|formatUnabbreviated| |target|))
-     (COND 
-      ((NULL |args|) (CONS (MAKESTRING "() -> ") |target|))
-      ((NULL (CDR |args|))
-       (APPEND
-        (|formatUnabbreviated| (QCAR |args|))
-        (CONS (MAKESTRING " -> ") |target|)))
-      ((QUOTE T)
-       (SPADLET |args| (|formatUnabbreviatedTuple| |args|))
-       (CONS
-        (MAKESTRING "(")
-        (APPEND |args| (CONS (MAKESTRING ") -> ") |target|)))))))))) 
+  (PROG (|target| |args|)
+    (RETURN
+      (COND
+        ((NULL |sig|) (CONS '|() -> ()| NIL))
+        ('T (SPADLET |target| (CAR |sig|)) (SPADLET |args| (CDR |sig|))
+         (SPADLET |target| (|formatUnabbreviated| |target|))
+         (COND
+           ((NULL |args|) (CONS (MAKESTRING "() -> ") |target|))
+           ((NULL (CDR |args|))
+            (APPEND (|formatUnabbreviated| (QCAR |args|))
+                    (CONS (MAKESTRING " -> ") |target|)))
+           ('T (SPADLET |args| (|formatUnabbreviatedTuple| |args|))
+            (CONS (MAKESTRING "(")
+                  (APPEND |args| (CONS (MAKESTRING ") -> ") |target|))))))))))
 
 ;formatUnabbreviatedTuple t ==
 ;  -- t is a list of types
@@ -799,20 +755,18 @@
 ;;;     ***       |formatUnabbreviatedTuple| REDEFINED
 
 (DEFUN |formatUnabbreviatedTuple| (|t|)
- (PROG (|t0|)
-  (RETURN
-   (COND
-    ((NULL |t|) |t|)
-    ((ATOM |t|) (CONS |t| NIL))
-    ((QUOTE T)
-     (SPADLET |t0| (|formatUnabbreviated| (QCAR |t|)))
-     (COND
-      ((NULL (CDR |t|)) |t0|)
-      ((QUOTE T)
-       (APPEND
-        |t0|
-        (CONS "," (|formatUnabbreviatedTuple| (QCDR |t|)))))))))))
- 
+  (PROG (|t0|)
+    (RETURN
+      (COND
+        ((NULL |t|) |t|)
+        ((ATOM |t|) (CONS |t| NIL))
+        ('T (SPADLET |t0| (|formatUnabbreviated| (QCAR |t|)))
+         (COND
+           ((NULL (CDR |t|)) |t0|)
+           ('T
+            (APPEND |t0|
+                    (CONS "," (|formatUnabbreviatedTuple| (QCDR |t|)))))))))))
+
 ;formatUnabbreviated t ==
 ;  atom t =>
 ;    [t]
@@ -835,64 +789,62 @@
 ;  t
 
 (DEFUN |formatUnabbreviated| (|t|)
- (PROG (|p| |sel| |ISTMP#2| |ISTMP#1| |arg1| |arg| |args|)
-  (RETURN
-   (COND
-    ((ATOM |t|) (CONS |t| NIL))
-    ((NULL |t|) (CONS (MAKESTRING "()") NIL))
-    ((AND 
-      (PAIRP |t|)
-      (PROGN
-       (SPADLET |p| (QCAR |t|))
-       (SPADLET |ISTMP#1| (QCDR |t|))
-       (AND
-        (PAIRP |ISTMP#1|)
-        (PROGN
-         (SPADLET |sel| (QCAR |ISTMP#1|))
-         (SPADLET |ISTMP#2| (QCDR |ISTMP#1|))
-         (AND
-          (PAIRP |ISTMP#2|)
-          (EQ (QCDR |ISTMP#2|) NIL)
-          (PROGN (SPADLET |arg| (QCAR |ISTMP#2|)) (QUOTE T))))))
-      (|member| |p| (QUOTE (|:| ":"))))
-     (CONS |sel| (CONS (MAKESTRING ": ") (|formatUnabbreviated| |arg|))))
-    ((AND (PAIRP |t|)
-          (EQ (QCAR |t|) (QUOTE |Union|))
-          (PROGN (SPADLET |args| (QCDR |t|)) (QUOTE T)))
-     (CONS
-      (QUOTE |Union|)
-      (CONS "(" (APPEND (|formatUnabbreviatedTuple| |args|) (CONS ")" NIL)))))
-    ((AND (PAIRP |t|)
-          (EQ (QCAR |t|) (QUOTE |Mapping|))
-          (PROGN (SPADLET |args| (QCDR |t|)) (QUOTE T)))
-     (|formatUnabbreviatedSig| |args|))
-    ((AND (PAIRP |t|)
-          (EQ (QCAR |t|) (QUOTE |Record|))
-          (PROGN (SPADLET |args| (QCDR |t|)) (QUOTE T)))
-     (CONS 
-      (QUOTE |Record|)
-      (CONS "(" (APPEND (|formatUnabbreviatedTuple| |args|) (CONS ")" NIL)))))
-    ((AND (PAIRP |t|) 
-          (EQ (QCDR |t|) NIL)
-          (PROGN (SPADLET |arg| (QCAR |t|)) (QUOTE T)))
-     |t|)
-    ((AND (PAIRP |t|)
-          (PROGN
-           (SPADLET |arg| (QCAR |t|))
-           (SPADLET |ISTMP#1| (QCDR |t|))
-           (AND (PAIRP |ISTMP#1|)
-                (EQ (QCDR |ISTMP#1|) NIL)
-                (PROGN (SPADLET |arg1| (QCAR |ISTMP#1|)) (QUOTE T)))))
-     (CONS |arg| (CONS (MAKESTRING " ") (|formatUnabbreviated| |arg1|))))
-    ((AND (PAIRP |t|) 
-          (PROGN
-           (SPADLET |arg| (QCAR |t|))
-           (SPADLET |args| (QCDR |t|))
-           (QUOTE T)))
-     (CONS
-      |arg|
-      (CONS "(" (APPEND (|formatUnabbreviatedTuple| |args|) (CONS ")" NIL)))))
-    ((QUOTE T) |t|))))) 
+  (PROG (|p| |sel| |ISTMP#2| |ISTMP#1| |arg1| |arg| |args|)
+    (RETURN
+      (COND
+        ((ATOM |t|) (CONS |t| NIL))
+        ((NULL |t|) (CONS (MAKESTRING "()") NIL))
+        ((AND (PAIRP |t|)
+              (PROGN
+                (SPADLET |p| (QCAR |t|))
+                (SPADLET |ISTMP#1| (QCDR |t|))
+                (AND (PAIRP |ISTMP#1|)
+                     (PROGN
+                       (SPADLET |sel| (QCAR |ISTMP#1|))
+                       (SPADLET |ISTMP#2| (QCDR |ISTMP#1|))
+                       (AND (PAIRP |ISTMP#2|) (EQ (QCDR |ISTMP#2|) NIL)
+                            (PROGN
+                              (SPADLET |arg| (QCAR |ISTMP#2|))
+                              'T)))))
+              (|member| |p| '(|:| ":")))
+         (CONS |sel|
+               (CONS (MAKESTRING ": ") (|formatUnabbreviated| |arg|))))
+        ((AND (PAIRP |t|) (EQ (QCAR |t|) '|Union|)
+              (PROGN (SPADLET |args| (QCDR |t|)) 'T))
+         (CONS '|Union|
+               (CONS "("
+                     (APPEND (|formatUnabbreviatedTuple| |args|)
+                             (CONS ")" NIL)))))
+        ((AND (PAIRP |t|) (EQ (QCAR |t|) '|Mapping|)
+              (PROGN (SPADLET |args| (QCDR |t|)) 'T))
+         (|formatUnabbreviatedSig| |args|))
+        ((AND (PAIRP |t|) (EQ (QCAR |t|) '|Record|)
+              (PROGN (SPADLET |args| (QCDR |t|)) 'T))
+         (CONS '|Record|
+               (CONS "("
+                     (APPEND (|formatUnabbreviatedTuple| |args|)
+                             (CONS ")" NIL)))))
+        ((AND (PAIRP |t|) (EQ (QCDR |t|) NIL)
+              (PROGN (SPADLET |arg| (QCAR |t|)) 'T))
+         |t|)
+        ((AND (PAIRP |t|)
+              (PROGN
+                (SPADLET |arg| (QCAR |t|))
+                (SPADLET |ISTMP#1| (QCDR |t|))
+                (AND (PAIRP |ISTMP#1|) (EQ (QCDR |ISTMP#1|) NIL)
+                     (PROGN (SPADLET |arg1| (QCAR |ISTMP#1|)) 'T))))
+         (CONS |arg|
+               (CONS (MAKESTRING " ") (|formatUnabbreviated| |arg1|))))
+        ((AND (PAIRP |t|)
+              (PROGN
+                (SPADLET |arg| (QCAR |t|))
+                (SPADLET |args| (QCDR |t|))
+                'T))
+         (CONS |arg|
+               (CONS "("
+                     (APPEND (|formatUnabbreviatedTuple| |args|)
+                             (CONS ")" NIL)))))
+        ('T |t|)))))
 
 ;sublisNQ(al,e) ==
 ;  atom al => e
@@ -908,41 +860,42 @@
 ;    [u,:v]
 
 (DEFUN |sublisNQ,fn| (|al| |e|)
- (PROG (|a| |u| |v|)
-  (RETURN
-   (SEQ
-    (IF (ATOM |e|)
-     (EXIT
-      (SEQ
-       (DO ((#0=#:G1412 |al| (CDR #0#)) (|x| NIL))
-           ((OR (ATOM #0#) (PROGN (SETQ |x| (CAR #0#)) NIL)) NIL)
-        (SEQ
-         (EXIT
-          (IF (EQ (CAR |x|) |e|) (EXIT (RETURN (SPADLET |e| (CDR |x|))))))))
-       (EXIT |e|))))
-    (IF (EQ (SPADLET |a| (CAR |e|)) (QUOTE QUOTE)) (EXIT |e|))
-    (SPADLET |u| (|sublisNQ,fn| |al| |a|))
-    (SPADLET |v| (|sublisNQ,fn| |al| (CDR |e|)))
-    (IF (AND (EQ |a| |u|) (EQ (CDR |e|) |v|)) (EXIT |e|))
-    (EXIT (CONS |u| |v|)))))) 
+  (PROG (|a| |u| |v|)
+    (RETURN
+      (SEQ (IF (ATOM |e|)
+               (EXIT (SEQ (DO ((G1412 |al| (CDR G1412)) (|x| NIL))
+                              ((OR (ATOM G1412)
+                                   (PROGN
+                                     (SETQ |x| (CAR G1412))
+                                     NIL))
+                               NIL)
+                            (SEQ (EXIT (IF (EQ (CAR |x|) |e|)
+                                        (EXIT
+                                         (RETURN
+                                           (SPADLET |e| (CDR |x|))))))))
+                          (EXIT |e|))))
+           (IF (EQ (SPADLET |a| (CAR |e|)) 'QUOTE) (EXIT |e|))
+           (SPADLET |u| (|sublisNQ,fn| |al| |a|))
+           (SPADLET |v| (|sublisNQ,fn| |al| (CDR |e|)))
+           (IF (AND (EQ |a| |u|) (EQ (CDR |e|) |v|)) (EXIT |e|))
+           (EXIT (CONS |u| |v|))))))
 
 (DEFUN |sublisNQ| (|al| |e|)
- (COND
-  ((ATOM |al|) |e|)
-  ((QUOTE T) (|sublisNQ,fn| |al| |e|)))) 
+  (COND ((ATOM |al|) |e|) ('T (|sublisNQ,fn| |al| |e|))))
 
 ;str2Outform s ==
 ;  parse := ncParseFromString s or systemError '"String for TeX will not parse"
 ;  parse2Outform parse
 
 (DEFUN |str2Outform| (|s|)
- (PROG (|parse|)
-  (RETURN
-   (PROGN
-    (SPADLET |parse|
-     (OR (|ncParseFromString| |s|)
-         (|systemError| (MAKESTRING "String for TeX will not parse"))))
-    (|parse2Outform| |parse|))))) 
+  (PROG (|parse|)
+    (RETURN
+      (PROGN
+        (SPADLET |parse|
+                 (OR (|ncParseFromString| |s|)
+                     (|systemError|
+                         (MAKESTRING "String for TeX will not parse"))))
+        (|parse2Outform| |parse|)))))
 
 ;parse2Outform x ==
 ;  x is [op,:argl] =>
@@ -953,52 +906,61 @@
 ;  x
 
 (DEFUN |parse2Outform| (|x|)
- (PROG (|op| |argl| |nargl| |ISTMP#1| BRACKET |r|)
-  (RETURN
-   (SEQ
-    (COND
-     ((AND (PAIRP |x|)
-           (PROGN
-            (SPADLET |op| (QCAR |x|))
-            (SPADLET |argl| (QCDR |x|))
-            (QUOTE T)))
-      (SPADLET |nargl|
-       (PROG (#0=#:G1413)
-        (SPADLET #0# NIL)
-        (RETURN
-         (DO ((#1=#:G1414 |argl| (CDR #1#)) (|y| NIL))
-             ((OR (ATOM #1#) (PROGN (SETQ |y| (CAR #1#)) NIL)) (NREVERSE0 #0#))
-          (SEQ (EXIT (SETQ #0# (CONS (|parse2Outform| |y|) #0#))))))))
-      (COND
-       ((BOOT-EQUAL |op| (QUOTE |construct|))
-        (CONS
-         (QUOTE BRACKET)
-         (CONS
-          (CONS
-           (QUOTE ARGLST)
-           (PROG (#2=#:G1415)
-            (SPADLET #2# NIL)
-            (RETURN
-             (DO ((#3=#:G1416 |argl| (CDR #3#)) (|y| NIL))
-                 ((OR (ATOM #3#) (PROGN (SETQ |y| (CAR #3#)) NIL))
-                   (NREVERSE0 #2#))
-               (SEQ (EXIT (SETQ #2# (CONS (|parse2Outform| |y|) #2#))))))))
-          NIL)))
-       ((AND 
-         (BOOT-EQUAL |op| (QUOTE |brace|))
-         (PAIRP |nargl|)
-         (EQ (QCDR |nargl|) NIL)
-         (PROGN
-          (SPADLET |ISTMP#1| (QCAR |nargl|))
-          (AND
-           (PAIRP |ISTMP#1|)
-           (PROGN 
-            (SPADLET BRACKET (QCAR |ISTMP#1|))
-            (SPADLET |r| (QCDR |ISTMP#1|))
-            (QUOTE T)))))
-        (CONS (QUOTE BRACE) |r|))
-       ((QUOTE T) (CONS |op| |nargl|))))
-     ((QUOTE T) |x|)))))) 
+  (PROG (|op| |argl| |nargl| |ISTMP#1| BRACKET |r|)
+    (RETURN
+      (SEQ (COND
+             ((AND (PAIRP |x|)
+                   (PROGN
+                     (SPADLET |op| (QCAR |x|))
+                     (SPADLET |argl| (QCDR |x|))
+                     'T))
+              (SPADLET |nargl|
+                       (PROG (G1413)
+                         (SPADLET G1413 NIL)
+                         (RETURN
+                           (DO ((G1414 |argl| (CDR G1414))
+                                (|y| NIL))
+                               ((OR (ATOM G1414)
+                                    (PROGN
+                                      (SETQ |y| (CAR G1414))
+                                      NIL))
+                                (NREVERSE0 G1413))
+                             (SEQ (EXIT (SETQ G1413
+                                         (CONS (|parse2Outform| |y|)
+                                          G1413))))))))
+              (COND
+                ((BOOT-EQUAL |op| '|construct|)
+                 (CONS 'BRACKET
+                       (CONS (CONS 'ARGLST
+                                   (PROG (G1415)
+                                     (SPADLET G1415 NIL)
+                                     (RETURN
+                                       (DO
+                                        ((G1416 |argl| (CDR G1416))
+                                         (|y| NIL))
+                                        ((OR (ATOM G1416)
+                                          (PROGN
+                                            (SETQ |y| (CAR G1416))
+                                            NIL))
+                                         (NREVERSE0 G1415))
+                                         (SEQ
+                                          (EXIT
+                                           (SETQ G1415
+                                            (CONS (|parse2Outform| |y|)
+                                             G1415))))))))
+                             NIL)))
+                ((AND (BOOT-EQUAL |op| '|brace|) (PAIRP |nargl|)
+                      (EQ (QCDR |nargl|) NIL)
+                      (PROGN
+                        (SPADLET |ISTMP#1| (QCAR |nargl|))
+                        (AND (PAIRP |ISTMP#1|)
+                             (PROGN
+                               (SPADLET BRACKET (QCAR |ISTMP#1|))
+                               (SPADLET |r| (QCDR |ISTMP#1|))
+                               'T))))
+                 (CONS 'BRACE |r|))
+                ('T (CONS |op| |nargl|))))
+             ('T |x|))))))
 
 ;str2Tex s ==
 ;  outf := str2Outform s
@@ -1007,22 +969,21 @@
 ;  CAR val.1
 
 (DEFUN |str2Tex| (|s|)
- (PROG (|outf| |val|)
-  (RETURN 
-   (PROGN 
-    (SPADLET |outf| (|str2Outform| |s|))
-    (SPADLET |val|
-     (|coerceInt|
-      (|mkObj| (|wrap| |outf|) (QUOTE (|OutputForm|)))
-      (QUOTE (|TexFormat|))))
-    (SPADLET |val| (|objValUnwrap| |val|))
-    (CAR (ELT |val| 1)))))) 
+  (PROG (|outf| |val|)
+    (RETURN
+      (PROGN
+        (SPADLET |outf| (|str2Outform| |s|))
+        (SPADLET |val|
+                 (|coerceInt| (|mkObj| (|wrap| |outf|) '(|OutputForm|))
+                     '(|TexFormat|)))
+        (SPADLET |val| (|objValUnwrap| |val|))
+        (CAR (ELT |val| 1))))))
 
 ;opOf x ==
 ;  atom x => x
 ;  first x
 
-(DEFUN |opOf| (|x|) (COND ((ATOM |x|) |x|) ((QUOTE T) (CAR |x|)))) 
+(DEFUN |opOf| (|x|) (COND ((ATOM |x|) |x|) ('T (CAR |x|))))
 
 ;getProplist(x,E) ==
 ;  not atom x => getProplist(first x,E)
@@ -1033,12 +994,13 @@
 ;    pl
 
 (DEFUN |getProplist| (|x| E)
- (PROG (|u| |pl|)
-  (RETURN
-   (COND
-    ((NULL (ATOM |x|)) (|getProplist| (CAR |x|) E))
-    ((SPADLET |u| (|search| |x| E)) |u|)
-    ((SPADLET |pl| (|search| |x| |$CategoryFrame|)) |pl|))))) 
+  (PROG (|u| |pl|)
+    (DECLARE (SPECIAL |$CategoryFrame|))
+    (RETURN
+      (COND
+        ((NULL (ATOM |x|)) (|getProplist| (CAR |x|) E))
+        ((SPADLET |u| (|search| |x| E)) |u|)
+        ((SPADLET |pl| (|search| |x| |$CategoryFrame|)) |pl|)))))
 
 ;--  (pl:=PROPLIST x) => pl
 ;-- Above line commented out JHD/BMT 2.Aug.90
@@ -1046,12 +1008,13 @@
 ;  searchCurrentEnv(x,curEnv) or searchTailEnv(x,tailEnv)
 
 (DEFUN |search| (|x| |e|)
- (PROG (|curEnv| |tailEnv|)
-  (RETURN
-   (PROGN
-    (SPADLET |curEnv| (CAR |e|))
-    (SPADLET |tailEnv| (CDR |e|))
-    (OR (|searchCurrentEnv| |x| |curEnv|) (|searchTailEnv| |x| |tailEnv|)))))) 
+  (PROG (|curEnv| |tailEnv|)
+    (RETURN
+      (PROGN
+        (SPADLET |curEnv| (CAR |e|))
+        (SPADLET |tailEnv| (CDR |e|))
+        (OR (|searchCurrentEnv| |x| |curEnv|)
+            (|searchTailEnv| |x| |tailEnv|))))))
 
 ;searchCurrentEnv(x,currentEnv) ==
 ;  for contour in currentEnv repeat
@@ -1059,18 +1022,18 @@
 ;  KDR signal
 
 (DEFUN |searchCurrentEnv| (|x| |currentEnv|)
- (PROG (|u| |signal|)
-  (RETURN
-   (SEQ
-    (PROGN 
-     (DO ((#0=#:G1417 |currentEnv| (CDR #0#)) (|contour| NIL))
-         ((OR (ATOM #0#) (PROGN (SETQ |contour| (CAR #0#)) NIL)) NIL)
-      (SEQ
-       (EXIT
-        (COND
-         ((SPADLET |u| (ASSQ |x| |contour|)) (RETURN (SPADLET |signal| |u|)))
-         ((QUOTE T) NIL)))))
-     (KDR |signal|)))))) 
+  (PROG (|u| |signal|)
+    (RETURN
+      (SEQ (PROGN
+             (DO ((G1417 |currentEnv| (CDR G1417)) (|contour| NIL))
+                 ((OR (ATOM G1417)
+                      (PROGN (SETQ |contour| (CAR G1417)) NIL))
+                  NIL)
+               (SEQ (EXIT (COND
+                            ((SPADLET |u| (ASSQ |x| |contour|))
+                             (RETURN (SPADLET |signal| |u|)))
+                            ('T NIL)))))
+             (KDR |signal|))))))
 
 ;searchTailEnv(x,e) ==
 ;  for env in e repeat
@@ -1081,28 +1044,38 @@
 ;  KDR signal
 
 (DEFUN |searchTailEnv| (|x| |e|)
- (PROG (|u| |signal|)
-  (RETURN
-   (SEQ
-    (PROGN
-     (DO ((#0=#:G1418 |e| (CDR #0#)) (|env| NIL))
-         ((OR (ATOM #0#) (PROGN (SETQ |env| (CAR #0#)) NIL)) NIL)
-      (SEQ
-       (EXIT
-        (SPADLET |signal|
-         (PROGN
-          (DO ((#1=#:G1419 |env| (CDR #1#)) (|contour| NIL))
-              ((OR (ATOM #1#) (PROGN (SETQ |contour| (CAR #1#)) NIL)) NIL)
-           (SEQ
-            (EXIT
-             (COND
-              ((AND
-                (SPADLET |u| (ASSQ |x| |contour|))
-                (ASSQ (QUOTE FLUID) |u|))
-               (RETURN (SPADLET |signal| |u|)))
-              ((QUOTE T) NIL)))))
-          (COND (|signal| (RETURN |signal|)) ((QUOTE T) NIL)))))))
-     (KDR |signal|)))))) 
+  (PROG (|u| |signal|)
+    (RETURN
+      (SEQ (PROGN
+             (DO ((G1418 |e| (CDR G1418)) (|env| NIL))
+                 ((OR (ATOM G1418)
+                      (PROGN (SETQ |env| (CAR G1418)) NIL))
+                  NIL)
+               (SEQ (EXIT (SPADLET |signal|
+                                   (PROGN
+                                     (DO
+                                      ((G1419 |env| (CDR G1419))
+                                       (|contour| NIL))
+                                      ((OR (ATOM G1419)
+                                        (PROGN
+                                          (SETQ |contour|
+                                           (CAR G1419))
+                                          NIL))
+                                       NIL)
+                                       (SEQ
+                                        (EXIT
+                                         (COND
+                                           ((AND
+                                             (SPADLET |u|
+                                              (ASSQ |x| |contour|))
+                                             (ASSQ 'FLUID |u|))
+                                            (RETURN
+                                              (SPADLET |signal| |u|)))
+                                           ('T NIL)))))
+                                     (COND
+                                       (|signal| (RETURN |signal|))
+                                       ('T NIL)))))))
+             (KDR |signal|))))))
 
 ;augProplist(proplist,prop,val) ==
 ;  $InteractiveMode => augProplistInteractive(proplist,prop,val)
@@ -1114,28 +1087,33 @@
 ;  [[prop,:val],:proplist]
 
 (DEFUN |augProplist| (|proplist| |prop| |val|)
- (PROG (|ISTMP#1| |proplist'| |u|)
-  (RETURN 
-   (SEQ
-    (COND
-     (|$InteractiveMode| (|augProplistInteractive| |proplist| |prop| |val|))
-     ((QUOTE T)
-      (DO () 
-          ((NULL
-            (AND (PAIRP |proplist|)
-                 (PROGN
-                  (SPADLET |ISTMP#1| (QCAR |proplist|))
-                  (AND (PAIRP |ISTMP#1|) (EQUAL (QCAR |ISTMP#1|) |prop|)))
-                 (PROGN (SPADLET |proplist'| (QCDR |proplist|)) (QUOTE T))))
-            NIL)
-       (SEQ (EXIT (SPADLET |proplist| |proplist'|))))
-      (COND
-       ((BOOT-EQUAL |val| (SPADLET |u| (LASSOC |prop| |proplist|))) |proplist|)
-       ((NULL |val|)
-        (COND
-         ((NULL |u|) |proplist|)
-         ((QUOTE T) (DELLASOS |prop| |proplist|))))
-       ((QUOTE T) (CONS (CONS |prop| |val|) |proplist|))))))))) 
+  (PROG (|ISTMP#1| |proplist'| |u|)
+    (DECLARE (SPECIAL |$InteractiveMode|))
+    (RETURN
+      (SEQ (COND
+             (|$InteractiveMode|
+                 (|augProplistInteractive| |proplist| |prop| |val|))
+             ('T
+              (DO ()
+                  ((NULL (AND (PAIRP |proplist|)
+                              (PROGN
+                                (SPADLET |ISTMP#1| (QCAR |proplist|))
+                                (AND (PAIRP |ISTMP#1|)
+                                     (EQUAL (QCAR |ISTMP#1|) |prop|)))
+                              (PROGN
+                                (SPADLET |proplist'| (QCDR |proplist|))
+                                'T)))
+                   NIL)
+                (SEQ (EXIT (SPADLET |proplist| |proplist'|))))
+              (COND
+                ((BOOT-EQUAL |val|
+                     (SPADLET |u| (LASSOC |prop| |proplist|)))
+                 |proplist|)
+                ((NULL |val|)
+                 (COND
+                   ((NULL |u|) |proplist|)
+                   ('T (DELLASOS |prop| |proplist|))))
+                ('T (CONS (CONS |prop| |val|) |proplist|)))))))))
 
 ;augProplistOf(var,prop,val,e) ==
 ;  proplist:= getProplist(var,e)
@@ -1143,12 +1121,12 @@
 ;  augProplist(proplist,prop,val)
 
 (DEFUN |augProplistOf| (|var| |prop| |val| |e|)
- (PROG (|proplist|)
-  (RETURN
-   (PROGN
-    (SPADLET |proplist| (|getProplist| |var| |e|))
-    (|semchkProplist| |var| |proplist| |prop| |val|)
-    (|augProplist| |proplist| |prop| |val|))))) 
+  (PROG (|proplist|)
+    (RETURN
+      (PROGN
+        (SPADLET |proplist| (|getProplist| |var| |e|))
+        (|semchkProplist| |var| |proplist| |prop| |val|)
+        (|augProplist| |proplist| |prop| |val|)))))
 
 ;semchkProplist(x,proplist,prop,val) ==
 ;  prop="isLiteral" =>
@@ -1159,18 +1137,17 @@
 ;;;     ***       |semchkProplist| REDEFINED
 
 (DEFUN |semchkProplist| (|x| |proplist| |prop| |val|)
- (SEQ
-  (COND
-   ((BOOT-EQUAL |prop| (QUOTE |isLiteral|))
-    (COND
-     ((OR
-       (LASSOC (QUOTE |value|) |proplist|)
-       (LASSOC (QUOTE |mode|) |proplist|))
-      (EXIT (|warnLiteral| |x|)))))
-    ((MEMQ |prop| (QUOTE (|mode| |value|)))
-     (COND
-      ((LASSOC (QUOTE |isLiteral|) |proplist|)
-       (EXIT (|warnLiteral| |x|)))))))) 
+  (declare (special |val|))
+  (SEQ (COND
+         ((BOOT-EQUAL |prop| '|isLiteral|)
+          (COND
+            ((OR (LASSOC '|value| |proplist|)
+                 (LASSOC '|mode| |proplist|))
+             (EXIT (|warnLiteral| |x|)))))
+         ((MEMQ |prop| '(|mode| |value|))
+          (COND
+            ((LASSOC '|isLiteral| |proplist|)
+             (EXIT (|warnLiteral| |x|))))))))
 
 ;DEFPARAMETER($envHashTable,nil)
 
@@ -1189,37 +1166,40 @@
 ;;;     ***       |addBinding| REDEFINED
 
 (DEFUN |addBinding| (|var| |proplist| |e|)
- (PROG (|tailContour| |tailEnv| |ISTMP#1| |curContour| |lx|)
-  (RETURN
-   (SEQ
-    (PROGN 
-     (SPADLET |curContour| (CAAR |e|))
-     (SPADLET |tailContour| (CDAR |e|))
-     (SPADLET |tailEnv| (CDR |e|))
-     (COND
-      ((EQ |proplist| (|getProplist| |var| |e|)) |e|)
-      ((QUOTE T)
-       (COND
-        (|$envHashTable|
-         (DO ((#0=#:G1420 |proplist| (CDR #0#)) (|u| NIL))
-             ((OR (ATOM #0#) (PROGN (SETQ |u| (CAR #0#)) NIL)) NIL)
-          (SEQ
-           (EXIT
-            (HPUT |$envHashTable|
-             (CONS |var| (CONS (CAR |u|) NIL)) (QUOTE T)))))))
-       (COND
-        (|$InteractiveMode| (|addBindingInteractive| |var| |proplist| |e|))
-        ((QUOTE T)
-         (COND
-          ((AND (PAIRP |curContour|)
-                (PROGN
-                 (SPADLET |ISTMP#1| (QCAR |curContour|))
-                 (AND (PAIRP |ISTMP#1|) (EQUAL (QCAR |ISTMP#1|) |var|))))
-           (SPADLET |curContour| (CDR |curContour|))))
-         (SPADLET |lx| (CONS |var| |proplist|))
-         (CONS
-          (CONS (CONS |lx| |curContour|) |tailContour|)
-          |tailEnv|)))))))))) 
+  (PROG (|tailContour| |tailEnv| |ISTMP#1| |curContour| |lx|)
+    (DECLARE (SPECIAL |$InteractiveMode| |$envHashTable|))
+    (RETURN
+      (SEQ (PROGN
+             (SPADLET |curContour| (CAAR |e|))
+             (SPADLET |tailContour| (CDAR |e|))
+             (SPADLET |tailEnv| (CDR |e|))
+             (COND
+               ((EQ |proplist| (|getProplist| |var| |e|)) |e|)
+               ('T
+                (COND
+                  (|$envHashTable|
+                      (DO ((G1420 |proplist| (CDR G1420))
+                           (|u| NIL))
+                          ((OR (ATOM G1420)
+                               (PROGN (SETQ |u| (CAR G1420)) NIL))
+                           NIL)
+                        (SEQ (EXIT (HPUT |$envHashTable|
+                                    (CONS |var| (CONS (CAR |u|) NIL))
+                                    'T))))))
+                (COND
+                  (|$InteractiveMode|
+                      (|addBindingInteractive| |var| |proplist| |e|))
+                  ('T
+                   (COND
+                     ((AND (PAIRP |curContour|)
+                           (PROGN
+                             (SPADLET |ISTMP#1| (QCAR |curContour|))
+                             (AND (PAIRP |ISTMP#1|)
+                                  (EQUAL (QCAR |ISTMP#1|) |var|))))
+                      (SPADLET |curContour| (CDR |curContour|))))
+                   (SPADLET |lx| (CONS |var| |proplist|))
+                   (CONS (CONS (CONS |lx| |curContour|) |tailContour|)
+                         |tailEnv|))))))))))
 
 ;position(x,l) ==
 ;  posn(x,l,0) where
@@ -1229,10 +1209,9 @@
 ;      posn(x,rest l,n+1)
 
 (DEFUN |position,posn| (|x| |l| |n|)
- (SEQ
-  (IF (NULL |l|) (EXIT (SPADDIFFERENCE 1)))
-  (IF (BOOT-EQUAL |x| (CAR |l|)) (EXIT |n|))
-  (EXIT (|position,posn| |x| (CDR |l|) (PLUS |n| 1))))) 
+  (SEQ (IF (NULL |l|) (EXIT (SPADDIFFERENCE 1)))
+       (IF (BOOT-EQUAL |x| (CAR |l|)) (EXIT |n|))
+       (EXIT (|position,posn| |x| (CDR |l|) (PLUS |n| 1)))))
 
 (DEFUN |position| (|x| |l|) (|position,posn| |x| |l| 0)) 
 
@@ -1241,9 +1220,7 @@
 ;  [x,:y]
 
 (DEFUN |insert| (|x| |y|)
- (COND
-  ((|member| |x| |y|) |y|)
-  ((QUOTE T) (CONS |x| |y|)))) 
+  (COND ((|member| |x| |y|) |y|) ('T (CONS |x| |y|))))
 
 ;after(u,v) ==
 ;  r:= u
@@ -1251,31 +1228,28 @@
 ;  r
 
 (DEFUN |after| (|u| |v|)
- (PROG (|r|)
-  (RETURN
-   (SEQ
-    (PROGN
-     (SPADLET |r| |u|)
-     (DO ((#0=#:G1421 |u| (CDR #0#))
-          (|x| NIL)
-          (#1=#:G1422 |v| (CDR #1#))
-          (|y| NIL))
-         ((OR (ATOM #0#)
-              (PROGN (SETQ |x| (CAR #0#)) NIL)
-              (ATOM #1#)
-              (PROGN (SETQ |y| (CAR #1#)) NIL))
-            NIL)
-       (SEQ (EXIT (SPADLET |r| (CDR |r|)))))
-     |r|))))) 
+  (PROG (|r|)
+    (RETURN
+      (SEQ (PROGN
+             (SPADLET |r| |u|)
+             (DO ((G1421 |u| (CDR G1421)) (|x| NIL)
+                  (G1422 |v| (CDR G1422)) (|y| NIL))
+                 ((OR (ATOM G1421)
+                      (PROGN (SETQ |x| (CAR G1421)) NIL)
+                      (ATOM G1422)
+                      (PROGN (SETQ |y| (CAR G1422)) NIL))
+                  NIL)
+               (SEQ (EXIT (SPADLET |r| (CDR |r|)))))
+             |r|)))))
 
 ;$blank := char ('_ )
 
-(SPADLET |$blank| (|char| (QUOTE | |))) 
+(SPADLET |$blank| (|char| '| |))
 
 ;trimString s ==
 ;  leftTrim rightTrim s
 
-(DEFUN |trimString| (|s|) (|leftTrim| (|rightTrim| |s|))) 
+(DEFUN |trimString| (|s|) (|leftTrim| (|rightTrim| |s|)))
 
 ;leftTrim s ==
 ;  k := MAXINDEX s
@@ -1286,21 +1260,21 @@
 ;  s
 
 (DEFUN |leftTrim| (|s|)
- (PROG (|k| |j|)
-  (RETURN
-   (SEQ
-    (PROGN
-     (SPADLET |k| (MAXINDEX |s|))
-     (COND
-      ((MINUSP |k|) |s|)
-      ((BOOT-EQUAL (ELT |s| 0) |$blank|)
-       (DO ((|i| 0 (QSADD1 |i|)))
-           ((OR (QSGREATERP |i| |k|)
-                (NULL (BOOT-EQUAL (ELT |s| |i|) |$blank|)))
-             NIL)
-         (SEQ (EXIT (SPADLET |j| |i|))))
-       (SUBSTRING |s| (PLUS |j| 1) NIL))
-      ((QUOTE T) |s|))))))) 
+  (PROG (|k| |j|)
+    (DECLARE (SPECIAL |$blank|))
+    (RETURN
+      (SEQ (PROGN
+             (SPADLET |k| (MAXINDEX |s|))
+             (COND
+               ((MINUSP |k|) |s|)
+               ((BOOT-EQUAL (ELT |s| 0) |$blank|)
+                (DO ((|i| 0 (QSADD1 |i|)))
+                    ((OR (QSGREATERP |i| |k|)
+                         (NULL (BOOT-EQUAL (ELT |s| |i|) |$blank|)))
+                     NIL)
+                  (SEQ (EXIT (SPADLET |j| |i|))))
+                (SUBSTRING |s| (PLUS |j| 1) NIL))
+               ('T |s|)))))))
 
 ;rightTrim s ==  -- assumed a non-empty string
 ;  k := MAXINDEX s
@@ -1311,21 +1285,22 @@
 ;  s
 
 (DEFUN |rightTrim| (|s|)
- (PROG (|k| |j|)
-  (RETURN
-   (SEQ
-    (PROGN
-     (SPADLET |k| (MAXINDEX |s|))
-     (COND
-      ((MINUSP |k|) |s|)
-      ((BOOT-EQUAL (ELT |s| |k|) |$blank|)
-       (DO ((#0=#:G1423 (SPADDIFFERENCE 1)) (|i| |k| (+ |i| #0#)))
-           ((OR (IF (MINUSP #0#) (< |i| 0) (> |i| 0))
-                (NULL (BOOT-EQUAL (ELT |s| |i|) |$blank|)))
-             NIL)
-         (SEQ (EXIT (SPADLET |j| |i|))))
-       (SUBSTRING |s| 0 |j|))
-      ((QUOTE T) |s|))))))) 
+  (PROG (|k| |j|)
+    (DECLARE (SPECIAL |$blank|))
+    (RETURN
+      (SEQ (PROGN
+             (SPADLET |k| (MAXINDEX |s|))
+             (COND
+               ((MINUSP |k|) |s|)
+               ((BOOT-EQUAL (ELT |s| |k|) |$blank|)
+                (DO ((G1423 (SPADDIFFERENCE 1))
+                     (|i| |k| (+ |i| G1423)))
+                    ((OR (IF (MINUSP G1423) (< |i| 0) (> |i| 0))
+                         (NULL (BOOT-EQUAL (ELT |s| |i|) |$blank|)))
+                     NIL)
+                  (SEQ (EXIT (SPADLET |j| |i|))))
+                (SUBSTRING |s| 0 |j|))
+               ('T |s|)))))))
 
 ;pp x ==
 ;  PRETTYPRINT x
@@ -1346,11 +1321,11 @@
 ;  simpBool ['AND,a,b]
 
 (DEFUN |quickAnd| (|a| |b|)
- (COND
-  ((BOOT-EQUAL |a| (QUOTE T)) |b|)
-  ((BOOT-EQUAL |b| (QUOTE T)) |a|)
-  ((OR (NULL |a|) (NULL |b|)) NIL)
-  ((QUOTE T) (|simpBool| (CONS (QUOTE AND) (CONS |a| (CONS |b| NIL))))))) 
+  (COND
+    ((BOOT-EQUAL |a| 'T) |b|)
+    ((BOOT-EQUAL |b| 'T) |a|)
+    ((OR (NULL |a|) (NULL |b|)) NIL)
+    ('T (|simpBool| (CONS 'AND (CONS |a| (CONS |b| NIL)))))))
 
 ;quickOr(a,b) ==
 ;  a = true or b = true => true
@@ -1359,14 +1334,14 @@
 ;  simpCatPredicate simpBool ['OR,a,b]
 
 (DEFUN |quickOr| (|a| |b|)
- (COND
-  ((OR (BOOT-EQUAL |a| (QUOTE T)) (BOOT-EQUAL |b| (QUOTE T))) (QUOTE T))
-  ((NULL |b|) |a|)
-  ((NULL |a|) |b|)
-  ((QUOTE T)
-   (|simpCatPredicate|
-    (|simpBool| (CONS (QUOTE OR) (CONS |a| (CONS |b| NIL))))))))
- 
+  (COND
+    ((OR (BOOT-EQUAL |a| 'T) (BOOT-EQUAL |b| 'T)) 'T)
+    ((NULL |b|) |a|)
+    ((NULL |a|) |b|)
+    ('T
+     (|simpCatPredicate|
+         (|simpBool| (CONS 'OR (CONS |a| (CONS |b| NIL))))))))
+
 ;intern x ==
 ;  STRINGP x =>
 ;    DIGITP x.0 => string2Integer x
@@ -1374,22 +1349,21 @@
 ;  x
 
 (DEFUN |intern| (|x|)
- (COND
-  ((STRINGP |x|)
-   (COND
-    ((DIGITP (ELT |x| 0)) (|string2Integer| |x|))
-    ((QUOTE T) (INTERN |x|))))
-  ((QUOTE T) |x|))) 
+  (COND
+    ((STRINGP |x|)
+     (COND
+       ((DIGITP (ELT |x| 0)) (|string2Integer| |x|))
+       ('T (INTERN |x|))))
+    ('T |x|)))
 
 ;isDomain a ==
 ;  PAIRP a and VECP(CAR a) and
 ;    MEMBER(CAR(a).0, $domainTypeTokens)
 
 (DEFUN |isDomain| (|a|)
- (AND
-  (PAIRP |a|)
-  (VECP (CAR |a|))
-  (|member| (ELT (CAR |a|) 0) |$domainTypeTokens|))) 
+  (DECLARE (SPECIAL |$domainTypeTokens|))
+  (AND (PAIRP |a|) (VECP (CAR |a|))
+       (|member| (ELT (CAR |a|) 0) |$domainTypeTokens|)))
 
 ;$htHash      := MAKE_-HASH_-TABLE()
 
@@ -1413,24 +1387,10 @@
 ; trace what )
 
 (SPADLET |$htSystemCommands|
- (QUOTE
-  ((|boot| . |development|)
-   |clear|
-   |display|
-   (|fin| . |development|)
-   |edit|
-   |help|
-   |frame|
-   |history|
-   |load|
-   |quit|
-   |read|
-   |set|
-   |show|
-   |synonym|
-   |system|
-   |trace|
-   |what|))) 
+         '((|boot| . |development|) |clear| |display|
+           (|fin| . |development|) |edit| |help| |frame| |history|
+           |load| |quit| |read| |set| |show| |synonym| |system| |trace|
+           |what|))
 
 ;$currentSysList := [opOf x for x in $htSystemCommands] --see ht-root
 
@@ -1463,27 +1423,27 @@
 
 ;$charPlus := char '_+
 
-(SPADLET |$charPlus| (|char| (QUOTE +))) 
+(SPADLET |$charPlus| (|char| '+))
 
 ;$charBlank:= (char '_ )
 
-(SPADLET |$charBlank| (|char| (QUOTE | |))) 
+(SPADLET |$charBlank| (|char| '| |))
 
 ;$charLbrace:= char '_{
 
-(SPADLET |$charLbrace| (|char| (QUOTE {))) 
+(SPADLET |$charLbrace| (|char| '{))
 
 ;$charRbrace:= char '_}
 
-(SPADLET |$charRbrace| (|char| (QUOTE }))) 
+(SPADLET |$charRbrace| (|char| '}))
 
 ;$charBack := char '_\
 
-(SPADLET |$charBack| (|char| (QUOTE |\\|))) 
+(SPADLET |$charBack| (|char| '|\\|))
 
 ;$charDash := char '_-
 
-(SPADLET |$charDash| (|char| (QUOTE -))) 
+(SPADLET |$charDash| (|char| '-))
 
 ;$charTab            := CODE_-CHAR(9)
 
@@ -1507,20 +1467,19 @@
 
 ;$charExclusions := [char 'a, char 'A]
 
-(SPADLET |$charExclusions|
- (CONS (|char| (QUOTE |a|)) (CONS (|char| (QUOTE A)) NIL))) 
+(SPADLET |$charExclusions| (CONS (|char| '|a|) (CONS (|char| 'A) NIL)))
 
 ;$charQuote := char '_'
 
-(SPADLET |$charQuote| (|char| (QUOTE |'|))) 
+(SPADLET |$charQuote| (|char| '|'|))
 
 ;$charSemiColon := char '_;
 
-(SPADLET |$charSemiColon| (|char| (QUOTE |;|))) 
+(SPADLET |$charSemiColon| (|char| '|;|))
 
 ;$charComma     := char '_,
 
-(SPADLET |$charComma| (|char| (QUOTE |,|))) 
+(SPADLET |$charComma| (|char| '|,|))
 
 ;$charPeriod    := char '_.
 
@@ -1529,74 +1488,46 @@
 ;$checkPrenAlist := [[char '_(,:char '_)],[char '_{,:char '_}],[char '_[,:char '_]]]
 
 (SPADLET |$checkPrenAlist|
- (CONS
-  (CONS (|char| (QUOTE |(|)) (|char| (QUOTE |)|)))
-  (CONS
-   (CONS (|char| (QUOTE {)) (|char| (QUOTE })))
-   (CONS (CONS (|char| (QUOTE [)) (|char| (QUOTE ]))) NIL)))) 
+         (CONS (CONS (|char| '|(|) (|char| '|)|))
+               (CONS (CONS (|char| '{) (|char| '}))
+                     (CONS (CONS (|char| '[) (|char| '])) NIL))))
 
 ;$charEscapeList:= [char '_%,char '_#,$charBack]
 
 (SPADLET |$charEscapeList|
- (CONS (|char| (QUOTE %)) (CONS (|char| (QUOTE |#|)) (CONS |$charBack| NIL)))) 
+         (CONS (|char| '%) (CONS (|char| '|#|) (CONS |$charBack| NIL))))
 
 ;$charIdentifierEndings := [char '__, char '_!, char '_?]
 
 (SPADLET |$charIdentifierEndings|
- (CONS
-  (|char| (QUOTE _))
-  (CONS (|char| (QUOTE !)) (CONS (|char| (QUOTE ?)) NIL)))) 
+         (CONS (|char| '_) (CONS (|char| '!) (CONS (|char| '?) NIL))))
 
 ;$charSplitList := [$charComma,$charPeriod,char '_[, char '_],$charLbrace, $charRbrace, char '_(, char '_), char '_$, char '_%]
 
 (SPADLET |$charSplitList|
- (CONS
-  |$charComma|
-  (CONS
-   |$charPeriod|
-   (CONS
-    (|char| (QUOTE [))
-    (CONS 
-     (|char| (QUOTE ]))
-     (CONS
-      |$charLbrace|
-      (CONS 
-       |$charRbrace| 
-       (CONS 
-        (|char| (QUOTE |(|))
-        (CONS
-         (|char| (QUOTE |)|))
-         (CONS
-          (|char| (QUOTE $))
-          (CONS
-           (|char| (QUOTE %))
-           NIL))))))))))) 
+         (CONS |$charComma|
+               (CONS |$charPeriod|
+                     (CONS (|char| '[)
+                           (CONS (|char| '])
+                                 (CONS |$charLbrace|
+                                       (CONS |$charRbrace|
+                                        (CONS (|char| '|(|)
+                                         (CONS (|char| '|)|)
+                                          (CONS (|char| '$)
+                                           (CONS (|char| '%) NIL)))))))))))
 
 ;$charDelimiters := [$charBlank, char '_(, char '_), $charBack]
 
 (SPADLET |$charDelimiters|
- (CONS 
-  |$charBlank| 
-  (CONS 
-   (|char| (QUOTE |(|)) 
-   (CONS 
-    (|char| (QUOTE |)|)) 
-    (CONS 
-     |$charBack| 
-     NIL))))) 
+         (CONS |$charBlank|
+               (CONS (|char| '|(|)
+                     (CONS (|char| '|)|) (CONS |$charBack| NIL)))))
 
 ;$HTspadmacros := '("\spadtype" "\spadcommand" "\spadop" "\spadfun" "\spadatt" "\spadsyscom" "\spad" "\s")
 
-(SPADLET |$HTspadmacros| 
- (QUOTE 
-  ("\\spadtype" 
-   "\\spadcommand" 
-   "\\spadop" 
-   "\\spadfun" 
-   "\\spadatt" 
-   "\\spadsyscom" 
-   "\\spad" 
-   "\\s"))) 
+(SPADLET |$HTspadmacros|
+         '("\\spadtype" "\\spadcommand" "\\spadop" "\\spadfun"
+           "\\spadatt" "\\spadsyscom" "\\spad" "\\s"))
 
 ;$HTmacs := [
 ;  ['"\beginmenu",$charRbrace,'"menu",$charLbrace,'"\begin"],
@@ -1607,79 +1538,45 @@
 ;           ['"\endscroll",$charRbrace,'"scroll",$charLbrace,'"\end"]]
 
 (SPADLET |$HTmacs|
- (CONS
-  (CONS
-   (MAKESTRING "\\beginmenu")
-   (CONS
-    |$charRbrace|
-     (CONS
-       (MAKESTRING "menu")
-       (CONS
-         |$charLbrace|
-         (CONS
-          (MAKESTRING "\\begin")
-          NIL)))))
-  (CONS
-   (CONS
-    (MAKESTRING "\\endmenu")
-    (CONS
-     |$charRbrace|
-     (CONS
-      (MAKESTRING "menu")
-      (CONS
-       |$charLbrace|
-       (CONS
-        (MAKESTRING "\\end")
-        NIL)))))
-   (CONS
-    (CONS
-     (MAKESTRING "\\beginitems")
-     (CONS
-      |$charRbrace|
-      (CONS
-       (MAKESTRING "items")
-       (CONS
-        |$charLbrace|
-        (CONS
-         (MAKESTRING "\\begin")
-         NIL)))))
-    (CONS
-     (CONS
-      (MAKESTRING "\\enditems")
-      (CONS
-       |$charRbrace|
-       (CONS
-        (MAKESTRING "items")
-        (CONS
-         |$charLbrace|
-         (CONS
-          (MAKESTRING "\\end")
-          NIL)))))
-     (CONS
-      (CONS
-       (MAKESTRING "\\beginscroll")
-       (CONS 
-        |$charRbrace|
-        (CONS
-         (MAKESTRING "scroll")
-         (CONS
-          |$charLbrace|
-          (CONS
-           (MAKESTRING "\\begin")
-           NIL)))))
-      (CONS
-       (CONS
-        (MAKESTRING "\\endscroll")
-        (CONS
-         |$charRbrace|
-         (CONS
-          (MAKESTRING "scroll")
-          (CONS 
-           |$charLbrace|
-           (CONS
-            (MAKESTRING "\\end")
-            NIL)))))
-        NIL))))))) 
+         (CONS (CONS (MAKESTRING "\\beginmenu")
+                     (CONS |$charRbrace|
+                           (CONS (MAKESTRING "menu")
+                                 (CONS |$charLbrace|
+                                       (CONS (MAKESTRING "\\begin")
+                                        NIL)))))
+               (CONS (CONS (MAKESTRING "\\endmenu")
+                           (CONS |$charRbrace|
+                                 (CONS (MAKESTRING "menu")
+                                       (CONS |$charLbrace|
+                                        (CONS (MAKESTRING "\\end") NIL)))))
+                     (CONS (CONS (MAKESTRING "\\beginitems")
+                                 (CONS |$charRbrace|
+                                       (CONS (MAKESTRING "items")
+                                        (CONS |$charLbrace|
+                                         (CONS (MAKESTRING "\\begin")
+                                          NIL)))))
+                           (CONS (CONS (MAKESTRING "\\enditems")
+                                       (CONS |$charRbrace|
+                                        (CONS (MAKESTRING "items")
+                                         (CONS |$charLbrace|
+                                          (CONS (MAKESTRING "\\end")
+                                           NIL)))))
+                                 (CONS (CONS
+                                        (MAKESTRING "\\beginscroll")
+                                        (CONS |$charRbrace|
+                                         (CONS (MAKESTRING "scroll")
+                                          (CONS |$charLbrace|
+                                           (CONS (MAKESTRING "\\begin")
+                                            NIL)))))
+                                       (CONS
+                                        (CONS
+                                         (MAKESTRING "\\endscroll")
+                                         (CONS |$charRbrace|
+                                          (CONS (MAKESTRING "scroll")
+                                           (CONS |$charLbrace|
+                                            (CONS (MAKESTRING "\\end")
+                                             NIL)))))
+                                        NIL)))))))
 
 ;$HTlinks := '(
 ;  "\downlink"
@@ -1689,12 +1586,8 @@
 ;  "\menumemolink")
 
 (SPADLET |$HTlinks|
- (QUOTE
-  ("\\downlink"  
-   "\\menulink" 
-   "\\menudownlink" 
-   "\\menuwindowlink" 
-   "\\menumemolink"))) 
+         '("\\downlink" "\\menulink" "\\menudownlink"
+           "\\menuwindowlink" "\\menumemolink"))
 
 ;$HTlisplinks := '(
 ;  "\lispdownlink"
@@ -1705,13 +1598,8 @@
 ;  "\lispmemolink")
 
 (SPADLET |$HTlisplinks|
- (QUOTE
-  ("\\lispdownlink" 
-   "\\menulispdownlink" 
-   "\\menulispwindowlink"
-   "\\menulispmemolink" 
-   "\\lispwindowlink" 
-   "\\lispmemolink"))) 
+         '("\\lispdownlink" "\\menulispdownlink" "\\menulispwindowlink"
+           "\\menulispmemolink" "\\lispwindowlink" "\\lispmemolink"))
 
 ;$beginEndList := '(
 ;  "page"
@@ -1722,15 +1610,15 @@
 ;  "detail")
 
 (SPADLET |$beginEndList|
- (QUOTE ("page" "items" "menu" "scroll" "verbatim" "detail"))) 
+         '("page" "items" "menu" "scroll" "verbatim" "detail"))
 
 ;isDefaultPackageName x == (s := PNAME x).(MAXINDEX s) = char '_&
 
 (DEFUN |isDefaultPackageName| (|x|)
- (PROG (|s|)
-  (RETURN
-   (BOOT-EQUAL (ELT (SPADLET |s| (PNAME |x|)) (MAXINDEX |s|))
-               (|char| (QUOTE &)))))) 
+  (PROG (|s|)
+    (RETURN
+      (BOOT-EQUAL (ELT (SPADLET |s| (PNAME |x|)) (MAXINDEX |s|))
+          (|char| '&)))))
 
 
 @