diff --git a/changelog b/changelog
index d2ba894..bc48699 100644
--- a/changelog
+++ b/changelog
@@ -1,3 +1,5 @@
+20091007 tpd src/axiom-website/patches.html 20091007.05.tpd.patch
+20091007 tpd src/interp/g-cndata.lisp cleanup
 20091007 tpd src/axiom-website/patches.html 20091007.04.tpd.patch
 20091007 tpd src/interp/g-error.lisp cleanup
 20091007 tpd src/axiom-website/patches.html 20091007.03.tpd.patch
diff --git a/src/axiom-website/patches.html b/src/axiom-website/patches.html
index 56fcedc..9f4264a 100644
--- a/src/axiom-website/patches.html
+++ b/src/axiom-website/patches.html
@@ -2129,5 +2129,7 @@ src/interp/g-timer.lisp cleanup<br/>
 src/interp/g-opt.lisp cleanup<br/>
 <a href="patches/20091007.04.tpd.patch">20091007.04.tpd.patch</a>
 src/interp/g-error.lisp cleanup<br/>
+<a href="patches/20091007.05.tpd.patch">20091007.05.tpd.patch</a>
+src/interp/g-cndata.lisp cleanup<br/>
  </body>
 </html>
diff --git a/src/interp/g-cndata.lisp.pamphlet b/src/interp/g-cndata.lisp.pamphlet
index ba71b5a..ece9995 100644
--- a/src/interp/g-cndata.lisp.pamphlet
+++ b/src/interp/g-cndata.lisp.pamphlet
@@ -25,13 +25,16 @@
 ;  $lowerCaseConTb
 
 (DEFUN |mkLowerCaseConTable| ()
- (SEQ
-  (PROGN
-   (SPADLET |$lowerCaseConTb| (MAKE-HASH-TABLE))
-   (DO ((#0=#:G166061 (|allConstructors|) (CDR #0#)) (|x| NIL))
-       ((OR (ATOM #0#) (PROGN (SETQ |x| (CAR #0#)) NIL)) NIL)
-    (SEQ (EXIT (|augmentLowerCaseConTable| |x|))))
-   |$lowerCaseConTb|))) 
+  (DECLARE (SPECIAL |$lowerCaseConTb|))
+  (SEQ (PROGN
+         (SPADLET |$lowerCaseConTb| (MAKE-HASH-TABLE))
+         (DO ((G166061 (|allConstructors|) (CDR G166061))
+              (|x| NIL))
+             ((OR (ATOM G166061)
+                  (PROGN (SETQ |x| (CAR G166061)) NIL))
+              NIL)
+           (SEQ (EXIT (|augmentLowerCaseConTable| |x|))))
+         |$lowerCaseConTb|)))
 
 ;augmentLowerCaseConTable x ==
 ;  y:=GETDATABASE(x,'ABBREVIATION)
@@ -41,14 +44,15 @@
 ;  HPUT($lowerCaseConTb,y,item)
 
 (DEFUN |augmentLowerCaseConTable| (|x|)
- (PROG (|y| |item|)
-  (RETURN
-   (PROGN
-    (SPADLET |y| (GETDATABASE |x| (QUOTE ABBREVIATION)))
-    (SPADLET |item| (CONS |x| (CONS |y| (CONS NIL NIL))))
-    (HPUT |$lowerCaseConTb| |x| |item|)
-    (HPUT |$lowerCaseConTb| (DOWNCASE |x|) |item|)
-    (HPUT |$lowerCaseConTb| |y| |item|))))) 
+  (PROG (|y| |item|)
+    (DECLARE (SPECIAL |$lowerCaseConTb|))
+    (RETURN
+      (PROGN
+        (SPADLET |y| (GETDATABASE |x| 'ABBREVIATION))
+        (SPADLET |item| (CONS |x| (CONS |y| (CONS NIL NIL))))
+        (HPUT |$lowerCaseConTb| |x| |item|)
+        (HPUT |$lowerCaseConTb| (DOWNCASE |x|) |item|)
+        (HPUT |$lowerCaseConTb| |y| |item|)))))
 
 ;getCDTEntry(info,isName) ==
 ;  not IDENTP info => NIL
@@ -60,66 +64,63 @@
 ;  entry
 
 (DEFUN |getCDTEntry| (|info| |isName|)
- (PROG (|entry| |name| |abb|)
-  (RETURN
-   (COND
-    ((NULL (IDENTP |info|)) NIL)
-    ((SPADLET |entry| (HGET |$lowerCaseConTb| |info|))
-     (SPADLET |name| (CAR |entry|))
-     (SPADLET |abb| (CADR |entry|))
-     (COND
-      ((AND |isName| (EQ |name| |info|)) |entry|)
-      ((AND (NULL |isName|) (EQ |abb| |info|)) |entry|)
-      ((QUOTE T) NIL)))
-    ((QUOTE T) |entry|))))) 
-;
+  (PROG (|entry| |name| |abb|)
+    (DECLARE (SPECIAL |$lowerCaseConTb|))
+    (RETURN
+      (COND
+        ((NULL (IDENTP |info|)) NIL)
+        ((SPADLET |entry| (HGET |$lowerCaseConTb| |info|))
+         (SPADLET |name| (CAR |entry|)) (SPADLET |abb| (CADR |entry|))
+         (COND
+           ((AND |isName| (EQ |name| |info|)) |entry|)
+           ((AND (NULL |isName|) (EQ |abb| |info|)) |entry|)
+           ('T NIL)))
+        ('T |entry|)))))
+
 ;putConstructorProperty(name,prop,val) ==
 ;  null (entry := getCDTEntry(name,true)) => NIL
 ;  RPLACD(CDR entry,PUTALIST(CDDR entry,prop,val))
 ;  true
 
 (DEFUN |putConstructorProperty| (|name| |prop| |val|)
- (PROG (|entry|)
-  (RETURN
-   (COND
-    ((NULL (SPADLET |entry| (|getCDTEntry| |name| (QUOTE T)))) NIL)
-    ((QUOTE T)
-     (RPLACD (CDR |entry|) (PUTALIST (CDDR |entry|) |prop| |val|))
-     (QUOTE T)))))) 
+  (PROG (|entry|)
+    (RETURN
+      (COND
+        ((NULL (SPADLET |entry| (|getCDTEntry| |name| 'T))) NIL)
+        ('T
+         (RPLACD (CDR |entry|) (PUTALIST (CDDR |entry|) |prop| |val|))
+         'T)))))
 
 ;attribute? name ==
 ;        MEMQ(name, _*ATTRIBUTES_*)
 
-(DEFUN |attribute?| (|name|) (MEMQ |name| *ATTRIBUTES*)) 
+(DEFUN |attribute?| (|name|)
+  (DECLARE (SPECIAL *ATTRIBUTES*))
+  (MEMQ |name| *ATTRIBUTES*))
 
-;
 ;abbreviation? abb ==
 ;  -- if it is an abbreviation, return the corresponding name
 ;  GETDATABASE(abb,'CONSTRUCTOR)
 
-(DEFUN |abbreviation?| (|abb|) (GETDATABASE |abb| (QUOTE CONSTRUCTOR))) 
+(DEFUN |abbreviation?| (|abb|) (GETDATABASE |abb| 'CONSTRUCTOR))
 
-;
 ;constructor? name ==
 ;  -- if it is a constructor name, return the abbreviation
 ;  GETDATABASE(name,'ABBREVIATION)
 
-(DEFUN |constructor?| (|name|) (GETDATABASE |name| (QUOTE ABBREVIATION))) 
+(DEFUN |constructor?| (|name|) (GETDATABASE |name| 'ABBREVIATION))
 
-;
 ;domainForm? d ==
 ;  GETDATABASE(opOf d,'CONSTRUCTORKIND) = 'domain
 
 (DEFUN |domainForm?| (|d|)
- (BOOT-EQUAL (GETDATABASE (|opOf| |d|) (QUOTE CONSTRUCTORKIND))
-             (QUOTE |domain|))) 
+  (BOOT-EQUAL (GETDATABASE (|opOf| |d|) 'CONSTRUCTORKIND) '|domain|))
 
 ;packageForm? d ==
 ;  GETDATABASE(opOf d,'CONSTRUCTORKIND) = 'package
 
 (DEFUN |packageForm?| (|d|)
- (BOOT-EQUAL (GETDATABASE (|opOf| |d|) (QUOTE CONSTRUCTORKIND))
-             (QUOTE |package|))) 
+  (BOOT-EQUAL (GETDATABASE (|opOf| |d|) 'CONSTRUCTORKIND) '|package|))
 
 ;categoryForm? c ==
 ;  op := opOf c
@@ -128,54 +129,55 @@
 ;  nil
 
 (DEFUN |categoryForm?| (|c|)
- (PROG (|op|)
-  (RETURN
-   (PROGN
-    (SPADLET |op| (|opOf| |c|))
-    (COND
-     ((MEMQ |op| |$CategoryNames|) (QUOTE T))
-     ((BOOT-EQUAL (GETDATABASE |op| (QUOTE CONSTRUCTORKIND))
-                  (QUOTE |category|))
-      (QUOTE T))
-     ((QUOTE T) NIL)))))) 
+  (PROG (|op|)
+    (DECLARE (SPECIAL |$CategoryNames|))
+    (RETURN
+      (PROGN
+        (SPADLET |op| (|opOf| |c|))
+        (COND
+          ((MEMQ |op| |$CategoryNames|) 'T)
+          ((BOOT-EQUAL (GETDATABASE |op| 'CONSTRUCTORKIND) '|category|)
+           'T)
+          ('T NIL))))))
 
 ;getImmediateSuperDomain(d) ==
 ;  IFCAR GETDATABASE(opOf d, 'SUPERDOMAIN)
 
 (DEFUN |getImmediateSuperDomain| (|d|)
- (IFCAR (GETDATABASE (|opOf| |d|) (QUOTE SUPERDOMAIN)))) 
+  (IFCAR (GETDATABASE (|opOf| |d|) 'SUPERDOMAIN)))
 
 ;maximalSuperType d ==
 ;  d' := GETDATABASE(opOf d, 'SUPERDOMAIN) => maximalSuperType first d'
 ;  d
 
 (DEFUN |maximalSuperType| (|d|)
- (PROG (|d'|)
-  (RETURN
-   (COND
-    ((SPADLET |d'| (GETDATABASE (|opOf| |d|) (QUOTE SUPERDOMAIN)))
-     (|maximalSuperType| (CAR |d'|)))
-    ((QUOTE T) |d|))))) 
+  (PROG (|d'|)
+    (RETURN
+      (COND
+        ((SPADLET |d'| (GETDATABASE (|opOf| |d|) 'SUPERDOMAIN))
+         (|maximalSuperType| (CAR |d'|)))
+        ('T |d|)))))
 
 ;-- probably will switch over to 'libName soon
 ;getLisplibName(c) == getConstructorAbbreviation(c)
 
-(DEFUN |getLisplibName| (|c|) (|getConstructorAbbreviation| |c|)) 
-;
+(DEFUN |getLisplibName| (|c|)
+ (|getConstructorAbbreviation| |c|)) 
+
 ;getConstructorAbbreviation op ==
 ;  constructor?(op) or throwKeyedMsg("S2IL0015",[op])
 
 (DEFUN |getConstructorAbbreviation| (|op|)
- (OR (|constructor?| |op|)
-     (|throwKeyedMsg| (QUOTE S2IL0015) (CONS |op| NIL)))) 
-;
+  (OR (|constructor?| |op|)
+      (|throwKeyedMsg| 'S2IL0015 (CONS |op| NIL))))
+
 ;getConstructorUnabbreviation op ==
 ;  abbreviation?(op) or throwKeyedMsg("S2IL0019",[op])
 
 (DEFUN |getConstructorUnabbreviation| (|op|)
- (OR (|abbreviation?| |op|) 
-     (|throwKeyedMsg| (QUOTE S2IL0019) (CONS |op| NIL)))) 
-;
+  (OR (|abbreviation?| |op|)
+      (|throwKeyedMsg| 'S2IL0019 (CONS |op| NIL))))
+
 ;mkUserConstructorAbbreviation(c,a,type) ==
 ;  if not atom c then c:= CAR c  --  Existing constructors will be wrapped
 ;  constructorAbbreviationErrorCheck(c,a,type,'abbreviationError)
@@ -185,15 +187,15 @@
 ;  setAutoLoadProperty(c)
 
 (DEFUN |mkUserConstructorAbbreviation| (|c| |a| |type|)
- (PROGN
-  (COND ((NULL (ATOM |c|)) (SPADLET |c| (CAR |c|))))
-  (|constructorAbbreviationErrorCheck| |c| |a| |type|
-    (QUOTE |abbreviationError|))
-  (|clearClams|)
-  (|clearConstructorCache| |c|)
-  (|installConstructor| |c| |type|)
-  (|setAutoLoadProperty| |c|))) 
-;
+  (PROGN
+    (COND ((NULL (ATOM |c|)) (SPADLET |c| (CAR |c|))))
+    (|constructorAbbreviationErrorCheck| |c| |a| |type|
+        '|abbreviationError|)
+    (|clearClams|)
+    (|clearConstructorCache| |c|)
+    (|installConstructor| |c| |type|)
+    (|setAutoLoadProperty| |c|)))
+
 ;installConstructor(cname,type) ==
 ;  (entry := getCDTEntry(cname,true)) => entry
 ;  item := [cname,GETDATABASE(cname,'ABBREVIATION),nil]
@@ -202,38 +204,37 @@
 ;    HPUT($lowerCaseConTb,DOWNCASE cname,item)
 
 (DEFUN |installConstructor| (|cname| |type|)
- (PROG (|entry| |item|)
-  (RETURN
-   (COND
-    ((SPADLET |entry| (|getCDTEntry| |cname| (QUOTE T))) |entry|)
-    ((QUOTE T)
-     (SPADLET |item|
-      (CONS |cname|
-       (CONS (GETDATABASE |cname| (QUOTE ABBREVIATION)) (CONS NIL NIL))))
-     (COND
-      ((AND (BOUNDP (QUOTE |$lowerCaseConTb|)) |$lowerCaseConTb|)
-       (HPUT |$lowerCaseConTb| |cname| |item|)
-       (HPUT |$lowerCaseConTb| (DOWNCASE |cname|) |item|))
-      ((QUOTE T) NIL))))))) 
-;
+  (DECLARE (IGNORE |type|))
+  (PROG (|entry| |item|)
+    (DECLARE (SPECIAL |$lowerCaseConTb|))
+    (RETURN
+      (COND
+        ((SPADLET |entry| (|getCDTEntry| |cname| 'T)) |entry|)
+        ('T
+         (SPADLET |item|
+                  (CONS |cname|
+                        (CONS (GETDATABASE |cname| 'ABBREVIATION)
+                              (CONS NIL NIL))))
+         (COND
+           ((AND (BOUNDP '|$lowerCaseConTb|) |$lowerCaseConTb|)
+            (HPUT |$lowerCaseConTb| |cname| |item|)
+            (HPUT |$lowerCaseConTb| (DOWNCASE |cname|) |item|))
+           ('T NIL)))))))
+
 ;constructorNameConflict(name,kind) ==
 ;  userError
 ;    ["The name",:bright name,"conflicts with the name of an existing rule",
 ;      "%l","please choose another ",kind]
 
 (DEFUN |constructorNameConflict| (|name| |kind|)
- (|userError|
-  (CONS
-   (QUOTE |The name|)
-   (APPEND
-    (|bright| |name|)
-    (CONS
-     (QUOTE |conflicts with the name of an existing rule|)
-     (CONS
-      (QUOTE |%l|)
-      (CONS (QUOTE |please choose another |) (CONS |kind| NIL)))))))) 
+  (|userError|
+      (CONS '|The name|
+            (APPEND (|bright| |name|)
+                    (CONS '|conflicts with the name of an existing rule|
+                          (CONS '|%l|
+                                (CONS '|please choose another |
+                                      (CONS |kind| NIL))))))))
 
-;
 ;constructorAbbreviationErrorCheck(c,a,typ,errmess) ==
 ;  siz := SIZE (s := PNAME a)
 ;  if typ = 'category and siz > 7
@@ -248,32 +249,33 @@
 ;  c=name and typ^=type => lisplibError(c,a,typ,abb,name,type,'wrongType)
 
 (DEFUN |constructorAbbreviationErrorCheck| (|c| |a| |typ| |errmess|)
- (PROG (|s| |siz| |abb| |name| |type|)
-  (RETURN
-   (PROGN
-    (SPADLET |siz| (SIZE (SPADLET |s| (PNAME |a|))))
-    (COND
-     ((AND (BOOT-EQUAL |typ| (QUOTE |category|)) (> |siz| 7))
-      (|throwKeyedErrorMsg| (QUOTE |precompilation|) (QUOTE S2IL0021) NIL)))
-    (COND
-     ((> |siz| 8)
-      (|throwKeyedErrorMsg| (QUOTE |precompilation|) (QUOTE S2IL0006) NIL)))
-    (COND ((NEQUAL |s| (UPCASE |s|)) (|throwKeyedMsg| (QUOTE S2IL0006) NIL)))
-    (SPADLET |abb| (GETDATABASE |c| (QUOTE ABBREVIATION)))
-    (SPADLET |name| (GETDATABASE |a| (QUOTE CONSTRUCTOR)))
-    (SPADLET |type| (GETDATABASE |c| (QUOTE CONSTRUCTORKIND)))
-    (COND
-     ((AND (BOOT-EQUAL |a| |abb|) (NEQUAL |c| |name|))
-      (|lisplibError| |c| |a| |typ| |abb| |name| |type|
-       (QUOTE |duplicateAbb|)))
-     ((AND (BOOT-EQUAL |a| |name|) (NEQUAL |c| |name|))
-      (|lisplibError| |c| |a| |typ| |abb| |name| |type|
-       (QUOTE |abbIsName|)))
-     ((AND (BOOT-EQUAL |c| |name|) (NEQUAL |typ| |type|))
-      (|lisplibError| |c| |a| |typ| |abb| |name| |type|
-       (QUOTE |wrongType|)))))))) 
+  (DECLARE (IGNORE |errmess|))
+  (PROG (|s| |siz| |abb| |name| |type|)
+    (RETURN
+      (PROGN
+        (SPADLET |siz| (SIZE (SPADLET |s| (PNAME |a|))))
+        (COND
+          ((AND (BOOT-EQUAL |typ| '|category|) (> |siz| 7))
+           (|throwKeyedErrorMsg| '|precompilation| 'S2IL0021 NIL)))
+        (COND
+          ((> |siz| 8)
+           (|throwKeyedErrorMsg| '|precompilation| 'S2IL0006 NIL)))
+        (COND
+          ((NEQUAL |s| (UPCASE |s|)) (|throwKeyedMsg| 'S2IL0006 NIL)))
+        (SPADLET |abb| (GETDATABASE |c| 'ABBREVIATION))
+        (SPADLET |name| (GETDATABASE |a| 'CONSTRUCTOR))
+        (SPADLET |type| (GETDATABASE |c| 'CONSTRUCTORKIND))
+        (COND
+          ((AND (BOOT-EQUAL |a| |abb|) (NEQUAL |c| |name|))
+           (|lisplibError| |c| |a| |typ| |abb| |name| |type|
+               '|duplicateAbb|))
+          ((AND (BOOT-EQUAL |a| |name|) (NEQUAL |c| |name|))
+           (|lisplibError| |c| |a| |typ| |abb| |name| |type|
+               '|abbIsName|))
+          ((AND (BOOT-EQUAL |c| |name|) (NEQUAL |typ| |type|))
+           (|lisplibError| |c| |a| |typ| |abb| |name| |type|
+               '|wrongType|)))))))
 
-;
 ;abbreviationError(c,a,typ,abb,name,type,error) ==
 ;  sayKeyedMsg("S2IL0009",[a,typ,c])
 ;  error='duplicateAbb =>
@@ -285,18 +287,19 @@
 ;  NIL
 
 (DEFUN |abbreviationError| (|c| |a| |typ| |abb| |name| |type| |error|)
- (PROGN
-  (|sayKeyedMsg| (QUOTE S2IL0009) (CONS |a| (CONS |typ| (CONS |c| NIL))))
-  (COND
-   ((BOOT-EQUAL |error| (QUOTE |duplicateAbb|))
-    (|throwKeyedMsg| 'S2IL0010 (CONS |a| (CONS |typ| (CONS |name| NIL)))))
-   ((BOOT-EQUAL |error| (QUOTE |abbIsName|))
-    (|throwKeyedMsg| (QUOTE S2IL0011) (CONS |a| (CONS |type| NIL))))
-   ((BOOT-EQUAL |error| (QUOTE |wrongType|))
-    (|throwKeyedMsg| (QUOTE S2IL0012) (CONS |c| (CONS |type| NIL))))
-   ((QUOTE T) NIL)))) 
+  (DECLARE (IGNORE |abb|))
+  (PROGN
+    (|sayKeyedMsg| 'S2IL0009 (CONS |a| (CONS |typ| (CONS |c| NIL))))
+    (COND
+      ((BOOT-EQUAL |error| '|duplicateAbb|)
+       (|throwKeyedMsg| 'S2IL0010
+           (CONS |a| (CONS |typ| (CONS |name| NIL)))))
+      ((BOOT-EQUAL |error| '|abbIsName|)
+       (|throwKeyedMsg| 'S2IL0011 (CONS |a| (CONS |type| NIL))))
+      ((BOOT-EQUAL |error| '|wrongType|)
+       (|throwKeyedMsg| 'S2IL0012 (CONS |c| (CONS |type| NIL))))
+      ('T NIL))))
 
-;
 ;abbreviate u ==
 ;  u is ['Union,:arglist] =>
 ;    ['Union,:[abbreviate a for a in arglist]]
@@ -307,44 +310,47 @@
 ;  constructor?(u) or u
 
 (DEFUN |abbreviate| (|u|)
- (PROG (|op| |arglist| |abb|)
-  (RETURN
-   (SEQ
-    (COND
-     ((AND (PAIRP |u|)
-           (EQ (QCAR |u|) (QUOTE |Union|))
-           (PROGN (SPADLET |arglist| (QCDR |u|)) (QUOTE T)))
-      (CONS
-       (QUOTE |Union|)
-       (PROG (#0=#:G166167) 
-        (SPADLET #0# NIL)
-        (RETURN
-         (DO ((#1=#:G166172 |arglist| (CDR #1#)) (|a| NIL))
-             ((OR (ATOM #1#) (PROGN (SETQ |a| (CAR #1#)) NIL)) (NREVERSE0 #0#))
-          (SEQ (EXIT (SETQ #0# (CONS (|abbreviate| |a|) #0#)))))))))
-     ((AND (PAIRP |u|)
-           (PROGN
-            (SPADLET |op| (QCAR |u|))
-            (SPADLET |arglist| (QCDR |u|))
-            (QUOTE T)))
-      (COND
-       ((SPADLET |abb| (|constructor?| |op|))
-        (CONS |abb| (|condAbbrev| |arglist|
-         (|getPartialConstructorModemapSig| |op|))))
-       ((QUOTE T) |u|)))
-     ((QUOTE T) (OR (|constructor?| |u|) |u|))))))) 
+  (PROG (|op| |arglist| |abb|)
+    (RETURN
+      (SEQ (COND
+             ((AND (PAIRP |u|) (EQ (QCAR |u|) '|Union|)
+                   (PROGN (SPADLET |arglist| (QCDR |u|)) 'T))
+              (CONS '|Union|
+                    (PROG (G166167)
+                      (SPADLET G166167 NIL)
+                      (RETURN
+                        (DO ((G166172 |arglist| (CDR G166172))
+                             (|a| NIL))
+                            ((OR (ATOM G166172)
+                                 (PROGN
+                                   (SETQ |a| (CAR G166172))
+                                   NIL))
+                             (NREVERSE0 G166167))
+                          (SEQ (EXIT (SETQ G166167
+                                      (CONS (|abbreviate| |a|)
+                                       G166167)))))))))
+             ((AND (PAIRP |u|)
+                   (PROGN
+                     (SPADLET |op| (QCAR |u|))
+                     (SPADLET |arglist| (QCDR |u|))
+                     'T))
+              (COND
+                ((SPADLET |abb| (|constructor?| |op|))
+                 (CONS |abb|
+                       (|condAbbrev| |arglist|
+                           (|getPartialConstructorModemapSig| |op|))))
+                ('T |u|)))
+             ('T (OR (|constructor?| |u|) |u|)))))))
 
-;
 ;unabbrev u == unabbrev1(u,nil)
 
-(DEFUN |unabbrev| (|u|) (|unabbrev1| |u| NIL)) 
+(DEFUN |unabbrev| (|u|)
+  (|unabbrev1| |u| NIL)) 
 
-;
 ;unabbrevAndLoad u == unabbrev1(u,true)
 
-(DEFUN |unabbrevAndLoad| (|u|) (|unabbrev1| |u| (QUOTE T))) 
+(DEFUN |unabbrevAndLoad| (|u|) (|unabbrev1| |u| 'T))
 
-;
 ;isNameOfType x ==
 ;  $doNotAddEmptyModeIfTrue:local:= true
 ;  (val := get(x,'value,$InteractiveFrame)) and
@@ -354,22 +360,21 @@
 ;  constructor? y
 
 (DEFUN |isNameOfType| (|x|)
- (PROG (|$doNotAddEmptyModeIfTrue| |val| |domain| |y|)
- (DECLARE (SPECIAL |$doNotAddEmptyModeIfTrue|))
-  (RETURN
-   (PROGN
-    (SPADLET |$doNotAddEmptyModeIfTrue| (QUOTE T))
-    (COND
-     ((AND
-       (SPADLET |val| (|get| |x| (QUOTE |value|) |$InteractiveFrame|))
-       (SPADLET |domain| (|objMode| |val|))
-       (|member| |domain|
-         (QUOTE ((|Mode|) (|Domain|) (|SubDomain| (|Domain|))))))
-      (QUOTE T))
-     ((QUOTE T)
-      (SPADLET |y| (|opOf| (|unabbrev| |x|))) (|constructor?| |y|))))))) 
+  (PROG (|$doNotAddEmptyModeIfTrue| |val| |domain| |y|)
+    (DECLARE (SPECIAL |$doNotAddEmptyModeIfTrue| |$InteractiveFrame|))
+    (RETURN
+      (PROGN
+        (SPADLET |$doNotAddEmptyModeIfTrue| 'T)
+        (COND
+          ((AND (SPADLET |val|
+                         (|get| |x| '|value| |$InteractiveFrame|))
+                (SPADLET |domain| (|objMode| |val|))
+                (|member| |domain|
+                    '((|Mode|) (|Domain|) (|SubDomain| (|Domain|)))))
+           'T)
+          ('T (SPADLET |y| (|opOf| (|unabbrev| |x|)))
+           (|constructor?| |y|)))))))
 
-;
 ;unabbrev1(u,modeIfTrue) ==
 ;  atom u =>
 ;    modeIfTrue =>
@@ -396,69 +401,87 @@
 ;  u
 
 (DEFUN |unabbrev1| (|u| |modeIfTrue|)
- (PROG (|largs| |a| |op| |arglist| |d| |cname| |r|)
-  (RETURN
-   (SEQ
-    (COND
-     ((ATOM |u|)
-      (COND
-       (|modeIfTrue|
-        (COND
-         ((SPADLET |d| (|isDomainValuedVariable| |u|)) |u|)
-         ((SPADLET |a| (|abbreviation?| |u|))
-          (COND
-           ((GETDATABASE |a| (QUOTE NILADIC)) (CONS |a| NIL))
-           ((QUOTE T)
-            (SPADLET |largs|
-             (PROG (#0=#:G166214)
-              (SPADLET #0# NIL)
-              (RETURN
-               (DO ((#1=#:G166219
-                     (|getPartialConstructorModemapSig| |a|)
-                     (CDR #1#))
-                    (|arg| NIL))
-                   ((OR (ATOM #1#) (PROGN (SETQ |arg| (CAR #1#)) NIL))
-                     (NREVERSE0 #0#))
-                (SEQ (EXIT (SETQ #0# (CONS (QUOTE |$EmptyMode|) #0#))))))))
-            (|unabbrev1| (CONS |u| |largs|) |modeIfTrue|))))
-         ((QUOTE T) |u|)))
-       ((QUOTE T)
-        (SPADLET |a| (OR (|abbreviation?| |u|) |u|))
-        (COND
-         ((GETDATABASE |a| (QUOTE NILADIC)) (CONS |a| NIL))
-         ((QUOTE T) |a|)))))
-     ((QUOTE T)
-      (SPADLET |op| (CAR |u|))
-      (SPADLET |arglist| (CDR |u|))
-      (COND
-       ((BOOT-EQUAL |op| (QUOTE |Join|))
-        (CONS
-         (QUOTE |Join|)
-         (PROG (#2=#:G166229)
-          (SPADLET #2# NIL)
-          (RETURN
-           (DO ((#3=#:G166234 |arglist| (CDR #3#))
-                (|x| NIL))
-               ((OR (ATOM #3#) (PROGN (SETQ |x| (CAR #3#)) NIL))
-                 (NREVERSE0 #2#))
-            (SEQ
-             (EXIT (SETQ #2# (CONS (|unabbrev1| |x| |modeIfTrue|) #2#)))))))))
-       ((SPADLET |d| (|isDomainValuedVariable| |op|))
-        (|throwKeyedMsg| (QUOTE S2IL0013) (CONS |op| (CONS |d| NIL))))
-       ((SPADLET |r| (|unabbrevSpecialForms| |op| |arglist| |modeIfTrue|)) |r|)
-       ((OR (SPADLET |cname| (|abbreviation?| |op|))
-            (AND (|constructor?| |op|) (SPADLET |cname| |op|)))
-        (COND
-         ((SPADLET |r| (|unabbrevSpecialForms| |cname| |arglist| |modeIfTrue|))
-          |r|)
-         ((QUOTE T)
-          (CONS
-           |cname|
-           (|condUnabbrev| |op| |arglist|
-            (|getPartialConstructorModemapSig| |cname|) |modeIfTrue|)))))
-       ((QUOTE T) |u|)))))))) 
+  (PROG (|largs| |a| |op| |arglist| |d| |cname| |r|)
+    (DECLARE (SPECIAL |$EmptyMode|))
+    (RETURN
+      (SEQ (COND
+             ((ATOM |u|)
+              (COND
+                (|modeIfTrue|
+                    (COND
+                      ((SPADLET |d| (|isDomainValuedVariable| |u|))
+                       |u|)
+                      ((SPADLET |a| (|abbreviation?| |u|))
+                       (COND
+                         ((GETDATABASE |a| 'NILADIC) (CONS |a| NIL))
+                         ('T
+                          (SPADLET |largs|
+                                   (PROG (G166214)
+                                     (SPADLET G166214 NIL)
+                                     (RETURN
+                                       (DO
+                                        ((G166219
+                                          (|getPartialConstructorModemapSig|
+                                           |a|)
+                                          (CDR G166219))
+                                         (|arg| NIL))
+                                        ((OR (ATOM G166219)
+                                          (PROGN
+                                            (SETQ |arg|
+                                             (CAR G166219))
+                                            NIL))
+                                         (NREVERSE0 G166214))
+                                         (SEQ
+                                          (EXIT
+                                           (SETQ G166214
+                                            (CONS '|$EmptyMode|
+                                             G166214))))))))
+                          (|unabbrev1| (CONS |u| |largs|) |modeIfTrue|))))
+                      ('T |u|)))
+                ('T (SPADLET |a| (OR (|abbreviation?| |u|) |u|))
+                 (COND
+                   ((GETDATABASE |a| 'NILADIC) (CONS |a| NIL))
+                   ('T |a|)))))
+             ('T (SPADLET |op| (CAR |u|)) (SPADLET |arglist| (CDR |u|))
+              (COND
+                ((BOOT-EQUAL |op| '|Join|)
+                 (CONS '|Join|
+                       (PROG (G166229)
+                         (SPADLET G166229 NIL)
+                         (RETURN
+                           (DO ((G166234 |arglist| (CDR G166234))
+                                (|x| NIL))
+                               ((OR (ATOM G166234)
+                                    (PROGN
+                                      (SETQ |x| (CAR G166234))
+                                      NIL))
+                                (NREVERSE0 G166229))
+                             (SEQ (EXIT (SETQ G166229
+                                         (CONS
+                                          (|unabbrev1| |x|
+                                           |modeIfTrue|)
+                                          G166229)))))))))
+                ((SPADLET |d| (|isDomainValuedVariable| |op|))
+                 (|throwKeyedMsg| 'S2IL0013 (CONS |op| (CONS |d| NIL))))
+                ((SPADLET |r|
+                          (|unabbrevSpecialForms| |op| |arglist|
+                              |modeIfTrue|))
+                 |r|)
+                ((OR (SPADLET |cname| (|abbreviation?| |op|))
+                     (AND (|constructor?| |op|) (SPADLET |cname| |op|)))
+                 (COND
+                   ((SPADLET |r|
+                             (|unabbrevSpecialForms| |cname| |arglist|
+                                 |modeIfTrue|))
+                    |r|)
+                   ('T
+                    (CONS |cname|
+                          (|condUnabbrev| |op| |arglist|
+                              (|getPartialConstructorModemapSig|
+                                  |cname|)
+                              |modeIfTrue|)))))
+                ('T |u|))))))))
 
-;
 ;unabbrevSpecialForms(op,arglist,modeIfTrue) ==
 ;  op = 'Mapping => [op,:[unabbrev1(a,modeIfTrue) for a in arglist]]
 ;  op = 'Union   =>
@@ -468,119 +491,135 @@
 ;  nil
 
 (DEFUN |unabbrevSpecialForms| (|op| |arglist| |modeIfTrue|)
- (PROG () 
-  (RETURN 
-   (SEQ
-    (COND
-     ((BOOT-EQUAL |op| (QUOTE |Mapping|))
-      (CONS |op|
-       (PROG (#0=#:G166261)
-        (SPADLET #0# NIL)
-        (RETURN
-         (DO ((#1=#:G166266 |arglist| (CDR #1#)) (|a| NIL))
-             ((OR (ATOM #1#) (PROGN (SETQ |a| (CAR #1#)) NIL)) (NREVERSE0 #0#))
-          (SEQ
-           (EXIT (SETQ #0# (CONS (|unabbrev1| |a| |modeIfTrue|) #0#)))))))))
-     ((BOOT-EQUAL |op| (QUOTE |Union|))
-      (CONS
-       |op|
-       (PROG (#2=#:G166276)
-        (SPADLET #2# NIL)
-        (RETURN
-         (DO ((#3=#:G166281 |arglist| (CDR #3#)) (|a| NIL))
-             ((OR (ATOM #3#) (PROGN (SETQ |a| (CAR #3#)) NIL)) (NREVERSE0 #2#))
-          (SEQ
-           (EXIT 
-            (SETQ #2#
-             (CONS (|unabbrevUnionComponent| |a| |modeIfTrue|) #2#)))))))))
-     ((BOOT-EQUAL |op| (QUOTE |Record|))
-      (CONS 
-       |op|
-       (PROG (#4=#:G166291)
-        (SPADLET #4# NIL)
-        (RETURN 
-         (DO ((#5=#:G166296 |arglist| (CDR #5#)) (|a| NIL))
-             ((OR (ATOM #5#) (PROGN (SETQ |a| (CAR #5#)) NIL)) (NREVERSE0 #4#))
-          (SEQ
-           (EXIT
-            (SETQ #4#
-             (CONS (|unabbrevRecordComponent| |a| |modeIfTrue|) #4#)))))))))
-     ((QUOTE T) NIL)))))) 
+  (PROG ()
+    (RETURN
+      (SEQ (COND
+             ((BOOT-EQUAL |op| '|Mapping|)
+              (CONS |op|
+                    (PROG (G166261)
+                      (SPADLET G166261 NIL)
+                      (RETURN
+                        (DO ((G166266 |arglist| (CDR G166266))
+                             (|a| NIL))
+                            ((OR (ATOM G166266)
+                                 (PROGN
+                                   (SETQ |a| (CAR G166266))
+                                   NIL))
+                             (NREVERSE0 G166261))
+                          (SEQ (EXIT (SETQ G166261
+                                      (CONS
+                                       (|unabbrev1| |a| |modeIfTrue|)
+                                       G166261)))))))))
+             ((BOOT-EQUAL |op| '|Union|)
+              (CONS |op|
+                    (PROG (G166276)
+                      (SPADLET G166276 NIL)
+                      (RETURN
+                        (DO ((G166281 |arglist| (CDR G166281))
+                             (|a| NIL))
+                            ((OR (ATOM G166281)
+                                 (PROGN
+                                   (SETQ |a| (CAR G166281))
+                                   NIL))
+                             (NREVERSE0 G166276))
+                          (SEQ (EXIT (SETQ G166276
+                                      (CONS
+                                       (|unabbrevUnionComponent| |a|
+                                        |modeIfTrue|)
+                                       G166276)))))))))
+             ((BOOT-EQUAL |op| '|Record|)
+              (CONS |op|
+                    (PROG (G166291)
+                      (SPADLET G166291 NIL)
+                      (RETURN
+                        (DO ((G166296 |arglist| (CDR G166296))
+                             (|a| NIL))
+                            ((OR (ATOM G166296)
+                                 (PROGN
+                                   (SETQ |a| (CAR G166296))
+                                   NIL))
+                             (NREVERSE0 G166291))
+                          (SEQ (EXIT (SETQ G166291
+                                      (CONS
+                                       (|unabbrevRecordComponent| |a|
+                                        |modeIfTrue|)
+                                       G166291)))))))))
+             ('T NIL))))))
 
-;
 ;unabbrevRecordComponent(a,modeIfTrue) ==
 ;  a is ["Declare",b,T] or a is [":",b,T] =>
 ;    [":",b,unabbrev1(T,modeIfTrue)]
 ;  userError "wrong format for Record type"
 
 (DEFUN |unabbrevRecordComponent| (|a| |modeIfTrue|)
- (PROG (|ISTMP#1| |b| |ISTMP#2| T$)
-  (RETURN
-   (COND
-    ((OR 
-      (AND
-       (PAIRP |a|)
-       (EQ (QCAR |a|) (QUOTE |Declare|))
-       (PROGN
-        (SPADLET |ISTMP#1| (QCDR |a|))
-        (AND (PAIRP |ISTMP#1|)
-             (PROGN
-              (SPADLET |b| (QCAR |ISTMP#1|))
-              (SPADLET |ISTMP#2| (QCDR |ISTMP#1|))
-              (AND (PAIRP |ISTMP#2|)
-                   (EQ (QCDR |ISTMP#2|) NIL)
-                   (PROGN (SPADLET T$ (QCAR |ISTMP#2|)) (QUOTE T)))))))
-      (AND (PAIRP |a|)
-           (EQ (QCAR |a|) (QUOTE |:|))
-           (PROGN
-            (SPADLET |ISTMP#1| (QCDR |a|))
-            (AND (PAIRP |ISTMP#1|)
-                 (PROGN
-                  (SPADLET |b| (QCAR |ISTMP#1|))
-                  (SPADLET |ISTMP#2| (QCDR |ISTMP#1|))
-                  (AND (PAIRP |ISTMP#2|)
-                       (EQ (QCDR |ISTMP#2|) NIL)
-                       (PROGN (SPADLET T$ (QCAR |ISTMP#2|)) (QUOTE T))))))))
-      (CONS (QUOTE |:|) (CONS |b| (CONS (|unabbrev1| T$ |modeIfTrue|) NIL))))
-    ((QUOTE T) (|userError| (QUOTE |wrong format for Record type|))))))) 
+  (PROG (|ISTMP#1| |b| |ISTMP#2| T$)
+    (RETURN
+      (COND
+        ((OR (AND (PAIRP |a|) (EQ (QCAR |a|) '|Declare|)
+                  (PROGN
+                    (SPADLET |ISTMP#1| (QCDR |a|))
+                    (AND (PAIRP |ISTMP#1|)
+                         (PROGN
+                           (SPADLET |b| (QCAR |ISTMP#1|))
+                           (SPADLET |ISTMP#2| (QCDR |ISTMP#1|))
+                           (AND (PAIRP |ISTMP#2|)
+                                (EQ (QCDR |ISTMP#2|) NIL)
+                                (PROGN
+                                  (SPADLET T$ (QCAR |ISTMP#2|))
+                                  'T))))))
+             (AND (PAIRP |a|) (EQ (QCAR |a|) '|:|)
+                  (PROGN
+                    (SPADLET |ISTMP#1| (QCDR |a|))
+                    (AND (PAIRP |ISTMP#1|)
+                         (PROGN
+                           (SPADLET |b| (QCAR |ISTMP#1|))
+                           (SPADLET |ISTMP#2| (QCDR |ISTMP#1|))
+                           (AND (PAIRP |ISTMP#2|)
+                                (EQ (QCDR |ISTMP#2|) NIL)
+                                (PROGN
+                                  (SPADLET T$ (QCAR |ISTMP#2|))
+                                  'T)))))))
+         (CONS '|:|
+               (CONS |b| (CONS (|unabbrev1| T$ |modeIfTrue|) NIL))))
+        ('T (|userError| '|wrong format for Record type|))))))
 
-;
 ;unabbrevUnionComponent(a,modeIfTrue) ==
 ;  a is ["Declare",b,T] or a is [":",b,T] =>
 ;    [":",b,unabbrev1(T,modeIfTrue)]
 ;  unabbrev1(a, modeIfTrue)
 
 (DEFUN |unabbrevUnionComponent| (|a| |modeIfTrue|)
- (PROG (|ISTMP#1| |b| |ISTMP#2| T$)
-  (RETURN
-   (COND
-    ((OR
-      (AND (PAIRP |a|)
-           (EQ (QCAR |a|) (QUOTE |Declare|))
-           (PROGN
-            (SPADLET |ISTMP#1| (QCDR |a|))
-            (AND (PAIRP |ISTMP#1|)
-                 (PROGN
-                  (SPADLET |b| (QCAR |ISTMP#1|))
-                  (SPADLET |ISTMP#2| (QCDR |ISTMP#1|))
-                  (AND (PAIRP |ISTMP#2|)
-                       (EQ (QCDR |ISTMP#2|) NIL)
-                       (PROGN (SPADLET T$ (QCAR |ISTMP#2|)) (QUOTE T)))))))
-      (AND (PAIRP |a|)
-           (EQ (QCAR |a|) (QUOTE |:|))
-           (PROGN
-            (SPADLET |ISTMP#1| (QCDR |a|))
-            (AND (PAIRP |ISTMP#1|)
-                 (PROGN
-                  (SPADLET |b| (QCAR |ISTMP#1|))
-                  (SPADLET |ISTMP#2| (QCDR |ISTMP#1|))
-                  (AND (PAIRP |ISTMP#2|)
-                       (EQ (QCDR |ISTMP#2|) NIL)
-                       (PROGN (SPADLET T$ (QCAR |ISTMP#2|)) (QUOTE T))))))))
-      (CONS (QUOTE |:|) (CONS |b| (CONS (|unabbrev1| T$ |modeIfTrue|) NIL))))
-    ((QUOTE T) (|unabbrev1| |a| |modeIfTrue|)))))) 
+  (PROG (|ISTMP#1| |b| |ISTMP#2| T$)
+    (RETURN
+      (COND
+        ((OR (AND (PAIRP |a|) (EQ (QCAR |a|) '|Declare|)
+                  (PROGN
+                    (SPADLET |ISTMP#1| (QCDR |a|))
+                    (AND (PAIRP |ISTMP#1|)
+                         (PROGN
+                           (SPADLET |b| (QCAR |ISTMP#1|))
+                           (SPADLET |ISTMP#2| (QCDR |ISTMP#1|))
+                           (AND (PAIRP |ISTMP#2|)
+                                (EQ (QCDR |ISTMP#2|) NIL)
+                                (PROGN
+                                  (SPADLET T$ (QCAR |ISTMP#2|))
+                                  'T))))))
+             (AND (PAIRP |a|) (EQ (QCAR |a|) '|:|)
+                  (PROGN
+                    (SPADLET |ISTMP#1| (QCDR |a|))
+                    (AND (PAIRP |ISTMP#1|)
+                         (PROGN
+                           (SPADLET |b| (QCAR |ISTMP#1|))
+                           (SPADLET |ISTMP#2| (QCDR |ISTMP#1|))
+                           (AND (PAIRP |ISTMP#2|)
+                                (EQ (QCDR |ISTMP#2|) NIL)
+                                (PROGN
+                                  (SPADLET T$ (QCAR |ISTMP#2|))
+                                  'T)))))))
+         (CONS '|:|
+               (CONS |b| (CONS (|unabbrev1| T$ |modeIfTrue|) NIL))))
+        ('T (|unabbrev1| |a| |modeIfTrue|))))))
 
-;
 ;condAbbrev(arglist,argtypes) ==
 ;  res:= nil
 ;  for arg in arglist for type in argtypes repeat
@@ -589,28 +628,25 @@
 ;  res
 
 (DEFUN |condAbbrev| (|arglist| |argtypes|)
- (PROG (|arg| |res|)
-  (RETURN
-   (SEQ
-    (PROGN
-     (SPADLET |res| NIL)
-     (DO ((#0=#:G166404 |arglist| (CDR #0#))
-          (|arg| NIL)
-          (#1=#:G166405 |argtypes| (CDR #1#))
-          (|type| NIL))
-         ((OR (ATOM #0#)
-              (PROGN (SETQ |arg| (CAR #0#)) NIL)
-              (ATOM #1#)
-              (PROGN (SETQ |type| (CAR #1#)) NIL))
-           NIL)
-      (SEQ
-       (EXIT
-        (PROGN
-         (COND ((|categoryForm?| |type|) (SPADLET |arg| (|abbreviate| |arg|))))
-         (SPADLET |res| (APPEND |res| (CONS |arg| NIL)))))))
-     |res|))))) 
+  (PROG (|res|)
+    (RETURN
+      (SEQ (PROGN
+             (SPADLET |res| NIL)
+             (DO ((G166404 |arglist| (CDR G166404)) (|arg| NIL)
+                  (G166405 |argtypes| (CDR G166405)) (|type| NIL))
+                 ((OR (ATOM G166404)
+                      (PROGN (SETQ |arg| (CAR G166404)) NIL)
+                      (ATOM G166405)
+                      (PROGN (SETQ |type| (CAR G166405)) NIL))
+                  NIL)
+               (SEQ (EXIT (PROGN
+                            (COND
+                              ((|categoryForm?| |type|)
+                               (SPADLET |arg| (|abbreviate| |arg|))))
+                            (SPADLET |res|
+                                     (APPEND |res| (CONS |arg| NIL)))))))
+             |res|)))))
 
-;
 ;condUnabbrev(op,arglist,argtypes,modeIfTrue) ==
 ;  #arglist ^= #argtypes =>
 ;    throwKeyedMsg("S2IL0014",[op,plural(#argtypes,'"argument"),
@@ -620,40 +656,37 @@
 ;    arg
 
 (DEFUN |condUnabbrev| (|op| |arglist| |argtypes| |modeIfTrue|)
- (PROG () 
-  (RETURN
-   (SEQ
-    (COND
-     ((NEQUAL (|#| |arglist|) (|#| |argtypes|))
-      (|throwKeyedMsg| 
-       (QUOTE S2IL0014) 
-       (CONS
-        |op|
-        (CONS
-         (|plural| (|#| |argtypes|) (MAKESTRING "argument"))
-         (CONS (|bright| (|#| |arglist|)) NIL)))))
-     ((QUOTE T)
-      (PROG (#0=#:G166428) 
-       (SPADLET #0# NIL)
-       (RETURN
-        (DO ((#1=#:G166434 |arglist| (CDR #1#))
-             (|arg| NIL)
-             (#2=#:G166435 |argtypes| (CDR #2#))
-             (|type| NIL))
-            ((OR (ATOM #1#)
-                 (PROGN (SETQ |arg| (CAR #1#)) NIL)
-                 (ATOM #2#)
-                 (PROGN (SETQ |type| (CAR #2#)) NIL))
-              (NREVERSE0 #0#))
-         (SEQ
-          (EXIT
-           (SETQ #0#
-            (CONS
-             (COND
-              ((|categoryForm?| |type|) (|unabbrev1| |arg| |modeIfTrue|))
-              ((QUOTE T) |arg|)) #0#))))))))))))) 
+  (PROG ()
+    (RETURN
+      (SEQ (COND
+             ((NEQUAL (|#| |arglist|) (|#| |argtypes|))
+              (|throwKeyedMsg| 'S2IL0014
+                  (CONS |op|
+                        (CONS (|plural| (|#| |argtypes|)
+                                  (MAKESTRING "argument"))
+                              (CONS (|bright| (|#| |arglist|)) NIL)))))
+             ('T
+              (PROG (G166428)
+                (SPADLET G166428 NIL)
+                (RETURN
+                  (DO ((G166434 |arglist| (CDR G166434))
+                       (|arg| NIL)
+                       (G166435 |argtypes| (CDR G166435))
+                       (|type| NIL))
+                      ((OR (ATOM G166434)
+                           (PROGN (SETQ |arg| (CAR G166434)) NIL)
+                           (ATOM G166435)
+                           (PROGN (SETQ |type| (CAR G166435)) NIL))
+                       (NREVERSE0 G166428))
+                    (SEQ (EXIT (SETQ G166428
+                                     (CONS
+                                      (COND
+                                        ((|categoryForm?| |type|)
+                                         (|unabbrev1| |arg|
+                                          |modeIfTrue|))
+                                        ('T |arg|))
+                                      G166428)))))))))))))
 
-;
 ;--% Code Being Phased Out
 ;
 ;nAssocQ(x,l,n) ==
@@ -664,17 +697,15 @@
 ;
 
 (DEFUN |nAssocQ| (|x| |l| |n|)
- (PROG NIL
-  (RETURN
-   (SEQ
-    (DO NIL
-        (NIL NIL)
-     (SEQ
-      (EXIT
-       (PROGN
-        (COND ((ATOM |l|) (RETURN NIL)))
-        (COND ((EQ |x| (ELT (QCAR |l|) |n|)) (RETURN (QCAR |l|))))
-        (SPADLET |l| (QCDR |l|)))))))))) 
+  (PROG ()
+    (RETURN
+      (SEQ (DO () (NIL NIL)
+             (SEQ (EXIT (PROGN
+                          (COND ((ATOM |l|) (RETURN NIL)))
+                          (COND
+                            ((EQ |x| (ELT (QCAR |l|) |n|))
+                             (RETURN (QCAR |l|))))
+                          (SPADLET |l| (QCDR |l|))))))))))
 
 @
 \eject