diff --git a/library/UNICODE b/library/UNICODE
index d29c052e..3e9de649 100644
--- a/library/UNICODE
+++ b/library/UNICODE
@@ -1,11 +1,11 @@
 (DEFINE-FILE-INFO PACKAGE "INTERLISP" READTABLE "INTERLISP" BASE 10 FORMAT XCCS)
-(FILECREATED " 3-Jul-2021 13:37:33" 
-{DSK}<Users>kaplan>Local>medley3.5>git-medley>library>UNICODE.;175 66483  
+(FILECREATED " 6-Aug-2021 10:30:15" 
+{DSK}<Users>kaplan>Local>medley3.5>git-medley>library>UNICODE.;185 64537  
 
-      changes to%:  (FNS READ-UNICODE-MAPPING MAKE-UNICODE-FORMATS)
+      changes to%:  (FNS \UTF16.BACKCCODEFN)
 
-      previous date%: " 3-Jul-2021 11:41:05" 
-{DSK}<Users>kaplan>Local>medley3.5>git-medley>library>UNICODE.;173)
+      previous date%: " 5-Aug-2021 22:34:22" 
+{DSK}<Users>kaplan>Local>medley3.5>git-medley>library>UNICODE.;184)
 
 
 (PRETTYCOMPRINT UNICODECOMS)
@@ -14,8 +14,8 @@
        [(COMS 
               (* ;; "External formats")
 
-              (FNS UTF8.OUTCHARFN UTF8.INCCODEFN UTF8.PEEKCCODEFN \UTF8.BACKCHARFN)
-              (FNS UTF16BE.OUTCHARFN UTF16BE.INCCODEFN UTF16BE.PEEKCCODEFN \UTF16.BACKCHARFN)
+              (FNS UTF8.OUTCHARFN UTF8.INCCODEFN UTF8.PEEKCCODEFN \UTF8.BACKCCODEFN)
+              (FNS UTF16BE.OUTCHARFN UTF16BE.INCCODEFN UTF16BE.PEEKCCODEFN \UTF16.BACKCCODEFN)
               (INITVARS (EXTERNALEOL 'LF))
               (FNS MAKE-UNICODE-FORMATS)
               (P (MAKE-UNICODE-FORMATS EXTERNALEOL))
@@ -78,22 +78,16 @@
 (DEFINEQ
 
 (UTF8.OUTCHARFN
-  [LAMBDA (STREAM CHARCODE RAW)                         (* ; "Edited  1-Feb-2021 15:50 by rmk:")
+  [LAMBDA (STREAM CHARCODE RAW)                         (* ; "Edited  5-Aug-2021 22:34 by rmk:")
                                                             (* ; "Edited 17-Aug-2020 08:45 by rmk:")
                                                             (* ; "Edited 30-Jan-2020 23:08 by rmk:")
 
     (* ;; "Perhaps the translation table should already do the mapping for EOL to LF, but that seems to be a separate property of the stream")
 
-    (* ;; "PRINT UTF8 sequence for CHARCODE.  Do not do XCCS to Unicode translation if RAW.")
+    (* ;; "Print UTF8 sequence for CHARCODE.  Do not do XCCS to Unicode translation if RAW.")
 
     (IF (EQ CHARCODE (CHARCODE EOL))
-        THEN (REPLACE (STREAM CHARPOSITION) OF STREAM WITH 0)
-              (\BOUT STREAM (SELECTC (FETCH (STREAM EOLCONVENTION) OF STREAM)
-                                (LF.EOLC (CHARCODE LF))
-                                (CR.EOLC (CHARCODE CR))
-                                (CRLF.EOLC (\BOUT STREAM (CHARCODE CR))
-                                           (CHARCODE LF))
-                                (SHOULDNT)))
+        THEN (\BOUTEOL STREAM)
       ELSE (CHANGE (FETCH (STREAM CHARPOSITION) OF STREAM)
                       (IPLUS DATUM 1))                       (* ; "Avoid overflow")
             (FOR C INSIDE (CL:IF RAW
@@ -131,7 +125,17 @@
 
 (UTF8.PEEKCCODEFN
  [LAMBDA (STREAM NOERROR RAW)                          (* ; "Edited 14-Jun-2021 22:53 by rmk:")

    (* ;; "Modeled this after \EUCPEEK on LLREAD.  In the multi-byte (non-ASCII) case, backs the file pointer to the beginning by the proper number of \BACKFILEPTRs, and returns a count of 0.  Returns NIL if NOERROR and either invalid UTF8 or end of file.")

    (* ;; "Could be that the caller takes care of backing up the file position if the number of binned-bytes is returned.")

    (* ;; "Do not do UNICODE to XCCS translation if RAW")

    (PROG (BYTE1 BYTE2 BYTE3 BYTE4 CODE)
          (SETQ BYTE1 (\PEEKBIN STREAM NOERROR))

     (* ;; "Distinguish on header bytex")

          (CL:UNLESS BYTE1 (RETURN NIL))
          [IF (ILESSP BYTE1 128)
              THEN 

                    (* ;; 
                  "Test first:  Ascii is the common case.  No need to back up, since we peeked.")

                    (SETQ CODE BYTE1)
            ELSEIF (IGEQ BYTE1 (LLSH 15 4))
              THEN                                       (* ; "4 bytes")
                    (\BIN STREAM)
                    (CL:UNLESS (AND (SETQ BYTE2 (\PEEKBIN STREAM NOERROR))
                                    (IGEQ BYTE2 128))
                        (\BACKFILEPTR STREAM)
                        (OR NOERROR (ERROR "INVALID UTF8 SEQUENCE" (LIST BYTE1 BYTE2)))
                        (RETURN CODE))
                    (\BIN STREAM)
                    (CL:UNLESS (AND (SETQ BYTE3 (\PEEKBIN STREAM NOERROR))
                                    (IGEQ BYTE3 128))
                        (\BACKFILEPTR STREAM)
                        (\BACKFILEPTR STREAM)
                        (OR NOERROR (ERROR "INVALID UTF8 SEQUENCE" (LIST BYTE1 BYTE2 BYTE3)))
                        (RETURN CODE))
                    (\BIN STREAM)
                    (SETQ BYTE4 (\PEEKBIN STREAM NOERROR))   (* ; 
                                                           "PEEK the last, no need to back it up")
                    (\BACKFILEPTR STREAM)
                    (\BACKFILEPTR STREAM)
                    (\BACKFILEPTR STREAM)
                    (IF (AND BYTE4 (IGEQ BYTE4 128))
                        THEN (SETQ CODE (LOGOR (LLSH (LOADBYTE BYTE1 0 3)
                                                         18)
                                                   (LLSH (LOADBYTE BYTE2 0 6)
                                                         12)
                                                   (LLSH (LOADBYTE BYTE3 0 6)
                                                         6)
                                                   (LOADBYTE BYTE4 0 6)))
                      ELSEIF NOERROR
                      ELSE (ERROR "INVALID UTF8 SEQUENCE" (LIST BYTE1 BYTE2 BYTE3 BYTE4)))
            ELSEIF (IGEQ BYTE1 (LLSH 7 5))
              THEN                                       (* ; "3 bytes")
                    (\BIN STREAM)
                    (CL:UNLESS (AND (SETQ BYTE2 (\PEEKBIN STREAM NOERROR))
                                    (IGEQ BYTE2 128))
                        (\BACKFILEPTR STREAM)
                        (OR NOERROR (ERROR "INVALID UTF8 SEQUENCE" (LIST BYTE1 BYTE2)))
                        (RETURN CODE))
                    (\BIN STREAM)
                    (SETQ BYTE3 (\PEEKBIN STREAM NOERROR))
                    (\BACKFILEPTR STREAM)
                    (\BACKFILEPTR STREAM)
                    (IF (AND BYTE3 (IGEQ BYTE3 128))
                        THEN (SETQ CODE (LOGOR (LLSH (LOADBYTE BYTE1 0 4)
                                                         12)
                                                   (LLSH (LOADBYTE BYTE2 0 6)
                                                         6)
                                                   (LOADBYTE BYTE3 0 6)))
                      ELSEIF NOERROR
                      ELSE (ERROR "INVALID UTF8 SEQUENCE" (LIST BYTE1 BYTE2 BYTE3)))
            ELSE                                         (* ; "Must be 2 bytes")
                  (\BIN STREAM)
                  (SETQ BYTE2 (\PEEKBIN STREAM NOERROR))
                  (\BACKFILEPTR STREAM)
                  (IF (AND BYTE2 (IGEQ BYTE2 128))
                      THEN (SETQ CODE (LOGOR (LLSH (LOADBYTE BYTE1 0 5)
                                                       6)
                                                 (LOADBYTE BYTE2 0 6)))
                    ELSEIF NOERROR
                    ELSE (ERROR "INVALID UTF8 SEQUENCE" (LIST BYTE1 BYTE2]
          (CL:WHEN (AND CODE (NOT RAW))
              (SETQ CODE (UNICODE.TRANSLATE CODE *UNICODETOXCCS*)))
          (RETURN CODE])
 
-(\UTF8.BACKCHARFN
  [LAMBDA (STREAM BYTECOUNTVAR BYTECOUNTVAL)            (* ; "Edited 15-Jun-2021 13:38 by rmk:")

    (* ;; "\BACKFILEPTR is NIL at beginning of FILE, just return COUNT")

    (BIND (C _ 0) WHILE (CL:WHEN (\BACKFILEPTR STREAM)
                                    (ADD C 1)
                                    (EQ 2 (LRSH (\PEEKBIN STREAM)
                                                6))) REPEATUNTIL (EQ C 4)
       FINALLY (CL:WHEN BYTECOUNTVAR
                       (SET BYTECOUNTVAR (IPLUS BYTECOUNTVAL C)))])
+(\UTF8.BACKCCODEFN
+  [LAMBDA (STREAM BYTECOUNTVAR BYTECOUNTVAL)            (* ; "Edited 15-Jun-2021 13:38 by rmk:")
+
+    (* ;; "\BACKFILEPTR is NIL at beginning of FILE, just return COUNT")
+
+    (BIND (C _ 0) WHILE (CL:WHEN (\BACKFILEPTR STREAM)
+                                    (ADD C 1)
+                                    (EQ 2 (LRSH (\PEEKBIN STREAM)
+                                                6))) REPEATUNTIL (EQ C 4)
+       FINALLY (CL:WHEN BYTECOUNTVAR
+                       (SET BYTECOUNTVAR (IPLUS BYTECOUNTVAL C)))])
 )
 (DEFINEQ
 
@@ -155,61 +159,57 @@
 
 (UTF16BE.PEEKCCODEFN
  [LAMBDA (STREAM NOERROR RAW)                          (* ; "Edited 14-Jun-2021 22:58 by rmk:")

    (* ;; "Could be that the caller takes care of backing up the file position if the number of binned-bytes is returned.")

    (* ;; "Do not do UNICODE to XCCS translation if RAW")

    (LET (BYTE1 BYTE2 CODE)
         (SETQ BYTE1 (\PEEKBIN STREAM NOERROR))
         (IF BYTE1
             THEN (\BIN STREAM)
                   (SETQ BYTE2 (\PEEKBIN STREAM NOERROR))
                   (\BACKFILEPTR STREAM)
                   (IF BYTE2
                       THEN (SETQ CODE (LOGOR (LLSH BYTE1 8)
                                                  BYTE2))
                             (CL:IF RAW
                                 CODE
                                 (UNICODE.TRANSLATE CODE *UNICODETOXCCS*))
                     ELSEIF NOERROR
                       THEN NIL)
           ELSEIF NOERROR
             THEN NIL
           ELSE (ERROR "INVALID UTF16 CHARACTER" (LIST BYTE1 BYTE2])
 
-(\UTF16.BACKCHARFN
  [LAMBDA (STREAM BYTECOUNTVAR BYTECOUNTVAL)            (* ; "Edited 15-Jun-2021 13:35 by rmk:")

    (* ;; "\BACKFILEPTR is NIL at beginning of FILE, do nothing.")

    (* ;; "Common for big-ending and little-ending")

    (IF (NOT (\BACKFILEPTR STREAM))
      ELSEIF (\BACKFILEPTR STREAM)
        THEN (AND BYTECOUNTVAR (SET BYTECOUNTVAR (IPLUS BYTECOUNTVAL 2)))
      ELSE (AND BYTECOUNTVAR (SET BYTECOUNTVAR (ADD1 BYTECOUNTVAL])
+(\UTF16.BACKCCODEFN
+  [LAMBDA (STREAM BYTECOUNTVAR BYTECOUNTVAL)            (* ; "Edited  6-Aug-2021 10:15 by rmk:")
+
+    (* ;; "\BACKFILEPTR is NIL at beginning of FILE, do nothing.")
+
+    (* ;; "Common for big-ending and little-ending")
+
+    (CL:WHEN (\BACKFILEPTR STREAM)
+        [IF (\BACKFILEPTR STREAM)
+            THEN (AND BYTECOUNTVAR (SET BYTECOUNTVAR (IPLUS BYTECOUNTVAL 2)))
+          ELSE (AND BYTECOUNTVAR (SET BYTECOUNTVAR (ADD1 BYTECOUNTVAL])])
 )
 
 (RPAQ? EXTERNALEOL 'LF)
 (DEFINEQ
 
 (MAKE-UNICODE-FORMATS
-  [LAMBDA (EXTERNALEOL)                                 (* ; "Edited  3-Jul-2021 13:17 by rmk:")
+  [LAMBDA (EXTERNALEOL)                                 (* ; "Edited  1-Aug-2021 23:18 by rmk:")
 
     (* ;; "RAW formats do not do XCCS/Unicode translation, just deal with the byte encoding.")
 
     (* ;; "The EXTERNALEOL specifies the EOLCONVENTION of the stream, particularly to produce output files with the desired convention.  On input the macro \CHECKEOLC (LLREAD) coerces only that coding to the internal EOL, which is a mistake.")
 
-    (SETQ EXTERNALEOL (SELECTQ EXTERNALEOL
-                          (LF LF.EOLC)
-                          (CR CR.EOLC)
-                          (CRLF CRLF.EOLC)
-                          (SHOULDNT)))
-    (\INSTALL.EXTERNALFORMAT (CREATE EXTERNALFORMAT
-                                    NAME _ :UTF16BE
-                                    EOL _ EXTERNALEOL
-                                    INCCODEFN _ (FUNCTION UTF16BE.INCCODEFN)
-                                    PEEKCCODEFN _ (FUNCTION UTF16BE.PEEKCCODEFN)
-                                    BACKCCODEFN _ (FUNCTION \UTF16.BACKCHARFN)
-                                    OUTCHARFN _ (FUNCTION UTF16BE.OUTCHARFN)))
-    [\INSTALL.EXTERNALFORMAT (CREATE EXTERNALFORMAT
-                                    NAME _ :UTF16BE-RAW
-                                    EOL _ EXTERNALEOL
-                                    INCCODEFN _ [FUNCTION (LAMBDA (STREAM BYTECOUNTVAR BYTECOUNTVAL)
-                                                            (UTF16BE.INCCODEFN STREAM 
-                                                                   BYTECOUNTVAR BYTECOUNTVAL T]
-                                    PEEKCCODEFN _ [FUNCTION (LAMBDA (STREAM NOERROR)
-                                                              (UTF16BE.PEEKCCODEFN STREAM NOERROR
-                                                                     T]
-                                    BACKCCODEFN _ (FUNCTION \UTF16.BACKCHARFN)
-                                    OUTCHARFN _ (FUNCTION (LAMBDA (STREAM CHARCODE)
-                                                            (UTF16BE.OUTCHARFN STREAM CHARCODE T]
-    [\INSTALL.EXTERNALFORMAT (CREATE EXTERNALFORMAT
-                                    NAME _ :UTF-8-RAW
-                                    EOL _ EXTERNALEOL
-                                    INCCODEFN _ [FUNCTION (LAMBDA (STREAM BYTECOUNTVAR BYTECOUNTVAL)
-                                                            (UTF8.INCCODEFN STREAM BYTECOUNTVAR 
-                                                                   BYTECOUNTVAL T]
-                                    PEEKCCODEFN _ [FUNCTION (LAMBDA (STREAM NOERROR)
-                                                              (UTF8.PEEKCCODEFN STREAM NOERROR T]
-                                    BACKCCODEFN _ (FUNCTION \UTF8.BACKCHARFN)
-                                    OUTCHARFN _ (FUNCTION (LAMBDA (STREAM CHARCODE)
-                                                            (UTF8.OUTCHARFN STREAM CHARCODE T]
-    (\INSTALL.EXTERNALFORMAT (CREATE EXTERNALFORMAT
-                                    NAME _ :UTF-8
-                                    EOL _ EXTERNALEOL
-                                    INCCODEFN _ (FUNCTION UTF8.INCCODEFN)
-                                    PEEKCCODEFN _ (FUNCTION UTF8.PEEKCCODEFN)
-                                    BACKCCODEFN _ (FUNCTION \UTF8.BACKCHARFN)
-                                    OUTCHARFN _ (FUNCTION UTF8.OUTCHARFN])
+    (MAKE-EXTERNALFORMAT :UTF-8 (FUNCTION UTF8.INCCODEFN)
+           (FUNCTION UTF8.PEEKCCODEFN)
+           (FUNCTION \UTF8.BACKCCODEFN)
+           (FUNCTION UTF8.OUTCHARFN)
+           NIL EXTERNALEOL)
+    (MAKE-EXTERNALFORMAT :UTF-8-RAW [FUNCTION (LAMBDA (STREAM BYTECOUNTVAR BYTECOUNTVAL)
+                                                (UTF8.INCCODEFN STREAM BYTECOUNTVAR BYTECOUNTVAL
+                                                       T]
+           [FUNCTION (LAMBDA (STREAM NOERROR)
+                       (UTF8.PEEKCCODEFN STREAM NOERROR T]
+           (FUNCTION \UTF8.BACKCCODEFN)
+           [FUNCTION (LAMBDA (STREAM CHARCODE)
+                       (UTF8.OUTCHARFN STREAM CHARCODE T]
+           NIL EXTERNALEOL)
+    (MAKE-EXTERNALFORMAT :UTF-16BE (FUNCTION UTF16BE.INCCODEFN)
+           (FUNCTION UTF16BE.PEEKCCODEFN)
+           (FUNCTION \UTF16.BACKCCODEFN)
+           (FUNCTION UTF16BE.OUTCHARFN)
+           NIL EXTERNALEOL)
+    (MAKE-EXTERNALFORMAT :UTF-16BE-RAW [FUNCTION (LAMBDA (STREAM BYTECOUNTVAR BYTECOUNTVAL)
+                                                   (UTF16BE.INCCODEFN STREAM BYTECOUNTVAR 
+                                                          BYTECOUNTVAL T]
+           [FUNCTION (LAMBDA (STREAM NOERROR)
+                       (UTF16BE.PEEKCCODEFN STREAM NOERROR T]
+           (FUNCTION \UTF16.BACKCCODEFN)
+           [FUNCTION (LAMBDA (STREAM CHARCODE)
+                       (UTF16BE.OUTCHARFN STREAM CHARCODE T]
+           NIL EXTERNALEOL])
 )
 
 (MAKE-UNICODE-FORMATS EXTERNALEOL)
@@ -993,15 +993,15 @@
 )
 )
 (DECLARE%: DONTCOPY
-  (FILEMAP (NIL (4126 17801 (UTF8.OUTCHARFN 4136 . 7332) (UTF8.INCCODEFN 7334 . 12450) (UTF8.PEEKCCODEFN
- 12452 . 17226) (\UTF8.BACKCHARFN 17228 . 17799)) (17802 20994 (UTF16BE.OUTCHARFN 17812 . 18545) (
-UTF16BE.INCCODEFN 18547 . 19430) (UTF16BE.PEEKCCODEFN 19432 . 20503) (\UTF16.BACKCHARFN 20505 . 20992)
-) (21024 24537 (MAKE-UNICODE-FORMATS 21034 . 24535)) (24633 25939 (UNICODE.UNMAPPED 24643 . 25937)) (
-25940 26476 (XCCS-UTF8-AFTER-OPEN 25950 . 26474)) (27546 27895 (XTOUCODE 27556 . 27724) (UTOXCODE 
-27726 . 27893)) (27935 44118 (READ-UNICODE-MAPPING-FILENAMES 27945 . 29107) (READ-UNICODE-MAPPING 
-29109 . 32407) (WRITE-UNICODE-MAPPING 32409 . 36626) (WRITE-UNICODE-INCLUDED 36628 . 41350) (
-WRITE-UNICODE-MAPPING-HEADER 41352 . 42584) (WRITE-UNICODE-MAPPING-FILENAME 42586 . 44116)) (47455 
-55928 (MAKE-UNICODE-TRANSLATION-TABLES 47465 . 55926)) (56349 64253 (HEXSTRING 56359 . 57520) (
-UTF8HEXSTRING 57522 . 59727) (NUTF8CODEBYTES 59729 . 60392) (NUTF8STRINGBYTES 60394 . 60875) (
-XTOUSTRING 60877 . 63888) (XCCSSTRING 63890 . 64251)) (64254 65723 (SHOWCHARS 64264 . 65721)))))
+  (FILEMAP (NIL (4105 17365 (UTF8.OUTCHARFN 4115 . 6895) (UTF8.INCCODEFN 6897 . 12013) (UTF8.PEEKCCODEFN
+ 12015 . 16789) (\UTF8.BACKCCODEFN 16791 . 17363)) (17366 20563 (UTF16BE.OUTCHARFN 17376 . 18109) (
+UTF16BE.INCCODEFN 18111 . 18994) (UTF16BE.PEEKCCODEFN 18996 . 20067) (\UTF16.BACKCCODEFN 20069 . 20561
+)) (20593 22591 (MAKE-UNICODE-FORMATS 20603 . 22589)) (22687 23993 (UNICODE.UNMAPPED 22697 . 23991)) (
+23994 24530 (XCCS-UTF8-AFTER-OPEN 24004 . 24528)) (25600 25949 (XTOUCODE 25610 . 25778) (UTOXCODE 
+25780 . 25947)) (25989 42172 (READ-UNICODE-MAPPING-FILENAMES 25999 . 27161) (READ-UNICODE-MAPPING 
+27163 . 30461) (WRITE-UNICODE-MAPPING 30463 . 34680) (WRITE-UNICODE-INCLUDED 34682 . 39404) (
+WRITE-UNICODE-MAPPING-HEADER 39406 . 40638) (WRITE-UNICODE-MAPPING-FILENAME 40640 . 42170)) (45509 
+53982 (MAKE-UNICODE-TRANSLATION-TABLES 45519 . 53980)) (54403 62307 (HEXSTRING 54413 . 55574) (
+UTF8HEXSTRING 55576 . 57781) (NUTF8CODEBYTES 57783 . 58446) (NUTF8STRINGBYTES 58448 . 58929) (
+XTOUSTRING 58931 . 61942) (XCCSSTRING 61944 . 62305)) (62308 63777 (SHOWCHARS 62318 . 63775)))))
 STOP
diff --git a/library/UNICODE.LCOM b/library/UNICODE.LCOM
index 8ea52dc9..bf542ebd 100644
Binary files a/library/UNICODE.LCOM and b/library/UNICODE.LCOM differ
diff --git a/sources/FILEIO b/sources/FILEIO
index 5d6a5624..ab1212d4 100644
--- a/sources/FILEIO
+++ b/sources/FILEIO
@@ -1,12 +1,11 @@
 (DEFINE-FILE-INFO PACKAGE "INTERLISP" READTABLE "INTERLISP" BASE 10 FORMAT XCCS)
-(FILECREATED " 2-Aug-2021 10:13:47" 
-{DSK}<Users>kaplan>Local>medley3.5>git-medley>sources>FILEIO.;68 180948 
+(FILECREATED " 6-Aug-2021 10:31:59" 
+{DSK}<Users>kaplan>Local>medley3.5>git-medley>sources>FILEIO.;75 181074 
 
-      changes to%:  (FNS \INSTALL.EXTERNALFORMAT \EXTERNALFORMAT)
-                    (RECORDS FDEV STREAM)
+      changes to%:  (FNS \THROUGHIN)
 
-      previous date%: " 1-Aug-2021 23:16:14" 
-{DSK}<Users>kaplan>Local>medley3.5>git-medley>sources>FILEIO.;64)
+      previous date%: " 5-Aug-2021 22:31:41" 
+{DSK}<Users>kaplan>Local>medley3.5>git-medley>sources>FILEIO.;74)
 
 
 (* ; "
@@ -1278,7 +1277,7 @@ Copyright (c) 1981-1993, 1999, 2020-2021 by Venue & Xerox Corporation.
 (DEFINEQ
 
 (\INSTALL.EXTERNALFORMAT
-  [LAMBDA (EXTFORMAT/NAME EXTERNALFORMAT)               (* ; "Edited  2-Aug-2021 10:13 by rmk:")
+  [LAMBDA (EXTFORMAT/NAME EXTERNALFORMAT)               (* ; "Edited  5-Aug-2021 14:22 by rmk:")
 
 (* ;;; "Register an instance of the datatype EXTERNALFORMAT.")
 
@@ -1299,9 +1298,8 @@ Copyright (c) 1981-1993, 1999, 2020-2021 by Venue & Xerox Corporation.
            ELSE (SETQ EXTERNALFORMAT EXTFORMAT/NAME)
                  (SETQ NAME (FETCH (EXTERNALFORMAT NAME) OF EXTERNALFORMAT)))
          (IF (type? EXTERNALFORMAT EXTERNALFORMAT)
-                (\REMOVE.EXTERNALFORMAT NAME)
-                (push *EXTERNALFORMATS* EXTERNALFORMAT)
-                NAME
+             THEN (\REMOVE.EXTERNALFORMAT NAME)
+                   (push *EXTERNALFORMATS* EXTERNALFORMAT)
            ELSE (ERROR "INVALID EXTERNALFORMAT " EXTERNALFORMAT))
          EXTERNALFORMAT])
 
@@ -1328,7 +1326,7 @@ Copyright (c) 1981-1993, 1999, 2020-2021 by Venue & Xerox Corporation.
         (CL:UNLESS NOERROR (ERROR NAME "is not an external format"])
 
 (\EXTERNALFORMAT
-  [LAMBDA (STREAM NEWFORMAT/NAME)                       (* ; "Edited  2-Aug-2021 10:11 by rmk:")
+  [LAMBDA (STREAM NEWFORMAT/NAME)                       (* ; "Edited  5-Aug-2021 20:39 by rmk:")
                                                              (* ; "Edited 26-Feb-91 13:20 by nm")
 
 (* ;;; ";;; RMK July 2020:  Added interface for per-device default external format.  \DO.PARAMS.AT.OPEN will make that call even if it is not specified from the open. STREAMPROP is fixed to call \EXTERNALFORMAT to set the property EXTERNALFORMAT, to export a user-level way of manipulating this.")
@@ -1346,21 +1344,24 @@ Copyright (c) 1981-1993, 1999, 2020-2021 by Venue & Xerox Corporation.
     (\DTEST STREAM 'STREAM)
     (CL:WHEN NEWFORMAT/NAME
         [LET (EXTFORMAT)
-             (if (type? EXTERNALFORMAT NEWFORMAT/NAME)
-                 then (SETQ EXTFORMAT NEWFORMAT/NAME)
-               else (CL:WHEN (EQ NEWFORMAT/NAME :DEFAULT)
-                            (SETQ NEWFORMAT/NAME (OR (CADR (ASSOC (fetch DEVICENAME
-                                                                     of (fetch DEVICE
-                                                                               of STREAM))
-                                                                  *DEFAULT-EXTERNALFORMATS*))
-                                                     (FETCH (FDEV DEFAULTEXTERNALFORMAT)
-                                                        OF (fetch DEVICE of STREAM))
-                                                     *DEFAULT-EXTERNALFORMAT*)))
-                     (SETQ EXTFORMAT (FIND-FORMAT NEWFORMAT/NAME))
-                     (CL:UNLESS EXTFORMAT (ERROR NEWFORMAT/NAME 
-                                                 "is not a registered external format name"))
-                     (CL:UNLESS (type? EXTERNALFORMAT EXTFORMAT)
-                            (ERROR "INVALID EXTERNALFORMAT " EXTFORMAT)))
+             [COND
+                ((type? EXTERNALFORMAT NEWFORMAT/NAME)
+                 (SETQ EXTFORMAT NEWFORMAT/NAME))
+                [(AND (TYPE? READER-ENVIRONMENT NEWFORMAT/NAME)
+                      (SETQ EXTFORMAT (FETCH (READER-ENVIRONMENT REFORMAT) OF NEWFORMAT/NAME]
+                (T (CL:WHEN (EQ NEWFORMAT/NAME :DEFAULT)
+                       (SETQ NEWFORMAT/NAME (OR (CADR (ASSOC (fetch DEVICENAME
+                                                                of (fetch DEVICE of
+                                                                                         STREAM))
+                                                             *DEFAULT-EXTERNALFORMATS*))
+                                                (FETCH (FDEV DEFAULTEXTERNALFORMAT)
+                                                   OF (fetch DEVICE of STREAM))
+                                                *DEFAULT-EXTERNALFORMAT*)))
+                   (SETQ EXTFORMAT (FIND-FORMAT NEWFORMAT/NAME))
+                   (CL:UNLESS EXTFORMAT (ERROR NEWFORMAT/NAME 
+                                               "is not a registered external format name"))
+                   (CL:UNLESS (type? EXTERNALFORMAT EXTFORMAT)
+                          (ERROR "INVALID EXTERNALFORMAT " EXTFORMAT]
              (UNINTERRUPTABLY
                  (freplace (STREAM EXTERNALFORMAT) of STREAM with EXTFORMAT)
                  (CL:WHEN (ffetch (EXTERNALFORMAT EOLVALID) of EXTFORMAT)
@@ -1414,13 +1415,14 @@ Copyright (c) 1981-1993, 1999, 2020-2021 by Venue & Xerox Corporation.
                                         EOL _ CR.EOLC])
 
 (\THROUGHIN
-  [LAMBDA (STREAM BYTECOUNTVAR BYTECOUNTVAL)            (* ; "Edited 15-Jun-2021 13:49 by rmk:")
+  [LAMBDA (STREAM BYTECOUNTVAR BYTECOUNTVAL)            (* ; "Edited  6-Aug-2021 10:31 by rmk:")
 
 (* ;;; "Read in a single byte from STREAM and returns it without any character conversion, just through as if.")
 
 (* ;;; "If COUNP is non-NIL, always -1 is returned as the second value.")
 
-    [CL:WHEN (BYTECOUNTVAR (SET BYTECOUNTVAR (SUB1 BYTECOUNTVAL]
+    (CL:WHEN BYTECOUNTVAR
+        (SET BYTECOUNTVAR (SUB1 BYTECOUNTVAL)))
     (\BIN STREAM])
 
 (\THROUGHBACKCCODE
@@ -3080,10 +3082,11 @@ update the map")
 (DEFINEQ
 
 (\BOUTEOL
-  [LAMBDA (STREAM)                                      (* ; "Edited  1-Aug-2021 10:08 by rmk:")
+  [LAMBDA (STREAM)                                      (* ; "Edited  5-Aug-2021 22:31 by rmk:")
 
-    (* ;; "Convenient closed function to put out EOL characters without depending on EXPORTS.ALL for constants.  This could also set the position back to 0.")
+    (* ;; "Convenient closed function to put out EOL characters without depending on EXPORTS.ALL for constants.  This also sets the position back to 0.")
 
+    (REPLACE (STREAM CHARPOSITION) OF STREAM WITH 0)
     (SELECTC (FETCH (STREAM EOLCONVENTION) OF STREAM)
         (LF.EOLC (\BOUT STREAM (CHARCODE LF)))
         (CR.EOLC (\BOUT STREAM (CHARCODE CR)))
@@ -3417,44 +3420,44 @@ update the map")
 (PUTPROPS FILEIO COPYRIGHT ("Venue & Xerox Corporation" 1981 1982 1983 1984 1985 1986 1987 1988 1989 
 1990 1991 1992 1993 1999 2020 2021))
 (DECLARE%: DONTCOPY
-  (FILEMAP (NIL (28483 31973 (STREAMPROP 28493 . 28927) (GETSTREAMPROP 28929 . 29402) (PUTSTREAMPROP 
-29404 . 31821) (STREAMP 31823 . 31971)) (32016 34535 (\DEFPRINT.BY.NAME 32026 . 33178) (
-\STREAM.DEFPRINT 33180 . 34228) (\FDEV.DEFPRINT 34230 . 34533)) (34793 39834 (\GETACCESS 34803 . 35257
-) (\SETACCESS 35259 . 39832)) (62838 64091 (MAKE-EXTERNALFORMAT 62848 . 64089)) (65277 72720 (
-\INSTALL.EXTERNALFORMAT 65287 . 66748) (\REMOVE.EXTERNALFORMAT 66750 . 67581) (FIND-FORMAT 67583 . 
-68134) (\EXTERNALFORMAT 68136 . 72718)) (73043 74862 (\CREATE.THROUGH.EXTERNALFORMAT 73053 . 73855) (
-\THROUGHIN 73857 . 74263) (\THROUGHBACKCCODE 74265 . 74510) (\THROUGHOUTCHARFN 74512 . 74860)) (74970 
-80939 (\DEFINEDEVICE 74980 . 77296) (\GETDEVICEFROMNAME 77298 . 77771) (\GETDEVICEFROMHOSTNAME 77773
- . 78817) (\REMOVEDEVICE 78819 . 79942) (\REMOVEDEVICE.NAMES 79944 . 80937)) (80979 105639 (\CLOSEFILE
- 80989 . 81814) (\DELETEFILE 81816 . 82110) (\DEVICEEVENT 82112 . 83882) (\GENERATEFILES 83884 . 84362
-) (\GENERATENEXTFILE 84364 . 85015) (\GENERATEFILEINFO 85017 . 85478) (\GETFILENAME 85480 . 85869) (
-\GENERIC.OUTFILEP 85871 . 86341) (\OPENFILE 86343 . 88921) (\DO.PARAMS.AT.OPEN 88923 . 91476) (
-\RENAMEFILE 91478 . 91902) (\REVALIDATEFILE 91904 . 94506) (\PAGED.REVALIDATEFILELST 94508 . 96066) (
-\PAGED.REVALIDATEFILES 96068 . 97787) (\PAGED.REVALIDATEFILE 97789 . 100072) (\BUFFERED.REVALIDATEFILE
- 100074 . 102360) (\BUFFERED.REVALIDATEFILELST 102362 . 103546) (\PRINT-REVALIDATION-RESULT 103548 . 
-103963) (\TRUNCATEFILE 103965 . 104356) (\FILE-CONFLICT 104358 . 105637)) (105675 110338 (
-\GENERATENOFILES 105685 . 107781) (\NULLFILEGENERATOR 107783 . 108027) (\NOFILESNEXTFILEFN 108029 . 
-110020) (\NOFILESINFOFN 110022 . 110336)) (110457 112365 (\FILE.NOT.OPEN 110467 . 110980) (
-\FILE.WONT.OPEN 110982 . 111310) (\ILLEGAL.DEVICEOP 111312 . 111594) (\IS.NOT.RANDACCESSP 111596 . 
-112042) (\STREAM.NOT.OPEN 112044 . 112363)) (112500 114798 (\FDEVINSTANCE 112510 . 114796)) (116348 
-123722 (CNDIR 116358 . 117663) (DIRECTORYNAME 117665 . 121848) (DIRECTORYNAMEP 121850 . 122466) (
-HOSTNAMEP 122468 . 123275) (\ADD.CONNECTED.DIR 123277 . 123720)) (123767 154410 (\BACKFILEPTR 123777
- . 123965) (\BACKPEEKBIN 123967 . 124328) (\BACKBIN 124330 . 124681) (BIN 124683 . 124900) (\BIN 
-124902 . 125179) (\BINS 125181 . 125467) (BOUT 125469 . 125831) (\BOUT 125833 . 126148) (\BOUTS 126150
- . 126461) (COPYBYTES 126463 . 129795) (COPYCHARS 129797 . 136719) (COPYFILE 136721 . 137518) (
-\COPYOPENFILE 137520 . 140593) (\INFER.FILE.TYPE 140595 . 141549) (EOFP 141551 . 141848) (FORCEOUTPUT 
-141850 . 142097) (\FLUSH.OPEN.STREAMS 142099 . 142455) (CHARSET 142457 . 144121) (ACCESS-CHARSET 
-144123 . 144340) (GETEOFPTR 144342 . 144592) (GETFILEINFO 144594 . 147787) (\TYPE.FROM.FILETYPE 147789
- . 148259) (\FILETYPE.FROM.TYPE 148261 . 148440) (GETFILEPTR 148442 . 148694) (SETFILEINFO 148696 . 
-152309) (SETFILEPTR 152311 . 154030) (BOUT16 154032 . 154217) (BIN16 154219 . 154408)) (154513 159718 
-(\GENERIC.BINS 154523 . 154803) (\GENERIC.BOUTS 154805 . 155070) (\GENERIC.RENAMEFILE 155072 . 156903)
- (\GENERIC.OPENP 156905 . 158220) (\GENERIC.READP 158222 . 159263) (\GENERIC.CHARSET 159265 . 159716))
- (159719 160058 (\MAP-OPEN-STREAMS 159729 . 160056)) (161928 164008 (\EOF.ACTION 161938 . 162189) (
-\EOSERROR 162191 . 162384) (\GETEOFPTR 162386 . 162568) (\INCFILEPTR 162570 . 162920) (\PEEKBIN 162922
- . 163113) (\SETCLOSEDFILELENGTH 163115 . 163449) (\SETEOFPTR 163451 . 163639) (\SETFILEPTR 163641 . 
-164006)) (164009 164551 (\FIXPOUT 164019 . 164319) (\FIXPIN 164321 . 164549)) (164552 165160 (\BOUTEOL
- 164562 . 165158)) (168252 178116 (\BUFFERED.BIN 168262 . 169114) (\BUFFERED.PEEKBIN 169116 . 169898) 
-(\BUFFERED.BOUT 169900 . 170760) (\BUFFERED.BINS 170762 . 174447) (\BUFFERED.BOUTS 174449 . 176250) (
-\BUFFERED.COPYBYTES 176252 . 178114)) (178145 180497 (\NULLDEVICE 178155 . 180173) (\NULL.OPENFILE 
-180175 . 180495)))))
+  (FILEMAP (NIL (28412 31902 (STREAMPROP 28422 . 28856) (GETSTREAMPROP 28858 . 29331) (PUTSTREAMPROP 
+29333 . 31750) (STREAMP 31752 . 31900)) (31945 34464 (\DEFPRINT.BY.NAME 31955 . 33107) (
+\STREAM.DEFPRINT 33109 . 34157) (\FDEV.DEFPRINT 34159 . 34462)) (34722 39763 (\GETACCESS 34732 . 35186
+) (\SETACCESS 35188 . 39761)) (62767 64020 (MAKE-EXTERNALFORMAT 62777 . 64018)) (65206 72777 (
+\INSTALL.EXTERNALFORMAT 65216 . 66665) (\REMOVE.EXTERNALFORMAT 66667 . 67498) (FIND-FORMAT 67500 . 
+68051) (\EXTERNALFORMAT 68053 . 72775)) (73100 74928 (\CREATE.THROUGH.EXTERNALFORMAT 73110 . 73912) (
+\THROUGHIN 73914 . 74329) (\THROUGHBACKCCODE 74331 . 74576) (\THROUGHOUTCHARFN 74578 . 74926)) (75036 
+81005 (\DEFINEDEVICE 75046 . 77362) (\GETDEVICEFROMNAME 77364 . 77837) (\GETDEVICEFROMHOSTNAME 77839
+ . 78883) (\REMOVEDEVICE 78885 . 80008) (\REMOVEDEVICE.NAMES 80010 . 81003)) (81045 105705 (\CLOSEFILE
+ 81055 . 81880) (\DELETEFILE 81882 . 82176) (\DEVICEEVENT 82178 . 83948) (\GENERATEFILES 83950 . 84428
+) (\GENERATENEXTFILE 84430 . 85081) (\GENERATEFILEINFO 85083 . 85544) (\GETFILENAME 85546 . 85935) (
+\GENERIC.OUTFILEP 85937 . 86407) (\OPENFILE 86409 . 88987) (\DO.PARAMS.AT.OPEN 88989 . 91542) (
+\RENAMEFILE 91544 . 91968) (\REVALIDATEFILE 91970 . 94572) (\PAGED.REVALIDATEFILELST 94574 . 96132) (
+\PAGED.REVALIDATEFILES 96134 . 97853) (\PAGED.REVALIDATEFILE 97855 . 100138) (\BUFFERED.REVALIDATEFILE
+ 100140 . 102426) (\BUFFERED.REVALIDATEFILELST 102428 . 103612) (\PRINT-REVALIDATION-RESULT 103614 . 
+104029) (\TRUNCATEFILE 104031 . 104422) (\FILE-CONFLICT 104424 . 105703)) (105741 110404 (
+\GENERATENOFILES 105751 . 107847) (\NULLFILEGENERATOR 107849 . 108093) (\NOFILESNEXTFILEFN 108095 . 
+110086) (\NOFILESINFOFN 110088 . 110402)) (110523 112431 (\FILE.NOT.OPEN 110533 . 111046) (
+\FILE.WONT.OPEN 111048 . 111376) (\ILLEGAL.DEVICEOP 111378 . 111660) (\IS.NOT.RANDACCESSP 111662 . 
+112108) (\STREAM.NOT.OPEN 112110 . 112429)) (112566 114864 (\FDEVINSTANCE 112576 . 114862)) (116414 
+123788 (CNDIR 116424 . 117729) (DIRECTORYNAME 117731 . 121914) (DIRECTORYNAMEP 121916 . 122532) (
+HOSTNAMEP 122534 . 123341) (\ADD.CONNECTED.DIR 123343 . 123786)) (123833 154476 (\BACKFILEPTR 123843
+ . 124031) (\BACKPEEKBIN 124033 . 124394) (\BACKBIN 124396 . 124747) (BIN 124749 . 124966) (\BIN 
+124968 . 125245) (\BINS 125247 . 125533) (BOUT 125535 . 125897) (\BOUT 125899 . 126214) (\BOUTS 126216
+ . 126527) (COPYBYTES 126529 . 129861) (COPYCHARS 129863 . 136785) (COPYFILE 136787 . 137584) (
+\COPYOPENFILE 137586 . 140659) (\INFER.FILE.TYPE 140661 . 141615) (EOFP 141617 . 141914) (FORCEOUTPUT 
+141916 . 142163) (\FLUSH.OPEN.STREAMS 142165 . 142521) (CHARSET 142523 . 144187) (ACCESS-CHARSET 
+144189 . 144406) (GETEOFPTR 144408 . 144658) (GETFILEINFO 144660 . 147853) (\TYPE.FROM.FILETYPE 147855
+ . 148325) (\FILETYPE.FROM.TYPE 148327 . 148506) (GETFILEPTR 148508 . 148760) (SETFILEINFO 148762 . 
+152375) (SETFILEPTR 152377 . 154096) (BOUT16 154098 . 154283) (BIN16 154285 . 154474)) (154579 159784 
+(\GENERIC.BINS 154589 . 154869) (\GENERIC.BOUTS 154871 . 155136) (\GENERIC.RENAMEFILE 155138 . 156969)
+ (\GENERIC.OPENP 156971 . 158286) (\GENERIC.READP 158288 . 159329) (\GENERIC.CHARSET 159331 . 159782))
+ (159785 160124 (\MAP-OPEN-STREAMS 159795 . 160122)) (161994 164074 (\EOF.ACTION 162004 . 162255) (
+\EOSERROR 162257 . 162450) (\GETEOFPTR 162452 . 162634) (\INCFILEPTR 162636 . 162986) (\PEEKBIN 162988
+ . 163179) (\SETCLOSEDFILELENGTH 163181 . 163515) (\SETEOFPTR 163517 . 163705) (\SETFILEPTR 163707 . 
+164072)) (164075 164617 (\FIXPOUT 164085 . 164385) (\FIXPIN 164387 . 164615)) (164618 165286 (\BOUTEOL
+ 164628 . 165284)) (168378 178242 (\BUFFERED.BIN 168388 . 169240) (\BUFFERED.PEEKBIN 169242 . 170024) 
+(\BUFFERED.BOUT 170026 . 170886) (\BUFFERED.BINS 170888 . 174573) (\BUFFERED.BOUTS 174575 . 176376) (
+\BUFFERED.COPYBYTES 176378 . 178240)) (178271 180623 (\NULLDEVICE 178281 . 180299) (\NULL.OPENFILE 
+180301 . 180621)))))
 STOP
diff --git a/sources/FILEIO.LCOM b/sources/FILEIO.LCOM
index f94a25e2..b8253988 100644
Binary files a/sources/FILEIO.LCOM and b/sources/FILEIO.LCOM differ
diff --git a/sources/MACHINEINDEPENDENT b/sources/MACHINEINDEPENDENT
index 9545f3e1..5c975b1a 100644
--- a/sources/MACHINEINDEPENDENT
+++ b/sources/MACHINEINDEPENDENT
@@ -1,67 +1,71 @@
-(DEFINE-FILE-INFO PACKAGE "INTERLISP" READTABLE "XCL" BASE 10 FORMAT XCCS)
-(FILECREATED "29-Jul-2021 20:32:10" 
-|{DSK}<Users>kaplan>Local>medley3.5>git-medley>sources>MACHINEINDEPENDENT.;15| 116367 
+(DEFINE-FILE-INFO PACKAGE "INTERLISP" READTABLE "INTERLISP" BASE 10 FORMAT XCCS)
+(FILECREATED " 5-Aug-2021 21:01:33" 
+{DSK}<Users>kaplan>Local>medley3.5>git-medley>sources>MACHINEINDEPENDENT.;23 114018 
 
-      |previous| |date:| "21-Jul-2021 21:06:47" 
-|{DSK}<Users>kaplan>Local>medley3.5>git-medley>sources>MACHINEINDEPENDENT.;14|)
+      changes to%:  (FNS WRITEFILE)
+
+      previous date%: " 5-Aug-2021 20:43:52" 
+{DSK}<Users>kaplan>Local>medley3.5>git-medley>sources>MACHINEINDEPENDENT.;22)
 
 
-; Copyright (c) 1983-1991, 2021 by Venue & Xerox Corporation.
-; The following program was created in 1983 but has not been published
-; within the meaning of the copyright law, is furnished under license,
-; and may not be used, copied and/or disclosed except in accordance
-; with the terms of said license.
+(* ; "
+Copyright (c) 1983-1991, 2021 by Venue & Xerox Corporation.
+The following program was created in 1983 but has not been published
+within the meaning of the copyright law, is furnished under license,
+and may not be used, copied and/or disclosed except in accordance
+with the terms of said license.
+")
 
 (PRETTYCOMPRINT MACHINEINDEPENDENTCOMS)
 
 (RPAQQ MACHINEINDEPENDENTCOMS
-       ((COMS                                                (* \; " \"File loader\"")
+       ([COMS                                                (* ; " %"File loader%"")
               (FNS LOAD? FILESLOAD DOFILESLOAD FINDFILE-WITH-EXTENSIONS READ-FILECREATED)
-              (INITVARS (*COMPILED-EXTENSIONS* (LIST FASL.EXT COMPILE.EXT))))
-        (COMS                                                (* \; 
+              (INITVARS (*COMPILED-EXTENSIONS* (LIST FASL.EXT COMPILE.EXT]
+        (COMS                                                (* ; 
                                                            "random machine-independent utilities")
               (FNS DMPHASH HASHOVERFLOW)
-              (DECLARE\: EVAL@COMPILE DONTCOPY (MACROS HASHOVERFLOW.ARRAYTEST 
+              (DECLARE%: EVAL@COMPILE DONTCOPY (MACROS HASHOVERFLOW.ARRAYTEST 
                                                       HASHOVERFLOW.UPDATEARRAY))
               (FNS BKBUFS CHANGENAME CHNGNM CLBUFS DEFINE FNS.PUTDEF EQMEMB EQUALN FNCHECK FNTYP1 
                    LCSKIP MAPRINT MKLIST NAMEFIELD NLIST PRINTBELLS PROMPTCHAR RAISEP READFILE 
                    READLINE REMPROPLIST RESETBUFS TAB UNSAVED1 WRITEFILE CLOSE-AND-MAYBE-DELETE 
                    UNSAFE.TO.MODIFY)
               (VARS UNSAFE.TO.MODIFY.FNS)
-              (COMS                                          (* \; 
+              [COMS                                          (* ; 
             "FILEDATE, for finding out the creation date of source files, from the compiled files.")
                     
-                    (* |;;| "FASL isn't loaded when MACHINEINDEPENDENT is, so we have to fake the FASL checker for now.  It's defined in FASLOAD.")
+                    (* ;; "FASL isn't loaded when MACHINEINDEPENDENT is, so we have to fake the FASL checker for now.  It's defined in FASLOAD.")
 
                     (FNS FILEDATE)
-                    (P (MOVD? 'NILL 'FASL-FILEDATE)))
+                    (P (MOVD? 'NILL 'FASL-FILEDATE]
               (P (MOVD? 'CL:FMAKUNBOUND 'UNDOABLY-FMAKUNBOUND))
-                                                             (* \; 
+                                                             (* ; 
                                                          "used in FNS.PUTDEF before CMLUNDO loaded")
               )
-        (COMS                                                (* \; 
+        (COMS                                                (* ; 
                    "Functions for retrieving and remembering FILEMAPs and file reader environments")
-              (FNS FILEMAP \\PARSE-FILE-HEADER GET-ENVIRONMENT-AND-FILEMAP 
-                   LOOKUP-ENVIRONMENT-AND-FILEMAP GET-FILEMAP-FROM-FILECREATED \\FILEMAP-HASHOVERFLOW
+              (FNS FILEMAP \PARSE-FILE-HEADER GET-ENVIRONMENT-AND-FILEMAP 
+                   LOOKUP-ENVIRONMENT-AND-FILEMAP GET-FILEMAP-FROM-FILECREATED \FILEMAP-HASHOVERFLOW
                    FLUSHFILEMAPS LISPSOURCEFILEP GETFILEMAP PUTFILEMAP UPDATEFILEMAP)
-              (INITVARS (*FILEMAP-LIMIT* 20)
+              [INITVARS (*FILEMAP-LIMIT* 20)
                      (*FILEMAP-VERSIONS* 2)
-                     (*FILEMAP-HASH* (HASHARRAY *FILEMAP-LIMIT* (FUNCTION \\FILEMAP-HASHOVERFLOW)
+                     (*FILEMAP-HASH* (HASHARRAY *FILEMAP-LIMIT* (FUNCTION \FILEMAP-HASHOVERFLOW)
                                             (FUNCTION STRING-EQUAL-HASHBITS)
-                                            (FUNCTION STRING.EQUAL))))
-              (DECLARE\: EVAL@COMPILE DONTCOPY (RECORDS FILEMAPHASH)
+                                            (FUNCTION STRING.EQUAL]
+              (DECLARE%: EVAL@COMPILE DONTCOPY (RECORDS FILEMAPHASH)
                      (GLOBALVARS *FILEMAP-LIMIT* *FILEMAP-VERSIONS* *FILEMAP-HASH*)))
         (COMS (* * LVLPRINT)
               (FNS LVLPRINT LVLPRIN1 LVLPRIN2 LVLPRIN LVLPRIN0))
-        (COMS                                                (* \; "used by PRINTOUT")
+        (COMS                                                (* ; "used by PRINTOUT")
               (FNS FLUSHRIGHT PRINTPARA PRINTPARA1))
-        (COMS                                                (* \; "SUBLIS and friends")
+        (COMS                                                (* ; "SUBLIS and friends")
               (FNS SUBLIS SUBPAIR DSUBLIS))
-        (COMS (* * CONSTANTS)
+        [COMS (* * CONSTANTS)
               (FNS CONSTANTOK)
               (P (MOVD? 'EVQ 'CONSTANT)
                  (MOVD? 'EVQ 'DEFERREDCONSTANT)
-                 (MOVD? 'EVQ 'LOADTIMECONSTANT)))
+                 (MOVD? 'EVQ 'LOADTIMECONSTANT]
         (COMS (* * SCRATCHLIST)
               (PROP MACRO SCRATCHLIST ADDTOSCRATCHLIST)
               (PROP INFO SCRATCHLIST))
@@ -69,8 +73,8 @@
                REREADFLG HISTSTR0 CTRLUFLG NOLINKMESS PROMPTCHARFORMS PROMPT#FLG FILERDTBL SPELLINGS2
                USERWORDS BELLS CLISPARRAY)
         (FNS NLAMBDA.ARGS)
-        (DECLARE\:
-         DONTEVAL@LOAD DOCOPY                                (* \; 
+        [DECLARE%:
+         DONTEVAL@LOAD DOCOPY                                (* ; 
                                                   "initialization of variables used in many places")
          (ADDVARS (CLISPARRAY)
                 (CLISPFLG)
@@ -104,14 +108,14 @@
                 (CHCONLST2 '(NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL NIL
                                  NIL NIL))
                 (CLEARSTKLST T)
-                (CLISPTRANFLG 'CLISP\ )
+                (CLISPTRANFLG 'CLISP% )
                 (HISTSTR0 "<c.r.>")
                 (HISTSTR2 "repeat")
                 (HISTSTR3 "from event:")
                 (HISTSTR4 "ignore")
                 (LISPXREADFN 'READ)
                 (USEMAPFLG T))
-         (P (MAPC '((APPLY BLKAPPLY)
+         (P [MAPC '((APPLY BLKAPPLY)
                     (SETTOPVAL SETATOMVAL)
                     (GETTOPVAL GETATOMVAL)
                     (APPLY* BLKAPPLY*)
@@ -166,8 +170,8 @@
                     (COPYBYTES COPYCHARS))
                   (FUNCTION (LAMBDA (X)
                                    (MOVD? (CAR X)
-                                          (CADR X)))))
-            (MAPC '((TIME PRIN1 LISPXPRIN1)
+                                          (CADR X]
+            [MAPC '((TIME PRIN1 LISPXPRIN1)
                     (TIME SPACES LISPXSPACES)
                     (TIME PRINT LISPXPRINT)
                     (DEFC PRINT LISPXPRINT)
@@ -180,15 +184,15 @@
                     (MKSWAPBLOCK PUTD /PUTD))
                   (FUNCTION (LAMBDA (X)
                                    (AND (CCODEP (CAR X))
-                                        (APPLY 'CHANGENAME X)))))
-            (MAPC '((EVALQT (LAMBDA NIL (PROG (TEM)
+                                        (APPLY 'CHANGENAME X]
+            (MAPC '[[EVALQT (LAMBDA NIL (PROG (TEM)
                                               (RESETRESTORE NIL 'RESET)
                                               LP
                                               (PROMPTCHAR '_ T)
                                               (LISPX (LISPXREAD T T))
-                                              (GO LP))))
-                    (LISPX (LAMBDA (LISPXX)
-                                  (PRINT (AND LISPXX (PROG (LISPXLINE LISPXHIST TEM)
+                                              (GO LP]
+                    [LISPX (LAMBDA (LISPXX)
+                                  (PRINT [AND LISPXX (PROG (LISPXLINE LISPXHIST TEM)
                                                            (RETURN (COND ((AND (NLISTP LISPXX)
                                                                                (SETQ LISPXLINE
                                                                                      (READLINE T NIL
@@ -196,44 +200,44 @@
                                                                           (APPLY LISPXX (CAR 
                                                                                             LISPXLINE
                                                                                              )))
-                                                                         (T (EVAL LISPXX))))))
-                                         T T)))
-                    (LISPXREAD (LAMBDA (FILE RDTBL)
-                                      (COND (READBUF (PROG1 (CAR READBUF)
-                                                         (SETQ READBUF (CDR READBUF))))
-                                            (T (READ FILE RDTBL)))))
-                    (LISPXREADP (LAMBDA (FLG)
+                                                                         (T (EVAL LISPXX]
+                                         T T]
+                    [LISPXREAD (LAMBDA (FILE RDTBL)
+                                      (COND [READBUF (PROG1 (CAR READBUF)
+                                                         (SETQ READBUF (CDR READBUF)))]
+                                            (T (READ FILE RDTBL]
+                    [LISPXREADP (LAMBDA (FLG)
                                        (COND ((AND READBUF (SETQ READBUF (LISPXREADBUF READBUF)))
                                               T)
-                                             (T (READP T FLG)))))
-                    (LISPXUNREAD (LAMBDA (LST)
-                                        (SETQ READBUF (APPEND LST (CONS HISTSTR0 READBUF)))))
-                    (LISPXREADBUF (LAMBDA (RDBUF)
+                                             (T (READP T FLG]
+                    [LISPXUNREAD (LAMBDA (LST)
+                                        (SETQ READBUF (APPEND LST (CONS HISTSTR0 READBUF]
+                    [LISPXREADBUF (LAMBDA (RDBUF)
                                          (PROG NIL LP (COND ((NLISTP RDBUF)
                                                              (RETURN NIL))
                                                             ((EQ (CAR RDBUF)
                                                                  HISTSTR0)
                                                              (SETQ RDBUF (CDR RDBUF))
                                                              (GO LP))
-                                                            (T (RETURN RDBUF))))))
-                    (LISPX/ (LAMBDA (X)
-                                   X))
-                    (LOWERCASE (LAMBDA (FLG)
+                                                            (T (RETURN RDBUF]
+                    [LISPX/ (LAMBDA (X)
+                                   X]
+                    [LOWERCASE (LAMBDA (FLG)
                                       (PROG1 LCASEFLG
                                           (RAISE (NULL FLG))
-                                          (RPAQ LCASEFLG FLG))))
-                    (FILEPOS (LAMBDA (STR FILE)
+                                          (RPAQ LCASEFLG FLG))]
+                    [FILEPOS (LAMBDA (STR FILE)
                                     (PROG NIL LP (COND ((EQ (PEEKC FILE)
                                                             (NTHCHAR STR 1))
                                                         (RETURN T)))
                                           (READC FILE)
-                                          (GO LP))))
-                    (FILEPKGCOM (NLAMBDA NIL NIL)))
+                                          (GO LP]
+                    (FILEPKGCOM (NLAMBDA NIL NIL]
                   (FUNCTION (LAMBDA (L)
                                    (OR (GETD (CAR L))
                                        (PUTD (CAR L)
-                                             (CADR L))))))))
-        (DECLARE\: DONTEVAL@LOAD DOEVAL@COMPILE DONTCOPY COMPILERVARS (ADDVARS (NLAMA RESETBUFS 
+                                             (CADR L]
+        (DECLARE%: DONTEVAL@LOAD DOEVAL@COMPILE DONTCOPY COMPILERVARS (ADDVARS (NLAMA RESETBUFS 
                                                                                       DMPHASH 
                                                                                       FILESLOAD)
                                                                              (NLAML FILEMAP)
@@ -242,346 +246,339 @@
 
 
 
-(* \; " \"File loader\"")
+(* ; " %"File loader%"")
 
 (DEFINEQ
 
 (LOAD?
-  (LAMBDA (FILE LDFLG PRINTFLG)                          (* |lmm| " 2-Sep-85 13:15")
-    (|bind| FULL |until| (SETQ FULL (FINDFILE FILE)) |do| (SETQ FILE
-                                                                       (LISPERROR "FILE NOT FOUND" 
-                                                                              FILE T))
-       |finally|
+  [LAMBDA (FILE LDFLG PRINTFLG)                          (* lmm " 2-Sep-85 13:15")
+    (bind FULL until (SETQ FULL (FINDFILE FILE)) do (SETQ FILE (LISPERROR 
+                                                                                  "FILE NOT FOUND" 
+                                                                                  FILE T))
+       finally
        (RETURN
-        (|if| (FMEMB FULL LOADEDFILELST)
-            |then| FULL
-          |else| (LET* ((ROOT (ROOTFILENAME FULL))
-                            (DATES (GETPROP ROOT 'FILEDATES))
-                            (FILEPROP (GETPROP ROOT 'FILE)))
-                           (|if| (AND DATES (|if| (EQ (FILENAMEFIELD FULL 'EXTENSION)
-                                                              COMPILE.EXT)
-                                                    |then|
-                                                    (AND (OR (NULL FILEPROP)
-                                                             (FMEMB (CDAR FILEPROP)
-                                                                    '(|Compiled| COMPILED)))
-                                                         (EQUAL (CAAR DATES)
-                                                                (FILEDATE FULL T)))
-                                                  |else| (AND FILEPROP (EQ (CDAR FILEPROP)
-                                                                               T)
-                                                                  (OR (EQ (CDAR DATES)
-                                                                          FULL)
-                                                                      (EQUAL (CAAR DATES)
-                                                                             (FILEDATE FULL))))))
-                               |then| FULL
-                             |else| (LOAD FULL LDFLG PRINTFLG))))))))
+        (if (FMEMB FULL LOADEDFILELST)
+            then FULL
+          else (LET* [(ROOT (ROOTFILENAME FULL))
+                          (DATES (GETPROP ROOT 'FILEDATES))
+                          (FILEPROP (GETPROP ROOT 'FILE]
+                         (if [AND DATES (if (EQ (FILENAMEFIELD FULL 'EXTENSION)
+                                                        COMPILE.EXT)
+                                                then (AND [OR (NULL FILEPROP)
+                                                                  (FMEMB (CDAR FILEPROP)
+                                                                         '(Compiled COMPILED]
+                                                              (EQUAL (CAAR DATES)
+                                                                     (FILEDATE FULL T)))
+                                              else (AND FILEPROP (EQ (CDAR FILEPROP)
+                                                                         T)
+                                                            (OR (EQ (CDAR DATES)
+                                                                    FULL)
+                                                                (EQUAL (CAAR DATES)
+                                                                       (FILEDATE FULL]
+                             then FULL
+                           else (LOAD FULL LDFLG PRINTFLG])
 
 (FILESLOAD
-  (NLAMBDA FILES                                         (* |lmm| "10-Dec-84 17:23")
+  [NLAMBDA FILES                                         (* lmm "10-Dec-84 17:23")
 
-    (* |;;| "Calls to this are written on files by the FILES command.  This function does the load-time evaluation of the command.")
+    (* ;; "Calls to this are written on files by the FILES command.  This function does the load-time evaluation of the command.")
 
-    (DOFILESLOAD (NLAMBDA.ARGS FILES))))
+    (DOFILESLOAD (NLAMBDA.ARGS FILES])
 
 (DOFILESLOAD
-  (LAMBDA (FILES)
-    (DECLARE (USEDFREE LDFLG))                       (* \; "Edited  4-May-88 14:23 by bvm")
-                                                             (* \; "does the work of FILESLOAD")
-    (|for| FILE |inside| FILES |bind| DIRS LOADOPTIONSFLG FORCEDEXT? NOERRORFLG WORD FULL
-                                             (FN _ 'LOAD?)
-                                             (EXT _ :COMPILED)
-       |first| (COND
-                      ((BOUNDP 'LDFLG)
+  [LAMBDA (FILES)
+    (DECLARE (USEDFREE LDFLG))                       (* ; "Edited  4-May-88 14:23 by bvm")
+                                                             (* ; "does the work of FILESLOAD")
+    (for FILE inside FILES bind DIRS LOADOPTIONSFLG FORCEDEXT? NOERRORFLG WORD FULL
+                                         (FN _ 'LOAD?)
+                                         (EXT _ :COMPILED)
+       first [COND
+                    ((BOUNDP 'LDFLG)
 
-                       (* |;;| 
-                     "Under a load;  give priority to directory of currently loading file. ")
+                     (* ;; "Under a load;  give priority to directory of currently loading file. ")
 
-                       (LET ((INPUTNAME (FULLNAME *STANDARD-INPUT*)))
-                            (|if| (AND (NEQ INPUTNAME *STANDARD-INPUT*)
-                                           (NEQ INPUTNAME T))
-                                |then|                   (* \; 
+                     (LET ((INPUTNAME (FULLNAME *STANDARD-INPUT*)))
+                          (if (AND (NEQ INPUTNAME *STANDARD-INPUT*)
+                                       (NEQ INPUTNAME T))
+                              then                       (* ; 
                                       "If reading from terminal or nameless stream, don't do this.")
-                                      (SETQ DIRS (CONS (PACKFILENAME.STRING 'VERSION NIL 'NAME NIL
-                                                              'EXTENSION NIL 'BODY INPUTNAME)
-                                                       (CONS T DIRECTORIES)))
-                                      (SETQ LOADOPTIONSFLG LDFLG)))))
-       |join|
+                                    (SETQ DIRS (CONS (PACKFILENAME.STRING 'VERSION NIL 'NAME NIL
+                                                            'EXTENSION NIL 'BODY INPUTNAME)
+                                                     (CONS T DIRECTORIES)))
+                                    (SETQ LOADOPTIONSFLG LDFLG]
+       join
        (COND
-          ((OR (LITATOM FILE)
-               (STRINGP FILE))                               (* \; "A file to do something with")
+          [(OR (LITATOM FILE)
+               (STRINGP FILE))                               (* ; "A file to do something with")
            (PROG NIL
                  (COND
                     ((AND (EQ FN 'LOAD?)
                           (GETPROP (ROOTFILENAME FILE)
-                                 'FILEDATES))                (* \; "Already loaded")
+                                 'FILEDATES))                (* ; "Already loaded")
                      (RETURN)))
              LP  (COND
-                    ((SETQ FULL (SELECTQ EXT
-                                    (NIL                     (* \; "No extension to guide us")
+                    [(SETQ FULL (SELECTQ EXT
+                                    (NIL                     (* ; "No extension to guide us")
                                          (FINDFILE FILE T DIRS))
-                                    (:COMPILED               (* \; 
+                                    (:COMPILED               (* ; 
                                     "Look for some sort of compiled file, or failing that a source")
                                                (OR (FINDFILE-WITH-EXTENSIONS FILE DIRS 
                                                           *COMPILED-EXTENSIONS*)
                                                    (AND (NOT FORCEDEXT?)
                                                         (FINDFILE FILE T DIRS))))
-                                    (PROGN                   (* \; 
+                                    (PROGN                   (* ; 
                                                            "Look for explicitly supplied extension")
                                            (FINDFILE (PACKFILENAME.STRING 'BODY FILE 'EXTENSION EXT)
-                                                  T DIRS)))))
+                                                  T DIRS]
                     (NOERRORFLG (RETURN))
                     ((AND (SETQ FILE (CL:CERROR "Forget about loading ~A" 
                                             "File ~A not found~@[ on~{ ~A~}~]" FILE DIRS))
                           (OR (LITATOM FILE)
-                              (STRINGP FILE)))               (* \; "User RETURNed a new file name")
+                              (STRINGP FILE)))               (* ; "User RETURNed a new file name")
                      (GO LP))
-                    (T                                       (* \; 
+                    (T                                       (* ; 
                                                 "if proceed from ERROR, blow off loading this file")
                        (RETURN)))
                  (RETURN (LIST (SELECTQ FN
-                                   (CHECKIMPORTS             (* \; 
+                                   (CHECKIMPORTS             (* ; 
                                                "LOADOPTIONSFLG has a different meaning for imports")
                                                  (CHECKIMPORTS FULL T)
                                                  FULL)
-                                   (LOAD?                    (* \; 
+                                   (LOAD?                    (* ; 
                                                        "already weeded out the ones with filedates")
                                           (LOAD FULL LOADOPTIONSFLG))
-                                   (CL:FUNCALL FN FULL LOADOPTIONSFLG))))))
-          (T (|while| (LISTP FILE)
-                |do| (SELECTQ (CAR FILE)
-                             (LOADCOMP (SETQQ FN LOADCOMP?)
-                                       (SETQ LOADOPTIONSFLG NIL)
-                                       (SETQ EXT NIL))
-                             (LOADFROM (SETQQ FN LOADFROM)
-                                       (SETQ EXT NIL))
-                             (FROM (|pop| FILE)
-                                   (SETQ DIRS (MKLIST (COND
-                                                             ((OR (EQ (SETQ WORD (CAR FILE))
-                                                                      'VALUEOF)
-                                                                  (COND
-                                                                     ((AND (EQ WORD 'VALUE)
-                                                                           (EQ (CADR FILE)
-                                                                               'OF))
-                                                                      (|pop| FILE)
-                                                                      T)))
-                                                              (|pop| FILE)
-                                                              (EVAL (CAR FILE)))
-                                                             ((AND (SELCHARQ (CHCON1 WORD)
-                                                                        (({ <) 
-                                                                             NIL)
-                                                                        T)
-                                                                   (BOUNDP (SETQ WORD
-                                                                            (PACK* WORD 'DIRECTORIES)
-                                                                            ))
-                                                                   (SETQ WORD (EVALV WORD)))
-                                                             (* \; 
-                   "KLUDGE: Turns, e.g., (FROM LISPUSERS) into (FROM VALUEOF LISPUSERSDIRECTORIES)")
-                                                              WORD)
-                                                             (T (CAR FILE))))))
-                             (COMPILED (SETQ FORCEDEXT? T)
-                                       (SETQ EXT :COMPILED))
-                             (LOAD (SETQQ FN LOAD?))
-                             ((EXTENSION EXT) 
-                                  (SETQ FILE (LISTP (CDR FILE)))
-                                  (SETQ EXT (CAR FILE)))
-                             ((SOURCE SYMBOLIC) 
-                                  (SETQ EXT NIL))
-                             (IMPORT (SETQQ FN CHECKIMPORTS)
+                                   (CL:FUNCALL FN FULL LOADOPTIONSFLG]
+          (T (while (LISTP FILE)
+                do (SELECTQ (CAR FILE)
+                           (LOADCOMP (SETQQ FN LOADCOMP?)
+                                     (SETQ LOADOPTIONSFLG NIL)
                                      (SETQ EXT NIL))
-                             (NOERROR (SETQ NOERRORFLG T))
-                             (COND
-                                ((FMEMB (CAR FILE)
-                                        LOADOPTIONS)
-                                 (SETQ LOADOPTIONSFLG (CAR FILE)))
-                                (T                           (* \; "invalid option in FILESLOAD")
-                                   NIL)))
-                      (|pop| FILE))
-             NIL)))))
+                           (LOADFROM (SETQQ FN LOADFROM)
+                                     (SETQ EXT NIL))
+                           (FROM (pop FILE)
+                                 [SETQ DIRS (MKLIST (COND
+                                                           ((OR (EQ (SETQ WORD (CAR FILE))
+                                                                    'VALUEOF)
+                                                                (COND
+                                                                   ((AND (EQ WORD 'VALUE)
+                                                                         (EQ (CADR FILE)
+                                                                             'OF))
+                                                                    (pop FILE)
+                                                                    T)))
+                                                            (pop FILE)
+                                                            (EVAL (CAR FILE)))
+                                                           ((AND (SELCHARQ (CHCON1 WORD)
+                                                                      (({ <) 
+                                                                           NIL)
+                                                                      T)
+                                                                 [BOUNDP (SETQ WORD
+                                                                          (PACK* WORD 'DIRECTORIES]
+                                                                 (SETQ WORD (EVALV WORD)))
+                                                             (* ; 
+                   "KLUDGE: Turns, e.g., (FROM LISPUSERS) into (FROM VALUEOF LISPUSERSDIRECTORIES)")
+                                                            WORD)
+                                                           (T (CAR FILE])
+                           (COMPILED (SETQ FORCEDEXT? T)
+                                     (SETQ EXT :COMPILED))
+                           (LOAD (SETQQ FN LOAD?))
+                           ((EXTENSION EXT) 
+                                (SETQ FILE (LISTP (CDR FILE)))
+                                (SETQ EXT (CAR FILE)))
+                           ((SOURCE SYMBOLIC) 
+                                (SETQ EXT NIL))
+                           (IMPORT (SETQQ FN CHECKIMPORTS)
+                                   (SETQ EXT NIL))
+                           (NOERROR (SETQ NOERRORFLG T))
+                           (COND
+                              ((FMEMB (CAR FILE)
+                                      LOADOPTIONS)
+                               (SETQ LOADOPTIONSFLG (CAR FILE)))
+                              (T                             (* ; "invalid option in FILESLOAD")
+                                 NIL)))
+                      (pop FILE))
+             NIL])
 
 (FINDFILE-WITH-EXTENSIONS
-  (LAMBDA (FILE DIRLST EXTENSIONS)                       (* \; "Edited  8-Dec-86 17:57 by bvm")
+  [LAMBDA (FILE DIRLST EXTENSIONS)                       (* ; "Edited  8-Dec-86 17:57 by bvm")
 
-(* |;;;| "Search for FILE on the directories contained in DIRLST, where NIL and T refer to the login and connected dirs, respectively.  On each directory, prefer files having extension found in EXTENSIONS in the indicated order.  If FILE already has an extension, EXTENSIONS is ignored; if FILE already has a host/dir, DIRLST is ignored.")
+(* ;;; "Search for FILE on the directories contained in DIRLST, where NIL and T refer to the login and connected dirs, respectively.  On each directory, prefer files having extension found in EXTENSIONS in the indicated order.  If FILE already has an extension, EXTENSIONS is ignored; if FILE already has a host/dir, DIRLST is ignored.")
 
-    (|if| FILE
-        |then|
+    (if FILE
+        then
         (LET
          ((FIELDS (UNPACKFILENAME.STRING FILE))
           DIR&FIELDS HASDIRECTORY HASEXTENSION VAL)
-         (|for| TAIL |on| FIELDS |by| (CDDR TAIL) |do| (SELECTQ (CAR TAIL)
-                                                                           (EXTENSION (SETQ 
-                                                                                       HASEXTENSION T
-                                                                                       ))
-                                                                           ((HOST DEVICE DIRECTORY) 
-                                                                                (SETQ HASDIRECTORY T))
-                                                                           NIL))
-         (|if| HASDIRECTORY
-             |then|                                      (* \; 
+         (for TAIL on FIELDS by (CDDR TAIL) do (SELECTQ (CAR TAIL)
+                                                                   (EXTENSION (SETQ HASEXTENSION T))
+                                                                   ((HOST DEVICE DIRECTORY) 
+                                                                        (SETQ HASDIRECTORY T))
+                                                                   NIL))
+         (if HASDIRECTORY
+             then                                        (* ; 
                                                        "Don't search dirs, just look where it says")
-                   (|if| HASEXTENSION
-                       |then| (INFILEP FILE)
-                     |else| (|for| EXT |in| EXTENSIONS
-                                   |when| (SETQ VAL (INFILEP (PACKFILENAME.STRING
-                                                                  `(EXTENSION ,EXT ,@FIELDS))))
-                                   |do| (RETURN VAL)))
-           |else|
-           (|for| DIR |inside| (|if| (NULL DIRLST)
-                                           |then|        (* \; 
+                   (if HASEXTENSION
+                       then (INFILEP FILE)
+                     else (for EXT in EXTENSIONS
+                                 when [SETQ VAL (INFILEP (PACKFILENAME.STRING
+                                                              `(EXTENSION ,EXT ,@FIELDS]
+                                 do (RETURN VAL)))
+           else
+           (for DIR inside (if (NULL DIRLST)
+                                       then              (* ; 
                                       "If DIRLST is defaulted, always look first on connected dir.")
-                                                 (|if| DIRECTORIES
-                                                     |then| (CONS T (REMOVE T DIRECTORIES))
-                                                   |else| T)
-                                         |else|          (* \; 
+                                             (if DIRECTORIES
+                                                 then (CONS T (REMOVE T DIRECTORIES))
+                                               else T)
+                                     else                (* ; 
                            "use explicit DIRLST, ignoring connected dir unless it's on DIRECTORIES")
-                                               DIRLST)
-              |when|
-              (PROGN (SETQ DIR&FIELDS (SELECTQ DIR
-                                          (NIL               (* \; "Login dir")
-                                               `(DIRECTORY ,(DIRECTORYNAME NIL)
-                                                       ,@FIELDS))
-                                          (T                 (* \; "Connected dir")
-                                             FIELDS)
-                                          `(DIRECTORY ,DIR ,@FIELDS)))
-                     (SETQ VAL (|if| HASEXTENSION
-                                   |then| (INFILEP (PACKFILENAME.STRING DIR&FIELDS))
-                                 |else| (|for| EXT |in| EXTENSIONS
-                                               |when| (SETQ VAL
-                                                           (INFILEP (PACKFILENAME.STRING
-                                                                     `(EXTENSION ,EXT ,@DIR&FIELDS)))
-                                                           ) |do| (RETURN VAL)))))
-              |do| (RETURN VAL)))))))
+                                           DIRLST)
+              when [PROGN [SETQ DIR&FIELDS (SELECTQ DIR
+                                                   (NIL      (* ; "Login dir")
+                                                        `(DIRECTORY ,(DIRECTORYNAME NIL)
+                                                                ,@FIELDS))
+                                                   (T        (* ; "Connected dir")
+                                                      FIELDS)
+                                                   `(DIRECTORY ,DIR ,@FIELDS]
+                              (SETQ VAL
+                               (if HASEXTENSION
+                                   then (INFILEP (PACKFILENAME.STRING DIR&FIELDS))
+                                 else (for EXT in EXTENSIONS
+                                             when [SETQ VAL
+                                                       (INFILEP (PACKFILENAME.STRING
+                                                                 `(EXTENSION ,EXT ,@DIR&FIELDS]
+                                             do (RETURN VAL] do (RETURN VAL])
 
 (READ-FILECREATED
-  (LAMBDA (STREAM)                                     (* \; "Edited 19-Sep-2020 20:39 by rmk:")
+  [LAMBDA (STREAM)                                      (* ; "Edited 19-Sep-2020 20:39 by rmk:")
 
-    (* |;;| "Reads the first FILECREATED expression on STREAM")
+    (* ;; "Reads the first FILECREATED expression on STREAM")
 
     (LET ((STARTPOS (GETFILEPTR STREAM)))
          (SETFILEPTR STREAM 0)
          (CL:MULTIPLE-VALUE-BIND (ENV FORM HERE)
-                (\\PARSE-FILE-HEADER STREAM 'RETURN)
+                (\PARSE-FILE-HEADER STREAM 'RETURN)
                 (SETFILEPTR STREAM STARTPOS)
-                FORM))))
+                FORM])
 )
 
 (RPAQ? *COMPILED-EXTENSIONS* (LIST FASL.EXT COMPILE.EXT))
 
 
 
-(* \; "random machine-independent utilities")
+(* ; "random machine-independent utilities")
 
 (DEFINEQ
 
 (DMPHASH
-  (NLAMBDA L                                             (* |rmk:| " 6-Apr-84 14:30")
+  [NLAMBDA L                                             (* rmk%: " 6-Apr-84 14:30")
     (MAPC L (FUNCTION (LAMBDA (ARRAYNAME)
                         (DECLARE (SPECVARS ARRAYNAME))
                         (ERSETQ (PROG ((A (EVALV ARRAYNAME 'DMPHASH))
                                        AP)
-                                      (PRINT (LIST 'RPAQ ARRAYNAME
+                                      [PRINT (LIST 'RPAQ ARRAYNAME
                                                    (COND
-                                                      ((LISTP A)
+                                                      [(LISTP A)
                                                        (SETQ AP (CAR A))
-                                                       (LIST 'CONS (LIST 'HARRAY (HARRAYSIZE AP)
+                                                       (LIST 'CONS [LIST 'HARRAY (HARRAYSIZE AP)
                                                                          (KWOTE (HARRAYPROP
                                                                                  AP
-                                                                                 'OVERFLOW)))
-                                                             (KWOTE (CDR A))))
+                                                                                 'OVERFLOW]
+                                                             (KWOTE (CDR A]
                                                       (T (LIST 'HASHARRAY (HARRAYSIZE A)
-                                                               (KWOTE (HARRAYPROP AP 'OVERFLOW)))))))
+                                                               (KWOTE (HARRAYPROP AP 'OVERFLOW]
                                       (MAPHASH (OR AP A)
                                              (FUNCTION (LAMBDA (VAL ITEM)
                                                          (PRINT (LIST 'PUTHASH (KWOTE ITEM)
                                                                       (KWOTE VAL)
-                                                                      ARRAYNAME))))))))))))
+                                                                      ARRAYNAME])
 
 (HASHOVERFLOW
-  (LAMBDA (HARRAY)                                       (* \; "Edited 26-Feb-91 13:16 by jds")
+  [LAMBDA (HARRAY)                                       (* ; "Edited 26-Feb-91 13:16 by jds")
 
-    (* |;;| "Should be called from PUTHASH on hash overflow, but for implementations where PUTHASH calls ERRORX directly, may be called from ERRORX2 when the offender is a listp.  HARRAY is guaranteed to be either HARRAYP or (LIST HARRAYP)")
+    (* ;; "Should be called from PUTHASH on hash overflow, but for implementations where PUTHASH calls ERRORX directly, may be called from ERRORX2 when the offender is a listp.  HARRAY is guaranteed to be either HARRAYP or (LIST HARRAYP)")
 
     (PROG ((OLDARRAY (HASHOVERFLOW.ARRAYTEST HARRAY))
            NEWARRAY NEWSIZE OLDNUMKEYS OVACTION NEWOVFLW)
-          (COND
+          [COND
              ((LISTP HARRAY)
               (SETQ OVACTION (CDR HARRAY))
 
-              (* |;;| "Get OVERFLOW method from original HARRAY since it would erroneously be ERROR if we got the method from the coerced OLDARRAY")
+              (* ;; "Get OVERFLOW method from original HARRAY since it would erroneously be ERROR if we got the method from the coerced OLDARRAY")
 
               (SETQ NEWOVFLW 'ERROR))
-             (T (SETQ OVACTION (SETQ NEWOVFLW (HARRAYPROP OLDARRAY 'OVERFLOW)))))
+             (T (SETQ OVACTION (SETQ NEWOVFLW (HARRAYPROP OLDARRAY 'OVERFLOW]
           (SETQ OLDNUMKEYS (HARRAYPROP OLDARRAY 'NUMKEYS))
 
-     (* |;;| "Compute the new array size:")
+     (* ;; "Compute the new array size:")
 
-          (SETQ NEWSIZE (SELECTQ OVACTION
+          [SETQ NEWSIZE (SELECTQ OVACTION
                             (NIL 
-                                 (* |;;| "SIZE*1.5 --- favor to bbn, since pdp-11 doesnt have floatng point, and LRSH on other systems might be faster than IQUOTIENT")
+                                 (* ;; "SIZE*1.5 --- favor to bbn, since pdp-11 doesnt have floatng point, and LRSH on other systems might be faster than IQUOTIENT")
 
-                                 (* |;;| 
+                                 (* ;; 
                                "[32749 IS THE BIGGEST PRIME < 32765, THE LIMIT ON ARRAY SIZES]")
 
-                                 (IMAX (+ OLDNUMKEYS 3)
+                                 [IMAX (+ OLDNUMKEYS 3)
                                        (IMIN 32749 (+ OLDNUMKEYS (LRSH (CL:1+ OLDNUMKEYS)
-                                                                       1)))))
-                            (ERROR (|do| (ERRORX (LIST 26 HARRAY))))
-                            (|if| (FLOATP OVACTION)
-                                |then| (IMAX (+ OLDNUMKEYS 3)
-                                                 (IMIN 32760 (FIXR (FTIMES OLDNUMKEYS OVACTION))))
-                              |elseif| (FIXP OVACTION)
-                                |then| (IMAX (+ OLDNUMKEYS 3)
-                                                 (IMIN 32749 (+ OLDNUMKEYS OVACTION)))
-                              |elseif| (AND (FNTYP OVACTION)
-                                                (NUMBERP (SETQ OVACTION (APPLY* OVACTION HARRAY))))
-                                |then| (|if| (FLOATP OVACTION)
-                                               |then|    (* \; 
+                                                                       1])
+                            (ERROR (do (ERRORX (LIST 26 HARRAY))))
+                            (if (FLOATP OVACTION)
+                                then [IMAX (+ OLDNUMKEYS 3)
+                                               (IMIN 32760 (FIXR (FTIMES OLDNUMKEYS OVACTION]
+                              elseif (FIXP OVACTION)
+                                then (IMAX (+ OLDNUMKEYS 3)
+                                               (IMIN 32749 (+ OLDNUMKEYS OVACTION)))
+                              elseif [AND (FNTYP OVACTION)
+                                              (NUMBERP (SETQ OVACTION (APPLY* OVACTION HARRAY]
+                                then (if (FLOATP OVACTION)
+                                             then        (* ; 
                                          "recompute NUMKEYS since OVACTION might have removed keys")
-                                                     (IMAX (+ (SETQ OLDNUMKEYS (HARRAYPROP
-                                                                                OLDARRAY
-                                                                                'NUMKEYS))
-                                                              3)
-                                                           (IMIN 32749 (FIXR (FTIMES OLDNUMKEYS 
-                                                                                    OVACTION))))
-                                             |else| OVACTION)
-                              |else|                     (* \; "Default: multiply by 1.5")
+                                                   [IMAX (+ (SETQ OLDNUMKEYS (HARRAYPROP OLDARRAY
+                                                                                    'NUMKEYS))
+                                                            3)
+                                                         (IMIN 32749 (FIXR (FTIMES OLDNUMKEYS 
+                                                                                  OVACTION]
+                                           else OVACTION)
+                              else                       (* ; "Default: multiply by 1.5")
                                     (SETQ OLDNUMKEYS (HARRAYPROP OLDARRAY 'NUMKEYS))
                                     (IMAX (+ OLDNUMKEYS 3)
                                           (IMIN 32749 (+ OLDNUMKEYS (LRSH (CL:1+ OLDNUMKEYS)
-                                                                          1)))))))
-          (SETQ NEWARRAY (REHASH OLDARRAY (HASHARRAY NEWSIZE NEWOVFLW (HARRAYPROP OLDARRAY
+                                                                          1]
+          [SETQ NEWARRAY (REHASH OLDARRAY (HASHARRAY NEWSIZE NEWOVFLW (HARRAYPROP OLDARRAY
                                                                              'HASHBITSFN)
-                                                 (HARRAYPROP OLDARRAY 'EQUIVFN))))
+                                                 (HARRAYPROP OLDARRAY 'EQUIVFN]
           (HASHOVERFLOW.UPDATEARRAY HARRAY NEWARRAY OLDARRAY)
-          (RETURN HARRAY))))
+          (RETURN HARRAY])
 )
-(DECLARE\: EVAL@COMPILE DONTCOPY 
-(DECLARE\: EVAL@COMPILE 
+(DECLARE%: EVAL@COMPILE DONTCOPY 
+(DECLARE%: EVAL@COMPILE 
 
-(PROGN (PUTPROPS HASHOVERFLOW.ARRAYTEST MACRO ((HARRAY)
+[PROGN (PUTPROPS HASHOVERFLOW.ARRAYTEST MACRO [(HARRAY)
                                                        (CAR (OR (LISTP HARRAY)
-                                                                (ERRORX (LIST 27 HARRAY))))))
+                                                                (ERRORX (LIST 27 HARRAY])
        (PUTPROPS HASHOVERFLOW.ARRAYTEST DMACRO ((HARRAY)
-                                                        (\\DTEST HARRAY 'HARRAYP))))
+                                                        (\DTEST HARRAY 'HARRAYP)))]
 
-(PROGN (PUTPROPS HASHOVERFLOW.UPDATEARRAY MACRO ((HARRAY NEWARRAY OLDARRAY)
+[PROGN (PUTPROPS HASHOVERFLOW.UPDATEARRAY MACRO ((HARRAY NEWARRAY OLDARRAY)
                                                          (FRPLACA HARRAY NEWARRAY)))
        (PUTPROPS HASHOVERFLOW.UPDATEARRAY DMACRO ((HARRAY NEWARRAY OLDARRAY)
-                                                          (\\COPYHARRAYP NEWARRAY OLDARRAY))))
+                                                          (\COPYHARRAYP NEWARRAY OLDARRAY)))]
 )
 )
 (DEFINEQ
 
 (BKBUFS
-  (LAMBDA (BUFS ID)                                      (* DD\: " 6-Oct-81 15:34")
+  [LAMBDA (BUFS ID)                                      (* DD%: " 6-Oct-81 15:34")
     (PROG (L S)
-          (COND
+          [COND
              ((NLISTP BUFS)
               (RETURN))
              (T (SETQ L (CAR BUFS))
-                (SETQ S (CDR BUFS))))
+                (SETQ S (CDR BUFS]
           (COND
              ((READP T)
 
-              (* |;;| "User types ahead before command causing buffer to be restored was executed.  In this case, his type-ahead would come BEFORE the restored buffer, when it should be after it, because the command causing the buffer to be restored had to have been given before the type-ahead.")
+              (* ;; "User types ahead before command causing buffer to be restored was executed.  In this case, his type-ahead would come BEFORE the restored buffer, when it should be after it, because the command causing the buffer to be restored had to have been given before the type-ahead.")
 
               (PRINTBELLS)
               (DOBE)
@@ -593,25 +590,25 @@
           (COND
              (L (AND ID (PRIN1 ID T))
 
-                (* |;;| "ID will be suppressed by LISPX to prevent it being typed in middle of input.  Note that anything put back in SYSBUF will be printed (echoed) as it is read.")
+                (* ;; "ID will be suppressed by LISPX to prevent it being typed in middle of input.  Note that anything put back in SYSBUF will be printed (echoed) as it is read.")
 
                 (PRIN1 L T)
                 (BKLINBUF L)))
-          (RETURN))))
+          (RETURN])
 
 (CHANGENAME
-  (LAMBDA (FN FROM TO)                                   (* |wt:| "18-SEP-78 21:29")
+  [LAMBDA (FN FROM TO)                                   (* wt%: "18-SEP-78 21:29")
     (COND
        ((CHANGENAME1 (GETD FN)
                FROM TO FN)
         (AND FILEPKGFLG (EXPRP FN)
              (MARKASCHANGED FN 'FNS))
-        FN))))
+        FN])
 
 (CHNGNM
-  (LAMBDA (FN OLD FLG)
+  [LAMBDA (FN OLD FLG)
     (PROG (NEW DEF X Y Z)
-          (SETQ FN (FNCHECK FN NIL T))                   (* \; 
+          (SETQ FN (FNCHECK FN NIL T))                   (* ; 
    "No error, becuase maybe OLD isnt defined yet, e.g. BREAK ((FOO IN FUM)) where FOO not defined.")
           (SETQ OLD (OR (FNCHECK OLD T T)
                         OLD))
@@ -619,13 +616,13 @@
                               (GETP FN 'BROKEN)
                               FN)))
           (SETQ NEW (PACK (LIST OLD '-IN- FN)))
-          (COND
+          [COND
              (FLG (AND (NULL (STKPOS NEW))
                        (/PUTD NEW))
-                  (COND
-                     ((SETQ Z (/DREMOVE OLD (GETP FN 'NAMESCHANGED)))
+                  [COND
+                     ([SETQ Z (/DREMOVE OLD (GETP FN 'NAMESCHANGED]
                       (/PUT FN 'NAMESCHANGED Z))
-                     (T (/REMPROP FN 'NAMESCHANGED)))
+                     (T (/REMPROP FN 'NAMESCHANGED]
                   (/REMPROP NEW 'ALIAS)
                   (SETQ Y OLD)
                   (SETQ X NEW))
@@ -635,32 +632,32 @@
                    ((AND (MEMB OLD (GETP FN 'NAMESCHANGED))
                          (GETD NEW)
                          (GETP NEW 'ALIAS))
-                    (RETURN NEW)))))
-          (COND
-             ((NULL DEF)
-              (RETURN (CONS DEF '(|not| |defined|))))
-             ((NULL (RESETVARS ((NOLINKMESS T))
-                               (RETURN (CHANGENAME1 DEF X Y FN))))
-              (RETURN (CONS X (APPEND '(|not| |found| |in|)
-                                     (LIST FN))))))
-          (COND
+                    (RETURN NEW]
+          [COND
+             [(NULL DEF)
+              (RETURN (CONS DEF '(not defined]
+             ([NULL (RESETVARS ((NOLINKMESS T))
+                               (RETURN (CHANGENAME1 DEF X Y FN]
+              (RETURN (CONS X (APPEND '(not found in)
+                                     (LIST FN]
+          [COND
              ((NULL FLG)
               (COND
                  ((NULL (SETQ DEF (GETD OLD)))
                   (SETQ DEF (LIST 'NLAMBDA (GENSYM)))
-                  (PRINT (CONS OLD '(|was| |undefined|))
+                  (PRINT (CONS OLD '(was undefined))
                          T T)))
               (/PUTD NEW (SAVED OLD NIL DEF OLD))
               (/ADDPROP FN 'NAMESCHANGED OLD)
-              (/PUT NEW 'ALIAS (CONS FN OLD))))
-          (RETURN Y))))
+              (/PUT NEW 'ALIAS (CONS FN OLD]
+          (RETURN Y])
 
 (CLBUFS
-  (LAMBDA (NOCLEARFLG NOTYPEFLG BUF)                         (* \; "wt: 10-MAR-77 21 5")
+  [LAMBDA (NOCLEARFLG NOTYPEFLG BUF)                         (* ; "wt: 10-MAR-77 21 5")
 
-    (* |;;| "NOCLEARFLG=T means CLEARBUF has already been done, and anything in the buffer now is type-ahead, e.g.  calls from EVALQT, and call from BREAK on control-h INTERRUPT.")
+    (* ;; "NOCLEARFLG=T means CLEARBUF has already been done, and anything in the buffer now is type-ahead, e.g.  calls from EVALQT, and call from BREAK on control-h INTERRUPT.")
 
-    (* |;;| "NOTYPEFLG=T means user should not be typing ahead.  If READP is T, warn him to stop and wait.  Occurs when CLBUFS is being done BEFORE some action, e.g.  DWIM interaction, loading SYSBUF for EXEC commands, etc.  as opposed to AFTER some action, e.g.  an error occurred.")
+    (* ;; "NOTYPEFLG=T means user should not be typing ahead.  If READP is T, warn him to stop and wait.  Occurs when CLBUFS is being done BEFORE some action, e.g.  DWIM interaction, loading SYSBUF for EXEC commands, etc.  as opposed to AFTER some action, e.g.  an error occurred.")
 
     (PROG (LBUF SBUF)
           (COND
@@ -671,7 +668,7 @@
           (CLEARBUF T T)
           (SETQ READBUF BUF)
       SKIP
-          (SETQ CTRLUFLG NIL)                                (* \; 
+          (SETQ CTRLUFLG NIL)                                (* ; 
             "In case user control-e's or control-d's after typing control-u and changing his mind.")
           (SETQ LBUF (LINBUF T))
           (SETQ SBUF (SYSBUF T))
@@ -683,111 +680,111 @@
               (SETQ LBUF NIL)))
           (RETURN (COND
                      ((OR SBUF LBUF)
-                      (CONS LBUF SBUF)))))))
+                      (CONS LBUF SBUF])
 
 (DEFINE
-  (LAMBDA (X TYPE-IN)                                    (* |mpl| "15-Jul-85 11:22")
+  [LAMBDA (X TYPE-IN)                                    (* mpl "15-Jul-85 11:22")
     (MAPCAR X (FUNCTION (LAMBDA (X)
                           (COND
                              ((NLISTP X)
                               (ERROR '"incorrect defining form" X)))
                           (FNS.PUTDEF (CAR X)
                                  'FNS
-                                 (COND
+                                 [COND
                                     ((NULL (CDDR X))
                                      (CADR X))
-                                    (T (CONS 'LAMBDA (CDR X))))
-                                 (|if| TYPE-IN
-                                     |then| 'DEFINED
-                                   |else| 'LOAD)))))))
+                                    (T (CONS 'LAMBDA (CDR X]
+                                 (if TYPE-IN
+                                     then 'DEFINED
+                                   else 'LOAD])
 
 (FNS.PUTDEF
-  (LAMBDA (NAME TYPE DEFINITION REASON)                  (* \; "Edited 20-Nov-87 14:24 by woz")
+  [LAMBDA (NAME TYPE DEFINITION REASON)                  (* ; "Edited 20-Nov-87 14:24 by woz")
     (PROG NIL
-          (|if| (OR (AND DEFINITION (NLISTP DEFINITION))
-                        (NOT (FMEMB (CAR DEFINITION)
-                                    LAMBDASPLST)))
-              |then| (ERROR DEFINITION "Illegal function definition"))
+          (if (OR (AND DEFINITION (NLISTP DEFINITION))
+                      (NOT (FMEMB (CAR DEFINITION)
+                                  LAMBDASPLST)))
+              then (ERROR DEFINITION "Illegal function definition"))
           (SELECTQ DFNFLG
               ((NIL T) 
-                   (|if| (UNSAFE.TO.MODIFY NAME "redefine")
-                       |then| (ERROR NAME " not redefined" T)))
+                   (if (UNSAFE.TO.MODIFY NAME "redefine")
+                       then (ERROR NAME " not redefined" T)))
               NIL)
-          (|if| (EQ REASON 'DEFINED)
-              |then| 
+          (if (EQ REASON 'DEFINED)
+              then 
 
-                    (* |;;| "woz: i think this test is wrong; what about CHANGED?  SEdit special cases FNS in sedit::completion, and calls FIXEDITDATE directly, but shouldn't have to.")
+                    (* ;; "woz: i think this test is wrong; what about CHANGED?  SEdit special cases FNS in sedit::completion, and calls FIXEDITDATE directly, but shouldn't have to.")
 
                     (FIXEDITDATE DEFINITION))
           (IF (AND (HASDEF NAME 'FUNCTIONS)
                        (NEQ (CAR DEFINITION)
                             'NLAMBDA))
-              THEN                                       (* \; 
+              THEN                                       (* ; 
           "For a while, we can't prevent the use of both a DEFMACRO and NLAMBDA for the same name.")
                     (DELDEF NAME 'FUNCTIONS))
-          (COND
+          [COND
              ((OR (NULL DFNFLG)
                   (EQ DFNFLG T))
-              (COND
+              [COND
                  ((GETD NAME)
                   (VIRGINFN NAME T)
 
-                  (* |;;| "((EQUAL DEFINITION (GETD NAME)) (RETURN NAME)) Used to be part of the following COND.  ripped out because editing out of the function cell wasn't completing fully.")
+                  (* ;; "((EQUAL DEFINITION (GETD NAME)) (RETURN NAME)) Used to be part of the following COND.  ripped out because editing out of the function cell wasn't completing fully.")
 
                   (COND
                      ((NULL DFNFLG)
-                      (PROGN                                 (* \; 
+                      (PROGN                                 (* ; 
                                                        "if EXEC-FORMAT existed earlier, I'd use it")
                              (LISPXPRIN1 "New fns definition for " T)
                              (LISPXPRIN2 NAME T)
                              (LISPXPRIN1 ".
 " T))
-                      (SAVEDEF NAME)))))
+                      (SAVEDEF NAME]
               (COND
                  (ADDSPELLFLG (ADDSPELL NAME)))
               (UNDOABLY-SETF (CL:SYMBOL-FUNCTION NAME)
                      DEFINITION)
 
-              (* |;;| "Removed:  (REMPROP NAME 'EXPR)  because it wasn't saving the definition where UNSAVEDEF could find it.")
+              (* ;; "Removed:  (REMPROP NAME 'EXPR)  because it wasn't saving the definition where UNSAVEDEF could find it.")
 
               )
-             (T                                              (* \; 
+             (T                                              (* ; 
                        "DFNFLG is PROP or ALLPROP.  However, treat anything else the same as PROP.")
                 (AND ADDSPELLFLG (ADDSPELL NAME 0))
                 (CL:UNLESS (EQ DEFINITION (GETD NAME))
 
-                    (* |;;| "woz:  don't want to have an EXPR property if have the definition in the function cell, so be careful here.")
+                    (* ;; "woz:  don't want to have an EXPR property if have the definition in the function cell, so be careful here.")
 
-                    (CL:WHEN (AND (OR (NULL REASON)
+                    (CL:WHEN [AND (OR (NULL REASON)
                                       (EQ REASON 'CHANGED))
-                                  (EQ DEFINITION (GETPROP NAME 'EXPR)))
+                                  (EQ DEFINITION (GETPROP NAME 'EXPR]
 
-                        (* |;;| "editing a definition out of the saved EXPR property, and since DFNFLG is PROP, let the user know not installed")
+                        (* ;; "editing a definition out of the saved EXPR property, and since DFNFLG is PROP, let the user know not installed")
 
                         (LISPXPRIN1 "New fns definition for " T)
                         (LISPXPRIN2 NAME T)
                         (LISPXPRIN1 " (but not installed).
 " T))
-                    (/PUTPROP NAME 'EXPR DEFINITION))))
+                    (/PUTPROP NAME 'EXPR DEFINITION))]
           (COND
              (FILEPKGFLG (MARKASCHANGED NAME 'FNS REASON)))
-          (RETURN NAME))))
+          (RETURN NAME])
 
 (EQMEMB
-  (LAMBDA (X Y)                                              (* |lmm:| 17 APR 75 305)
+  [LAMBDA (X Y)                                              (* lmm%: 17 APR 75 305)
     (OR (EQ X Y)
         (AND (LISTP Y)
              (FMEMB X Y)
-             T))))
+             T])
 
 (EQUALN
-  (LAMBDA (X Y DEPTH)                                    (* |wt:| "12-JUN-80 10:57")
+  [LAMBDA (X Y DEPTH)                                    (* wt%: "12-JUN-80 10:57")
 
-    (* |;;| "like EQUAL but stops, returning T, if depth of car recursion plus depth of cdr recursion ever exceeds DEPTH.")
+    (* ;; "like EQUAL but stops, returning T, if depth of car recursion plus depth of cdr recursion ever exceeds DEPTH.")
 
     (COND
        ((EQ X Y))
-       ((NLISTP X)
+       [(NLISTP X)
         (COND
            ((NUMBERP X)
             (AND (NUMBERP Y)
@@ -795,22 +792,22 @@
            ((STRINGP X)
             (STREQUAL X Y))
            ((STACKP X)
-            (EQP X Y))))
+            (EQP X Y]
        ((NLISTP Y)
         NIL)
        ((AND DEPTH (ILESSP DEPTH 1))
         '?)
-       (T (SELECTQ (EQUALN (CAR X)
+       (T (SELECTQ [EQUALN (CAR X)
                           (CAR Y)
-                          (AND DEPTH (SETQ DEPTH (SUB1 DEPTH))))
+                          (AND DEPTH (SETQ DEPTH (SUB1 DEPTH]
               (? '?)
               (T (EQUALN (CDR X)
                         (CDR Y)
                         DEPTH))
-              NIL)))))
+              NIL])
 
 (FNCHECK
-  (LAMBDA (FN NOERRORFLG SPELLFLG PROPFLG TAIL)          (* |bvm:| "30-OCT-83 21:59")
+  [LAMBDA (FN NOERRORFLG SPELLFLG PROPFLG TAIL)          (* bvm%: "30-OCT-83 21:59")
     (PROG (X BLOCK BLOCK/FN)
       TOP (COND
              ((NOT (LITATOM FN))
@@ -821,28 +818,25 @@
                    (GO ERROR)))
              ((NULL DWIMFLG)
               (GO ERROR))
-             ((AND (CAR (NLSETQ (SETQ X (OR (MISSPELLED? FN 70 USERWORDS SPELLFLG TAIL
+             ((AND [CAR (NLSETQ (SETQ X (OR (MISSPELLED? FN 70 USERWORDS SPELLFLG TAIL
                                                    (FUNCTION GETD))
-                                            (MISSPELLED? FN 70 SPELLINGS2 SPELLFLG TAIL)))))
+                                            (MISSPELLED? FN 70 SPELLINGS2 SPELLFLG TAIL]
                    (NEQ X FN))
               (SETQ FN X)
               (GO TOP))
-             ((AND (EQ (SYSTEMTYPE)
+             ([AND (EQ (SYSTEMTYPE)
                        'D)
-                   (|for| FL |in| (WHEREIS FN)
-                      |thereis| (|for| FILE |inside| (OR (GETP FL 'FILEGROUP)
-                                                                     FL)
-                                       |thereis| (SETQ BLOCK (|find| B
-                                                                    |in| (FILECOMSLST
-                                                                              FILE
-                                                                              'BLOCKS)
-                                                                    |suchthat|
-                                                                    (AND (CAR X)
-                                                                         (MEMB FN BLOCK))))))
-                   (GETD (SETQ BLOCK/FN (PACK* '\\ (CAR BLOCK)
-                                               '/ FN))))
+                   [for FL in (WHEREIS FN)
+                      thereis (for FILE inside (OR (GETP FL 'FILEGROUP)
+                                                               FL)
+                                     thereis (SETQ BLOCK (find B
+                                                                in (FILECOMSLST FILE 'BLOCKS)
+                                                                suchthat (AND (CAR X)
+                                                                                  (MEMB FN BLOCK]
+                   (GETD (SETQ BLOCK/FN (PACK* '\ (CAR BLOCK)
+                                               '/ FN]
 
-              (* |;;| "In Interlisp-D, get actual name of internal block fn.  This is a little odd, since in a truly block-compiled system you couldn't get at the subfns")
+              (* ;; "In Interlisp-D, get actual name of internal block fn.  This is a little odd, since in a truly block-compiled system you couldn't get at the subfns")
 
               (SETQ FN BLOCK/FN))
              (T (GO ERROR)))
@@ -851,43 +845,43 @@
       ERROR
           (COND
              (NOERRORFLG (RETURN NIL)))
-          (SETQ FN (ERROR FN '"not a function" (NULL (RELSTK (OR (STKPOS 'LOAD)
-                                                                 (STKPOS 'LOADFROM))))))
-          (GO TOP))))
+          [SETQ FN (ERROR FN '"not a function" (NULL (RELSTK (OR (STKPOS 'LOAD)
+                                                                 (STKPOS 'LOADFROM]
+          (GO TOP])
 
 (FNTYP1
-  (LAMBDA (X)
+  [LAMBDA (X)
     (AND CLISPARRAY (SETQ X (GETHASH X CLISPARRAY))
-         (FNTYP X))))
+         (FNTYP X])
 
 (LCSKIP
-  (LAMBDA (FN FLG)                                       (* |bvm:| "24-Oct-86 17:09")
+  [LAMBDA (FN FLG)                                       (* bvm%: "24-Oct-86 17:09")
 
-    (* |;;| "Skip or copy FN, FLG T to copy")
+    (* ;; "Skip or copy FN, FLG T to copy")
 
     (PROG (LEN LA)
-          (|if| (EQ (PEEKCCODE)
-                        (CHARCODE SPACE))
-              |then| (COND
-                            ((EQ (SETQ LA (READ))
-                                 'BINARY)
-                             (RETURN (BINSKIP FN FLG NIL NIL LA)))
-                            ((SETQ LEN (GETPROP LA 'CODEREADER))
-                                                             (* \; 
+          [if (EQ (PEEKCCODE)
+                      (CHARCODE SPACE))
+              then (COND
+                          ((EQ (SETQ LA (READ))
+                               'BINARY)
+                           (RETURN (BINSKIP FN FLG NIL NIL LA)))
+                          ((SETQ LEN (GETPROP LA 'CODEREADER))
+                                                             (* ; 
                                                       "Peter's hook for interfacing byte compiler.")
-                             (RETURN (APPLY* (CDR LEN)
-                                            FN FLG NIL NIL LA)))))
-          (ERROR "Bad or incompatible compiled function" FN))))
+                           (RETURN (APPLY* (CDR LEN)
+                                          FN FLG NIL NIL LA]
+          (ERROR "Bad or incompatible compiled function" FN])
 
 (MAPRINT
-  (LAMBDA (LST FILE LEFT RIGHT SEP PFN LSPXPRNTFLG)          (* |wt:| 15-SEP-77 15 43)
+  [LAMBDA (LST FILE LEFT RIGHT SEP PFN LSPXPRNTFLG)          (* wt%: 15-SEP-77 15 43)
     (RESETVARS ((LISPXPRINTFLG LSPXPRNTFLG))
-               (COND
+               [COND
                   ((NULL PFN)
-                   (SETQ PFN (FUNCTION LISPXPRIN1))))
-               (COND
+                   (SETQ PFN (FUNCTION LISPXPRIN1]
+               [COND
                   ((NULL SEP)
-                   (SETQ SEP '\ )))
+                   (SETQ SEP '% ]
                (COND
                   (LEFT (LISPXPRIN1 LEFT FILE)))
                (COND
@@ -906,19 +900,19 @@
                (GO LP)
            EXIT
                (COND
-                  (RIGHT (LISPXPRIN1 RIGHT FILE))))))
+                  (RIGHT (LISPXPRIN1 RIGHT FILE])
 
 (MKLIST
-  (LAMBDA (X)                                                (* |lmm:| 21 AUG 75 428)
+  [LAMBDA (X)                                                (* lmm%: 21 AUG 75 428)
     (AND X (OR (LISTP X)
-               (LIST X)))))
+               (LIST X])
 
 (NAMEFIELD
-  (LAMBDA (FILE SUFFIXFLG DIRFLG)                        (* \; "Edited  5-Dec-90 22:32 by nm")
+  [LAMBDA (FILE SUFFIXFLG DIRFLG)                        (* ; "Edited  5-Dec-90 22:32 by nm")
 
-    (* |;;| "IF SUFFIXFLG is T, returns name and suffix field, otherwise just NAMEFIELD")
+    (* ;; "IF SUFFIXFLG is T, returns name and suffix field, otherwise just NAMEFIELD")
 
-    (LET ((STR (COND
+    (LET [(STR (COND
                   ((EQ DIRFLG 'ONLY)
                    (UNPACKFILENAME.STRING FILE 'DIRECTORY))
                   ((EQ SUFFIXFLG 'ONLY)
@@ -927,7 +921,7 @@
                         (NULL DIRFLG))
                    (UNPACKFILENAME.STRING FILE 'NAME))
                   (T 
-                     (* |;;| "The general case.  EXTENSION is fairly icky because UNPACKFILENAME.STRING behaves differently than UNPACKFILENAME, in that it returns a null string instead of NIL for extensionless files")
+                     (* ;; "The general case.  EXTENSION is fairly icky because UNPACKFILENAME.STRING behaves differently than UNPACKFILENAME, in that it returns a null string instead of NIL for extensionless files")
 
                      (PACKFILENAME.STRING 'DIRECTORY (AND DIRFLG (UNPACKFILENAME.STRING FILE
                                                                         'DIRECTORY))
@@ -937,92 +931,92 @@
                             (AND SUFFIXFLG (SETQ SUFFIXFLG (UNPACKFILENAME.STRING FILE 'EXTENSION))
                                  (> (NCHARS SUFFIXFLG)
                                     0)
-                                 SUFFIXFLG))))))
+                                 SUFFIXFLG]
 
-         (* |;;| "Should not assume the case insensitive file system")
+         (* ;; "Should not assume the case insensitive file system")
 
-(* \| "(if (NOT (U-CASEP STR)) then (SETQ STR (U-CASE STR)))")
+(* %| "(if (NOT (U-CASEP STR)) then (SETQ STR (U-CASE STR)))")
 
-         (MKATOM STR))))
+         (MKATOM STR])
 
 (NLIST
-  (LAMBDA N                                              (* |bvm:| "14-Feb-85 23:48")
+  [LAMBDA N                                              (* bvm%: "14-Feb-85 23:48")
     (PROG (V (I N))
-      LP  (COND
+      LP  [COND
              ((EQ I 0)
               (RETURN V))
              ((OR V (ARG N I))
               (SETQ V (CONS (ARG N I)
-                            V))))
+                            V]
           (SETQ I (SUB1 I))
-          (GO LP))))
+          (GO LP])
 
 (PRINTBELLS
-  (LAMBDA NIL                                                (* |wt:| 10-MAR-77 21 15)
-    (PRIN3 BELLS T)))
+  [LAMBDA NIL                                                (* wt%: 10-MAR-77 21 15)
+    (PRIN3 BELLS T])
 
 (PROMPTCHAR
-  (LAMBDA (ID FLG HISTORY)
-    (DECLARE (SPECVARS ID HISTORY PROMPTSTR))        (* |lmm| " 9-Jun-85 20:53")
+  [LAMBDA (ID FLG HISTORY)
+    (DECLARE (SPECVARS ID HISTORY PROMPTSTR))        (* lmm " 9-Jun-85 20:53")
 
-    (* |;;| "First checks READBUF, and strips off any leading pseudo-carriage rettursn, and computes the new readbuf for repeated operations.  If following this, READBUF is not NIL, never prints ID.  Otherwise prints ID if FLG is T, or if READP is NIL.  FLG is T for calls from EVALQT and BREAK, NIL from editor.")
+    (* ;; "First checks READBUF, and strips off any leading pseudo-carriage rettursn, and computes the new readbuf for repeated operations.  If following this, READBUF is not NIL, never prints ID.  Otherwise prints ID if FLG is T, or if READP is NIL.  FLG is T for calls from EVALQT and BREAK, NIL from editor.")
 
     (PROG (N MOD PROMPTSTR)
           (COND
              (FLG (AND READBUF (SETQ READBUF (LISPXREADBUF READBUF))
-                       (RETURN NIL))                         (* \; "redoing an event")
+                       (RETURN NIL))                         (* ; "redoing an event")
                   )
-             ((LISPXREADP)                                   (* \; 
+             ((LISPXREADP)                                   (* ; 
            "LISPXREADP returns T if there is anything on this line, but returns NIL if just a c.r.")
               (RETURN NIL)))
-          (COND
+          [COND
              ((AND HISTORY PROMPT#FLG)
               (SETQ PROMPTSTR (COND
                                  ((IGREATERP (SETQ N (ADD1 (CADR HISTORY)))
                                          (SETQ MOD (OR (CADDDR HISTORY)
-                                                       100)))(* \; 
+                                                       100)))(* ; 
                                                            "This event is the roll-over event.")
                                   (IDIFFERENCE N MOD))
-                                 (T N)))))
-          (COND
+                                 (T N]
+          [COND
              (PROMPTCHARFORMS 
 
-                    (* |;;| "gives user a hook for operations to be performed each event, e.g.  monitoring functions, checking if typescript window is up etc.  also these forms can change what is printed by resetting promptstr and / or id")
+                    (* ;; "gives user a hook for operations to be performed each event, e.g.  monitoring functions, checking if typescript window is up etc.  also these forms can change what is printed by resetting promptstr and / or id")
 
                     (MAPC PROMPTCHARFORMS (FUNCTION (LAMBDA (X)
-                                                      (ERSETQ (EVAL X)))))))
+                                                      (ERSETQ (EVAL X]
           (AND PROMPTSTR (PRIN2 PROMPTSTR T))
-          (AND ID (PRIN1 ID T)))))
+          (AND ID (PRIN1 ID T])
 
 (RAISEP
-  (LAMBDA (TTBL)                                             (* |wt:| 1-AUG-77 14 15)
+  [LAMBDA (TTBL)                                             (* wt%: 1-AUG-77 14 15)
 
-    (* |;;| "True if lisp is in mode where it raises lower case inputs to uppercase.")
+    (* ;; "True if lisp is in mode where it raises lower case inputs to uppercase.")
 
     (COND
        ((RAISE NIL TTBL)
         (RAISE T TTBL)
-        T))))
+        T])
 
 (READFILE
-  (CL:LAMBDA (FILE &OPTIONAL RDTBL (ENDTOKEN 'STOP)
+  [CL:LAMBDA (FILE &OPTIONAL RDTBL (ENDTOKEN 'STOP)
                    PACKAGE)
-         (DECLARE (GLOBALVARS LOADPARAMETERS))     (* \; "Edited 21-Jul-2021 21:05 by rmk:")
+         (DECLARE (GLOBALVARS LOADPARAMETERS))      (* ; "Edited 21-Jul-2021 21:05 by rmk:")
          (WITH-READER-ENVIRONMENT *OLD-INTERLISP-READ-ENVIRONMENT*
 
-             (* |;;| "The optional RDTBL and PACKAGE are set for the initial reading, but will be overridden by the DEFINE-FILE-INFO if present.  ")
+             (* ;; "The optional RDTBL and PACKAGE are set for the initial reading, but will be overridden by the DEFINE-FILE-INFO if present.  ")
 
              (CL:WHEN RDTBL
-                 (SETQ *READTABLE* (\\DTEST RDTBL 'READTABLEP)))
+                 (SETQ *READTABLE* (\DTEST RDTBL 'READTABLEP)))
              (CL:WHEN PACKAGE
-                 (SETQ *PACKAGE* (\\DTEST PACKAGE 'PACKAGE)))
+                 (SETQ *PACKAGE* (\DTEST PACKAGE 'PACKAGE)))
              (RESETLST
-                 (RESETSAVE NIL (LIST 'CLOSEF? (SETQ FILE (OPENSTREAM FILE 'INPUT NIL NIL 
-                                                                 LOADPARAMETERS))))
+                 [RESETSAVE NIL (LIST 'CLOSEF? (SETQ FILE (OPENSTREAM FILE 'INPUT NIL NIL 
+                                                                 LOADPARAMETERS]
                  (CL:MULTIPLE-VALUE-BIND (ENV FORM)
                         (READ-READER-ENVIRONMENT FILE NIL T)
 
-                        (* |;;| "If FORM, a DEFINE-FILE-INFO was read, and that should override the RDTBL and PACKAGE arguments. But it is a little dicy if the reason there is no form is because it is a CL file, the return value is  *COMMON-LISP-READ-ENVIRONMENT*.  In that case the original code allowed the the arguments to override the commonlisp values.  Who knows why.")
+                        (* ;; "If FORM, a DEFINE-FILE-INFO was read, and that should override the RDTBL and PACKAGE arguments. But it is a little dicy if the reason there is no form is because it is a CL file, the return value is  *COMMON-LISP-READ-ENVIRONMENT*.  In that case the original code allowed the the arguments to override the commonlisp values.  Who knows why.")
 
                         (SET-READER-ENVIRONMENT ENV FILE)
                         (CL:WHEN (EQ ENV *COMMON-LISP-READ-ENVIRONMENT*)
@@ -1031,17 +1025,17 @@
                         (LET ((EOFTOKEN "eof")
                               TEM HELPCLOCK)
                              (DECLARE (SPECVARS HELPCLOCK))
-                             (CL:VALUES (|until| (OR (EQ (SETQ TEM (CL:READ FILE NIL EOFTOKEN))
-                                                             EOFTOKEN)
-                                                         (EQ TEM ENDTOKEN)) |collect| TEM
-                                           |finally| (CL:WHEN FORM
-                                                             (* \; 
+                             (CL:VALUES (until (OR (EQ (SETQ TEM (CL:READ FILE NIL EOFTOKEN))
+                                                           EOFTOKEN)
+                                                       (EQ TEM ENDTOKEN)) collect TEM
+                                           finally (CL:WHEN FORM
+                                                             (* ; 
                                                            "Pack on the DEFINE-FILE-INFO form")
-                                                             (PUSH $$VAL FORM)))
-                                    ENV)))))))
+                                                           (PUSH $$VAL FORM)))
+                                    ENV)))))])
 
 (READLINE
-  (LAMBDA (RDTBL LINE LISPXFLG)                          (* AJB " 1-Aug-85 14:50")
+  [LAMBDA (RDTBL LINE LISPXFLG)                          (* AJB " 1-Aug-85 14:50")
     (DECLARE (SPECVARS LINE LISPXFLG SPACEFLG))
     (PROG ((FL T)
            TEM SPACEFLG CHRCODE START)
@@ -1051,49 +1045,49 @@
              ((NULL (READP T))
               (CLEARBUF T)
 
-              (* |;;| "This is in case there is a c.r. in the single character buffer.  Note that if there were other atoms on the line terminated by a c.r., after readline finished, the c.r. would be gone.  Thus this check for consistency.")
+              (* ;; "This is in case there is a c.r. in the single character buffer.  Note that if there were other atoms on the line terminated by a c.r., after readline finished, the c.r. would be gone.  Thus this check for consistency.")
 
               (RETURN LINE)))
       LP  (SETQ SPACEFLG NIL)
       LP1 (COND
-             ((SYNTAXP (SETQ CHRCODE (CHCON1 (SETQ TEM (PEEKC FL (OR RDTBL T)))))
-                     'EOL)                                   (* \; "C.R.")
+             [(SYNTAXP [SETQ CHRCODE (CHCON1 (SETQ TEM (PEEKC FL (OR RDTBL T]
+                     'EOL)                                   (* ; "C.R.")
               (READC FL)
               (COND
                  ((AND LINE SPACEFLG)
                   (AND (EQ FL T)
                        (PRIN1 '|...| T))
                   (GO LP))
-                 (T (GO OUT))))
+                 (T (GO OUT]
              ((OR (SYNTAXP CHRCODE 'RIGHTPAREN RDTBL)
                   (SYNTAXP CHRCODE 'RIGHTBRACKET RDTBL))
               (READ FL RDTBL)
               (AND LISPXFLG (NULL (CDR LINE))
                    (SETQ LINE (NCONC1 LINE NIL)))
 
-              (* |;;| "The `]' is treated as NIL if it is the only thing on the line when READLINE is called with LISPXFLG=T.  The reason for CDR is that LISPX calls readline giving it the initial atom on the line.")
+              (* ;; "The `]' is treated as NIL if it is the only thing on the line when READLINE is called with LISPXFLG=T.  The reason for CDR is that LISPX calls readline giving it the initial atom on the line.")
 
               (GO OUT))
              ((AND (EQ CHRCODE (CHARCODE SPACE))
-                   (SYNTAXP CHRCODE 'SEPR RDTBL))            (* \; 
+                   (SYNTAXP CHRCODE 'SEPR RDTBL))            (* ; 
                                  "SPACE the syntaxp check is to allow for space being a read macro")
               (SETQ SPACEFLG T)
               (READC FL)
               (GO LP1)))
-          (SETQ TEM (COND
+          [SETQ TEM (COND
                        ((OR (EQ LISPXREADFN 'READ)
-                            (IMAGESTREAMTYPEP T 'TEXT))      (* \; 
+                            (IMAGESTREAMTYPEP T 'TEXT))      (* ; 
                                        "So the call will be linked, so the user can break on read.")
-                                                             (* \; "TEXTSTREAMS must use READ")
+                                                             (* ; "TEXTSTREAMS must use READ")
                         (READ FL RDTBL))
-                       (T (APPLY* LISPXREADFN FL RDTBL))))
+                       (T (APPLY* LISPXREADFN FL RDTBL]
 
-     (* |;;| "The reason for not embedding the setq in the ncon1 is that the act of reading may change L, e.g.  via a ^W read macro.")
+     (* ;; "The reason for not embedding the setq in the ncon1 is that the act of reading may change L, e.g.  via a ^W read macro.")
 
           (COND
              ((EQ TEM HISTSTR4)
 
-              (* |;;| "fo implemeing read macros that are for effect only.  ignore the value returned by read.  if we had soft interrupts from iowaits, we wouldnt needs this.")
+              (* ;; "fo implemeing read macros that are for effect only.  ignore the value returned by read.  if we had soft interrupts from iowaits, we wouldnt needs this.")
 
               (GO LP1)))
           (SETQ LINE (NCONC1 LINE TEM))
@@ -1101,7 +1095,7 @@
              ((SYNTAXP (SETQ TEM (CHCON1 (LASTC FL)))
                      'RIGHTBRACKET RDTBL)
 
-              (* |;;| "The reason why readline is driven by the last character insead of doing a peekc before reding is that due to eadmacros, it is possible for several things to be read, e.g.  A B C '(FOO) terminated by square bracket should terminate the line.  However, it is not sufficient just to check whether the value read is a list or not since `()' and NIL must also be treated differently.")
+              (* ;; "The reason why readline is driven by the last character insead of doing a peekc before reding is that due to eadmacros, it is possible for several things to be read, e.g.  A B C '(FOO) terminated by square bracket should terminate the line.  However, it is not sufficient just to check whether the value read is a list or not since `()' and NIL must also be treated differently.")
 
               (GO OUT))
              ((NULL (SYNTAXP TEM 'RIGHTPAREN RDTBL))
@@ -1109,29 +1103,29 @@
              ((AND LISPXFLG (NULL SPACEFLG)
                    (NULL (CDDR LINE)))
 
-              (* |;;| "A list terminates the line if if called from LISPX and is both the firt thing on a line and not preceded by a space.")
+              (* ;; "A list terminates the line if if called from LISPX and is both the firt thing on a line and not preceded by a space.")
 
               (GO OUT))
              (T (AND (EQ FL T)
                      (PRIN1 '|...| T))
                 (GO LP)))
           (GO LP)
-      OUT (COND
+      OUT [COND
              ((AND (LISTP LINE)
-                   CTRLUFLG)                                 (* \; 
+                   CTRLUFLG)                                 (* ; 
                                                            "User typed control-u during reading.")
               (SETQ CTRLUFLG NIL)
               (COND
-                 ((NULL (NLSETQ (EDITE LINE)))               (* \; "Exited with a STOP.")
-                  (SETQ REREADFLG 'ABORT)))))
+                 ((NULL (NLSETQ (EDITE LINE)))               (* ; "Exited with a STOP.")
+                  (SETQ REREADFLG 'ABORT]
           (COND
-             (START (COND
+             (START [COND
                        ((NEQ START (CADADR READBUF))
                         (SHOULDNT))
-                       (T                                    (* \; 
+                       (T                                    (* ; 
                                                            "the rplaca is to handle small numbers")
                           (RPLACA (CDADR READBUF)
-                                 (SETN START (GETFILEPTR FL)))))
+                                 (SETN START (GETFILEPTR FL]
                     (SETFILEPTR FL -1)))
           (RETURN LINE)
       LP2 (COND
@@ -1141,7 +1135,7 @@
               (RETURN LINE))
              ((NULL (SETQ READBUF (LISPXREADBUF READBUF)))
 
-              (* |;;| "checks for things like HISTSTR2 etc.  this can occur if you redo an event contaiing a readline.  can also occur under a break if you call a function which calls readline, because break unreads stuff, leaving the `from event' tag on.")
+              (* ;; "checks for things like HISTSTR2 etc.  this can occur if you redo an event contaiing a readline.  can also occur under a break if you call a function which calls readline, because break unreads stuff, leaving the `from event' tag on.")
 
               (GO TOP)))
           (SETQ TEM READBUF)
@@ -1150,16 +1144,16 @@
           (COND
              ((NULL READBUF)
 
-              (* |;;| "really shouldnt happen, as there should be a `<c.r.>' marker.  however, in the case of a fix command, user might delete it.")
+              (* ;; "really shouldnt happen, as there should be a `<c.r.>' marker.  however, in the case of a fix command, user might delete it.")
 
               (RETURN LINE)))
-          (GO LP2))))
+          (GO LP2])
 
 (REMPROPLIST
-  (LAMBDA (ATM PROPS)                                        (* \; "wt: 30-JUL-77 13 32")
+  [LAMBDA (ATM PROPS)                                        (* ; "wt: 30-JUL-77 13 32")
     (PROG (LST LST1 TEM)
           (COND
-             ((NULL (SETQ LST1 (SETQ LST (GETPROPLIST ATM))))
+             ([NULL (SETQ LST1 (SETQ LST (GETPROPLIST ATM]
               (RETURN NIL)))
       LP  (COND
              ((NLISTP LST1)
@@ -1171,28 +1165,28 @@
              ((SETQ TEM (CDDR LST1))
               (RPLNODE2 LST1 TEM)
               (GO LP))
-             (T                                              (* \; 
+             (T                                              (* ; 
                                                        "the last property, also not the first one.")
                 (RPLACD (NLEFT LST 1 LST1))
                 (GO OUT)))
           (SETQ LST1 (CDDR LST1))
           (GO LP)
       OUT (SETPROPLIST ATM LST)
-          (RETURN))))
+          (RETURN])
 
 (RESETBUFS
-  (NLAMBDA FORMS                                         (* |lmm| " 9-APR-78 00:27")
+  [NLAMBDA FORMS                                         (* lmm " 9-APR-78 00:27")
     (DECLARE (LOCALVARS . T))
-    (PROG (($$BUFS (PROGN (LINBUF)
+    (PROG [($$BUFS (PROGN (LINBUF)
                           (SYSBUF)
-                          (CLBUFS NIL T READBUF))))
+                          (CLBUFS NIL T READBUF]
           (RETURN (PROG1 (APPLY (FUNCTION PROGN)
                                 FORMS
                                 'INTERNAL)
-                      (AND $$BUFS (BKBUFS $$BUFS)))))))
+                      (AND $$BUFS (BKBUFS $$BUFS)))])
 
 (TAB
-  (LAMBDA (POS MINSPACES FILE)
+  [LAMBDA (POS MINSPACES FILE)
     (PROG (X)
           (COND
              ((NOT (IGREATERP (IPLUS (SETQ X (POSITION FILE))
@@ -1201,23 +1195,23 @@
                           POS))
               (SPACES (IDIFFERENCE POS X)
                      FILE))
-             ((EQ MINSPACES T)                               (* \; 
+             ((EQ MINSPACES T)                               (* ; 
                             "MINSPACES=T means space over to POS unless you are already beyond it.")
               )
              (T (TERPRI FILE)
-                (SPACES POS FILE))))))
+                (SPACES POS FILE])
 
 (UNSAVED1
-  (LAMBDA (FN TYP)                                       (* |bvm:| "29-Sep-86 23:24")
+  [LAMBDA (FN TYP)                                       (* bvm%: "29-Sep-86 23:24")
     (PROG (DEF PROP)
       TOP (COND
              ((NOT (LITATOM FN)))
-             ((SETQ DEF (COND
+             ([SETQ DEF (COND
                            ((SETQ PROP TYP)
                             (GET FN TYP))
-                           ((GET FN (SETQ PROP 'EXPR)))
-                           ((GET FN (SETQ PROP 'CODE)))
-                           ((GET FN (SETQ PROP 'SUBR)))))
+                           [(GET FN (SETQ PROP 'EXPR]
+                           [(GET FN (SETQ PROP 'CODE]
+                           ((GET FN (SETQ PROP 'SUBR]
               (VIRGINFN FN T)
               (/REMPROP FN PROP)
               (COND
@@ -1226,20 +1220,20 @@
               (/PUTD FN DEF T)
               (AND ADDSPELLFLG (ADDSPELL FN))
               (RETURN PROP))
-             ((OR (GETD FN)
-                  (GETPROPLIST FN))                          (* \; "Not a misspelling")
+             [(OR (GETD FN)
+                  (GETPROPLIST FN))                          (* ; "Not a misspelling")
               (RETURN (COND
                          (TYP (CONCAT "(" TYP " not found)"))
-                         (T "(nothing found)"))))
+                         (T "(nothing found)"]
              ((SETQ PROP (FNCHECK FN T))
               (SETQ FN PROP)
               (GO TOP)))
-          (ERROR FN '"not a function"))))
+          (ERROR FN '"not a function"])
 
 (WRITEFILE
-  (LAMBDA (X FILE)                                       (* |bvm:| "30-Aug-86 16:45")
+  [LAMBDA (X FILE)                                      (* ; "Edited  5-Aug-2021 20:58 by rmk:")
 
-    (* |;;| "X is a list of expression (or an atom that evaluates to a list) X is written on FILE.  If X begins with a PRINTDATE expression, a new one is written.  Following the PRETTYDEF conventions, if FILE is listed, it is left open.  Otherwise a stop is printed and it is closed.")
+    (* ;; "X is a list of expression (or an atom that evaluates to a list) X is written on FILE.  If X begins with a PRINTDATE expression, a new one is written.  Following the PRETTYDEF conventions, if FILE is listed, it is left open.  Otherwise a stop is printed and it is closed.")
 
     (WITH-READER-ENVIRONMENT *OLD-INTERLISP-READ-ENVIRONMENT*
         (RESETLST
@@ -1248,14 +1242,15 @@
                      ((LISTP FILE)
                       (SETQ FILE (CAR FILE))
                       (SETQ OPENED T)))
-                  (RESETSAVE NIL (LIST (FUNCTION CLOSE-AND-MAYBE-DELETE)
-                                       (SETQ STREAM (OPENSTREAM FILE 'OUTPUT))))
+                  [RESETSAVE NIL (LIST (FUNCTION CLOSE-AND-MAYBE-DELETE)
+                                       (SETQ STREAM (OPENSTREAM FILE 'OUTPUT]
                   (RESETSAVE (OUTPUT STREAM))
-                  (COND
+                  (\EXTERNALFORMAT STREAM *OLD-INTERLISP-READ-ENVIRONMENT*)
+                  [COND
                      ((ATOM X)
-                      (SETQ X (EVAL X))))
-                  (PRIN1 "
-(PRIN1 (QUOTE \"
+                      (SETQ X (EVAL X]
+                  (TERPRI)
+                  (PRIN1 "(PRIN1 (QUOTE %"
 WRITEFILE OF ")
                   (PRIN2 (SETQ FILE (FULLNAME STREAM)))
                   (PRIN1 " MADE BY ")
@@ -1263,36 +1258,36 @@ WRITEFILE OF ")
                   (PRIN1 " ON ")
                   (PRIN1 (DATE))
                   (PRIN1 "
-\")T)
-
-")
-                  (|for| X1 |in| X |do| (PRINTDEF X1 NIL (EQ (CAR (LISTP X1))
-                                                                         'DEFINEQ))
-                                                 (TERPRI))
-                  (|if| (NULL OPENED)
-                      |then| (ENDFILE))
-                  (RETURN FILE))))))
+%")T)")
+                  (TERPRI)
+                  (TERPRI)
+                  (for X1 in X do (PRINTDEF X1 NIL (EQ (CAR (LISTP X1))
+                                                                   'DEFINEQ))
+                                             (TERPRI))
+                  (if (NULL OPENED)
+                      then (ENDFILE))
+                  (RETURN FILE))))])
 
 (CLOSE-AND-MAYBE-DELETE
-  (LAMBDA (STREAM)                                       (* \; "Edited 19-Mar-87 16:43 by jrb:")
+  [LAMBDA (STREAM)                                       (* ; "Edited 19-Mar-87 16:43 by jrb:")
 
-(* |;;;| "For use in RESETSAVE.  Closes STREAM, and if happened under error, deletes the file")
+(* ;;; "For use in RESETSAVE.  Closes STREAM, and if happened under error, deletes the file")
 
-    (|if| (OPENP STREAM)
-        |then| (SETQ STREAM (CLOSEF STREAM)))
-    (AND RESETSTATE (DELFILE STREAM))))
+    (if (OPENP STREAM)
+        then (SETQ STREAM (CLOSEF STREAM)))
+    (AND RESETSTATE (DELFILE STREAM])
 
 (UNSAFE.TO.MODIFY
-  (LAMBDA (FN OPTION)                                    (* |lmm| "31-Jul-85 02:06")
-    (|if| (FMEMB FN UNSAFE.TO.MODIFY.FNS)
-        |then| (PRINTOUT T "Warning: " FN " may be unsafe to " (OR OPTION "modify")
-                          " -- continue? ")
-              (|if| (EQ (|if| (GETD 'ASKUSER)
-                                |then| (ASKUSER DWIMWAIT 'N)
-                              |else| (READ T))
-                            'Y)
-                  |then| NIL
-                |else| T))))
+  [LAMBDA (FN OPTION)                                    (* lmm "31-Jul-85 02:06")
+    (if (FMEMB FN UNSAFE.TO.MODIFY.FNS)
+        then (PRINTOUT T "Warning: " FN " may be unsafe to " (OR OPTION "modify")
+                        " -- continue? ")
+              (if (EQ (if (GETD 'ASKUSER)
+                              then (ASKUSER DWIMWAIT 'N)
+                            else (READ T))
+                          'Y)
+                  then NIL
+                else T])
 )
 
 (RPAQQ UNSAFE.TO.MODIFY.FNS
@@ -1321,63 +1316,63 @@ WRITEFILE OF ")
 
 
 
-(* \; "FILEDATE, for finding out the creation date of source files, from the compiled files.")
+(* ; "FILEDATE, for finding out the creation date of source files, from the compiled files.")
 
 
 
 
-(* |;;| 
+(* ;; 
 "FASL isn't loaded when MACHINEINDEPENDENT is, so we have to fake the FASL checker for now.  It's defined in FASLOAD."
 )
 
 (DEFINEQ
 
 (FILEDATE
-  (LAMBDA (FILE CFLG)                                    (* \; "Edited 17-Feb-89 11:26 by jds")
-                                                             (* \; "CFLG IS T FOR COMPILED FILES")
+  [LAMBDA (FILE CFLG)                                    (* ; "Edited 17-Feb-89 11:26 by jds")
+                                                             (* ; "CFLG IS T FOR COMPILED FILES")
     (COND
        (FILE (CAR (NLSETQ (RESETLST
                               (PROG (STREAM OLDPTR VALUE)
-                                    (COND
+                                    [COND
                                        ((SETQ STREAM (OPENP FILE 'INPUT))
                                         (SETQ OLDPTR (GETFILEPTR STREAM)))
-                                       (T                    (* \; 
+                                       (T                    (* ; 
                                 "OPENSTREAM used instead of INFILEP to allow for error correction.")
                                           (RESETSAVE NIL (LIST 'CLOSEF (SETQ STREAM
-                                                                        (OPENSTREAM FILE 'INPUT))))))
+                                                                        (OPENSTREAM FILE 'INPUT]
 
-                               (* |;;| "This code used to have some gross kludgery for checking file dates of grouped files during the loadup procedure, now gone -bvm")
+                               (* ;; "This code used to have some gross kludgery for checking file dates of grouped files during the loadup procedure, now gone -bvm")
 
-                                    (COND
+                                    [COND
                                        ((RANDACCESSP STREAM)
                                         (SETFILEPTR STREAM 0)
                                         (COND
                                            ((SETQ VALUE (FASL-FILEDATE STREAM CFLG))
 
-                                            (* |;;| " Aha, a Dfasl file")
+                                            (* ;; " Aha, a Dfasl file")
 
-                                            (* |;;| 
+                                            (* ;; 
         " Having decided it's a DFASL, FASL-FILEDATE returned the date, and it's in VALUE already.")
 
                                             )
-                                           (T                (* \; "Any other filetype")
+                                           (T                (* ; "Any other filetype")
                                               (SETFILEPTR STREAM 0)
                                               (CL:MULTIPLE-VALUE-BIND
                                                (ENV FORM)
-                                               (\\PARSE-FILE-HEADER STREAM 'RETURN)
-                                               (COND
+                                               (\PARSE-FILE-HEADER STREAM 'RETURN)
+                                               [COND
                                                   ((AND CFLG (LISTP FORM))
-                                                             (* \; 
+                                                             (* ; 
                                     "First expression is for compiled file, next one is its source")
                                                    (SETQ FORM (WITH-READER-ENVIRONMENT ENV
-                                                                     (READ STREAM)))))
+                                                                     (READ STREAM]
                                                (COND
                                                   ((EQ (CAR (LISTP FORM))
                                                        'FILECREATED)
-                                                   (SETQ VALUE (CAR (LISTP (CDR FORM)))))))))))
+                                                   (SETQ VALUE (CAR (LISTP (CDR FORM]
                                     (COND
                                        (OLDPTR (SETFILEPTR STREAM OLDPTR)))
-                                    (RETURN VALUE)))))))))
+                                    (RETURN VALUE)))])
 )
 
 (MOVD? 'NILL 'FASL-FILEDATE)
@@ -1386,67 +1381,67 @@ WRITEFILE OF ")
 
 
 
-(* \; "used in FNS.PUTDEF before CMLUNDO loaded")
+(* ; "used in FNS.PUTDEF before CMLUNDO loaded")
 
 
 
 
-(* \; "Functions for retrieving and remembering FILEMAPs and file reader environments")
+(* ; "Functions for retrieving and remembering FILEMAPs and file reader environments")
 
 (DEFINEQ
 
 (FILEMAP
-  (NLAMBDA (FILEMAP)                                 (* |bvm:| "27-Aug-86 23:41")
+  [NLAMBDA (FILEMAP)                                 (* bvm%: "27-Aug-86 23:41")
 
-(* |;;;| "Called by the FILEMAP expression at the end of every standard Interlisp file")
+(* ;;; "Called by the FILEMAP expression at the end of every standard Interlisp file")
 
-    (DECLARE (USEDFREE FILECREATEDLST))                  (* \; 
+    (DECLARE (USEDFREE FILECREATEDLST))                  (* ; 
                                    "FILECREATEDLST bound in LOAD or LOADFNS and set by FILECREATED")
     (PUTFILEMAP (FULLNAME (GETSTREAM NIL 'INPUT))
-           FILEMAP FILECREATEDLST NIL T)))
+           FILEMAP FILECREATEDLST NIL T])
 
-(\\PARSE-FILE-HEADER
-  (LAMBDA (STREAM FILECREATEDFN RETURNFORM INITIALENV) (* \; "Edited 17-Jul-2021 21:26 by rmk:")
+(\PARSE-FILE-HEADER
+  [LAMBDA (STREAM FILECREATEDFN RETURNFORM INITIALENV)  (* ; "Edited 17-Jul-2021 21:26 by rmk:")
 
-(* |;;;| "Parses the stuff at front of STREAM, which is assumed positioned at zero, and returns as its first value a reader environment for the file, or NIL if this is not a Lisp source file.")
+(* ;;; "Parses the stuff at front of STREAM, which is assumed positioned at zero, and returns as its first value a reader environment for the file, or NIL if this is not a Lisp source file.")
 
-(* |;;;| "")
+(* ;;; "")
 
-(* |;;;| "The header information that it processes consists of an optional DEFINE-FILE-INFO expression followed by a single FILECREATED expression.  That is, if there are 2 filecreated expressions, as for compiled files, it only gets the first one.")
+(* ;;; "The header information that it processes consists of an optional DEFINE-FILE-INFO expression followed by a single FILECREATED expression.  That is, if there are 2 filecreated expressions, as for compiled files, it only gets the first one.")
 
-(* |;;;| "")
+(* ;;; "")
 
-(* |;;;| "If a FILECREATED expression is found, then calls FILECREATEDFN with the file pointer positioned immediately after the symbol FILECREATED, and returns the fn's value as its second value.")
+(* ;;; "If a FILECREATED expression is found, then calls FILECREATEDFN with the file pointer positioned immediately after the symbol FILECREATED, and returns the fn's value as its second value.")
 
-(* |;;;| "FILECREATEDFN = RETURN returns the entire FILECREATED expression.")
+(* ;;; "FILECREATEDFN = RETURN returns the entire FILECREATED expression.")
 
-(* |;;;| "Finally, in the case where no FILECREATED expression was found, returns as second value the actual first expression if RETURNFORM is true (this is needed for callers that don't want to lose when the stream is non-randaccess).")
+(* ;;; "Finally, in the case where no FILECREATED expression was found, returns as second value the actual first expression if RETURNFORM is true (this is needed for callers that don't want to lose when the stream is non-randaccess).")
 
-(* |;;;| "The first expression on the file is read in the current reader environment.  Usually this wants to be IL.")
+(* ;;; "The first expression on the file is read in the current reader environment.  Usually this wants to be IL.")
 
     (CL:UNLESS INITIALENV (SETQ INITIALENV *OLD-INTERLISP-READ-ENVIRONMENT*))
     (WITH-READER-ENVIRONMENT INITIALENV
         (SELCHARQ (SKIPSEPRCODES STREAM)
-             (";"                                            (* \; "Assume it's common lisp file")
+             (";"                                            (* ; "Assume it's common lisp file")
                   *COMMON-LISP-READ-ENVIRONMENT*)
-             ("("                                            (* \; 
+             ("("                                            (* ; 
                         "Start of Lisp expression, could be either DEFINE-FILE-INFO or FILECREATED")
                   (LET (ENV FIRSTSYM RESULT HERE)
-                       (SETQ HERE (GETFILEPTR STREAM))       (* \; 
+                       (SETQ HERE (GETFILEPTR STREAM))       (* ; 
                          "HERE is before the next expression, in case the caller wants to back out")
                        (SETQ ENV (READ-READER-ENVIRONMENT STREAM INITIALENV))
                        (SETQ HERE (GETFILEPTR STREAM))
                        (SET-READER-ENVIRONMENT ENV STREAM)
 
-                       (* |;;| "After the optional DEFINE-INFO, do we see FILECREATED?")
+                       (* ;; "After the optional DEFINE-INFO, do we see FILECREATED?")
 
-                       (SETQ RESULT (IF (AND FILECREATEDFN (EQ (SKIPSEPRCODES STREAM)
+                       [SETQ RESULT (IF [AND FILECREATEDFN (EQ (SKIPSEPRCODES STREAM)
                                                                    (CHARCODE "("))
                                                  (PROGN (READCCODE STREAM)
                                                         (AND (SYNTAXP (SKIPSEPRCODES STREAM)
                                                                     'OTHER)
                                                              (EQ 'FILECREATED (SETQ FIRSTSYM
-                                                                               (RATOM STREAM))))))
+                                                                               (RATOM STREAM]
                                         THEN (IF (EQ 'RETURN FILECREATEDFN)
                                                      THEN (CONS 'FILECREATED (
                                                                                CL:READ-DELIMITED-LIST
@@ -1456,14 +1451,14 @@ WRITEFILE OF ")
                                       ELSEIF RETURNFORM
                                         THEN (CONS FIRSTSYM (CL:READ-DELIMITED-LIST (CHARCODE
                                                                                          ")")
-                                                                       STREAM))))
+                                                                       STREAM]
                        (CL:VALUES ENV RESULT HERE)))
-             NIL))))
+             NIL))])
 
 (GET-ENVIRONMENT-AND-FILEMAP
-  (LAMBDA (STREAM DONTCACHE)                             (* |bvm:| "26-Sep-86 11:39")
+  [LAMBDA (STREAM DONTCACHE)                             (* bvm%: "26-Sep-86 11:39")
 
-    (* |;;| "Returns three values: the stream's reader environment, its filemap, either obtained from the file itself, or from its property list, and the byte location where the FILECREATED expression starts.")
+    (* ;; "Returns three values: the stream's reader environment, its filemap, either obtained from the file itself, or from its property list, and the byte location where the FILECREATED expression starts.")
 
     (LET ((FULL (COND
                    ((STREAMP STREAM)
@@ -1472,48 +1467,47 @@ WRITEFILE OF ")
           MAPENTRY MAP ENV OLDPOS)
          (SETQ MAPENTRY (GETHASH FULL *FILEMAP-HASH*))
          (COND
-            ((AND MAPENTRY (OR (SETQ MAP (|fetch| FMFILEMAP |of| MAPENTRY))
+            ((AND MAPENTRY (OR (SETQ MAP (fetch FMFILEMAP of MAPENTRY))
                                (NULL USEMAPFLG)))
 
-             (* |;;| "Have all we need.  Return the map only if USEMAPFLG is true or the map was obtained by scanning the file")
+             (* ;; "Have all we need.  Return the map only if USEMAPFLG is true or the map was obtained by scanning the file")
 
-             (|replace| FMRECENT? |of| MAPENTRY |with| T)
-             (CL:VALUES (|fetch| FMENVIRONMENT |of| MAPENTRY)
-                    (AND MAP (OR USEMAPFLG (NOT (|fetch| FMFROMFILE? |of| MAPENTRY)))
+             (replace FMRECENT? of MAPENTRY with T)
+             (CL:VALUES (fetch FMENVIRONMENT of MAPENTRY)
+                    (AND MAP (OR USEMAPFLG (NOT (fetch FMFROMFILE? of MAPENTRY)))
                          MAP)
-                    (|fetch| FMFILECREATEDLOC |of| MAPENTRY)
-                    (|fetch| FMFILECREATEDLST |of| MAPENTRY)))
-            ((OR (NOT (SETQ STREAM (OPENP STREAM 'INPUT)))
-                 (NOT (RANDACCESSP STREAM)))                 (* \; "Out of luck")
+                    (fetch FMFILECREATEDLOC of MAPENTRY)
+                    (fetch FMFILECREATEDLST of MAPENTRY)))
+            ((OR [NOT (SETQ STREAM (OPENP STREAM 'INPUT]
+                 (NOT (RANDACCESSP STREAM)))                 (* ; "Out of luck")
              NIL)
-            (T                                               (* \; "Have to read file")
+            (T                                               (* ; "Have to read file")
                (SETQ OLDPOS (GETFILEPTR STREAM))
                (SETFILEPTR STREAM 0)
                (CL:MULTIPLE-VALUE-BIND (ENV NEWMAP FCLOCATION)
-                      (\\PARSE-FILE-HEADER STREAM (COND
-                                                         ((AND (NULL MAP)
-                                                               USEMAPFLG)
-                                                          (FUNCTION GET-FILEMAP-FROM-FILECREATED))))
+                      [\PARSE-FILE-HEADER STREAM (COND
+                                                        ((AND (NULL MAP)
+                                                              USEMAPFLG)
+                                                         (FUNCTION GET-FILEMAP-FROM-FILECREATED]
                       (SETFILEPTR STREAM OLDPOS)
                       (COND
                          ((AND NEWMAP (NOT DONTCACHE))
                           (PUTFILEMAP FULL NEWMAP NIL ENV T FCLOCATION)))
                       (CL:VALUES ENV (OR NEWMAP MAP)
-                             FCLOCATION)))))))
+                             FCLOCATION])
 
 (LOOKUP-ENVIRONMENT-AND-FILEMAP
-  (LAMBDA (FULL ROOTNAMEP)                               (* \; "Edited  4-May-88 15:30 by bvm")
+  [LAMBDA (FULL ROOTNAMEP)                               (* ; "Edited  4-May-88 15:30 by bvm")
 
-    (* |;;| "Returns four values: the file's reader environment, its filemap, either obtained from the file itself, or from its property list, the byte location where the FILECREATED expression starts, and the FILECREATEDLST of the file (used by ADDFILE).  Unlike GET-ENVIRONMENT-AND-FILEMAP, this function merely looks up cached info. If ROOTNAMEP is true, then FULLNAME is actually a root name, and we want to look up the most recent.")
+    (* ;; "Returns four values: the file's reader environment, its filemap, either obtained from the file itself, or from its property list, the byte location where the FILECREATED expression starts, and the FILECREATEDLST of the file (used by ADDFILE).  Unlike GET-ENVIRONMENT-AND-FILEMAP, this function merely looks up cached info. If ROOTNAMEP is true, then FULLNAME is actually a root name, and we want to look up the most recent.")
 
     (LET ((HIGHEST-VERSION -1)
           MAPENTRY)
-         (|if| ROOTNAMEP
-             |then| (MAPHASH *FILEMAP-HASH*
-                               (FUNCTION (LAMBDA (ENTRY KEY)
-                                           (LET
-                                            (V)
-                                            (|if| (AND (STRPOS FULL KEY NIL NIL NIL NIL 
+         (if ROOTNAMEP
+             then [MAPHASH *FILEMAP-HASH*
+                             (FUNCTION (LAMBDA (ENTRY KEY)
+                                         (LET (V)
+                                              (if (AND (STRPOS FULL KEY NIL NIL NIL NIL 
                                                                   UPPERCASEARRAY)
                                                            (STRING-EQUAL FULL (ROOTFILENAME KEY))
                                                            (IGREATERP (SETQ V
@@ -1522,20 +1516,20 @@ WRITEFILE OF ")
                                                                             'VERSION)
                                                                            0))
                                                                   HIGHEST-VERSION))
-                                                |then| (SETQ MAPENTRY ENTRY)
-                                                      (SETQ HIGHEST-VERSION V))))))
-           |else| (SETQ MAPENTRY (GETHASH FULL *FILEMAP-HASH*)))
-         (|if| MAPENTRY
-             |then| (|replace| FMRECENT? |of| MAPENTRY |with| T)
-                   (CL:VALUES (|fetch| FMENVIRONMENT |of| MAPENTRY)
-                          (|fetch| FMFILEMAP |of| MAPENTRY)
-                          (|fetch| FMFILECREATEDLOC |of| MAPENTRY)
-                          (|fetch| FMFILECREATEDLST |of| MAPENTRY))))))
+                                                  then (SETQ MAPENTRY ENTRY)
+                                                        (SETQ HIGHEST-VERSION V]
+           else (SETQ MAPENTRY (GETHASH FULL *FILEMAP-HASH*)))
+         (if MAPENTRY
+             then (replace FMRECENT? of MAPENTRY with T)
+                   (CL:VALUES (fetch FMENVIRONMENT of MAPENTRY)
+                          (fetch FMFILEMAP of MAPENTRY)
+                          (fetch FMFILECREATEDLOC of MAPENTRY)
+                          (fetch FMFILECREATEDLST of MAPENTRY])
 
 (GET-FILEMAP-FROM-FILECREATED
-  (LAMBDA (STREAM)                                       (* |bvm:| "29-Aug-86 15:06")
+  [LAMBDA (STREAM)                                       (* bvm%: "29-Aug-86 15:06")
 
-    (* |;;| "get map from address shown in FILECREATED expression, which is of form (FILECREATED file date mapaddr)")
+    (* ;; "get map from address shown in FILECREATED expression, which is of form (FILECREATED file date mapaddr)")
 
     (SKREAD STREAM)
     (SKREAD STREAM)
@@ -1548,248 +1542,244 @@ WRITEFILE OF ")
                                           (CHARCODE "(")))
                                (EQ (CAR (SETQ MAPADDR (READ STREAM)))
                                    'FILEMAP))
-                          (CADR MAPADDR))))))))
+                          (CADR MAPADDR])
 
-(\\FILEMAP-HASHOVERFLOW
-  (LAMBDA (HARRAY)                                       (* |bvm:| "26-Sep-86 12:11")
+(\FILEMAP-HASHOVERFLOW
+  [LAMBDA (HARRAY)                                       (* bvm%: "26-Sep-86 12:11")
 
-(* |;;;| "Called when *FILEMAP-HASH* overflows.  Trim back old entries")
+(* ;;; "Called when *FILEMAP-HASH* overflows.  Trim back old entries")
 
     (LET
      ((NUMENTRIES (HARRAYPROP HARRAY 'NUMKEYS))
       ENTRIES)
-     (|if| (> NUMENTRIES *FILEMAP-LIMIT*)
-         |then| (MAPHASH HARRAY
-                           (FUNCTION (LAMBDA (VAL KEY)       (* \; "Gather up contents of table")
-                                       (LET ((ROOT (|fetch| FMROOTNAME |of| VAL))
-                                             TEM)
-                                            (|if| (NOT (SETQ TEM (FASSOC ROOT ENTRIES)))
-                                                |then| (|push| ENTRIES (SETQ TEM (LIST ROOT))
-                                                                  ))
-                                            (|push| (CDR TEM)
-                                                   (CONS (|if| (CDR (|fetch| FMFILECREATEDLST
-                                                                           |of| VAL))
-                                                             |then| 
-                                                             (* \; 
+     (if (> NUMENTRIES *FILEMAP-LIMIT*)
+         then [MAPHASH HARRAY (FUNCTION (LAMBDA (VAL KEY)(* ; "Gather up contents of table")
+                                              (LET ((ROOT (fetch FMROOTNAME of VAL))
+                                                    TEM)
+                                                   [if (NOT (SETQ TEM (FASSOC ROOT ENTRIES)))
+                                                       then (push ENTRIES (SETQ TEM
+                                                                                   (LIST ROOT]
+                                                   (push (CDR TEM)
+                                                          (CONS (if (CDR (fetch 
+                                                                                    FMFILECREATEDLST
+                                                                                of VAL))
+                                                                    then 
+                                                             (* ; 
                                          "compiled file, don't keep if there is no other reason to")
-                                                                   0
-                                                           |else| (FILENAMEFIELD KEY 'VERSION))
-                                                         (CONS KEY VAL))))))) 
+                                                                          0
+                                                                  else (FILENAMEFIELD
+                                                                            KEY
+                                                                            'VERSION))
+                                                                (CONS KEY VAL] 
 
-               (* |;;| 
+               (* ;; 
  "each element of ENTRIES is (root . versions), where each version is (vers# fullname . hashvalue)")
 
-               (|for| GROUP |in| ENTRIES |bind| ONFILELST PAIR NFLUSH DATES
-                  |do| (SETQ ONFILELST (MEMB (CAR GROUP)
-                                                 FILELST))
+               [for GROUP in ENTRIES bind ONFILELST PAIR NFLUSH DATES
+                  do (SETQ ONFILELST (MEMB (CAR GROUP)
+                                               FILELST))
                         (SETQ NFLUSH (- (LENGTH (CDR GROUP))
                                         *FILEMAP-VERSIONS*))
-                        (|for| TAIL |on| (PROGN      (* \; 
+                        (for TAIL on (PROGN          (* ; 
                                                            "Sort files by increasing version")
-                                                        (SORT (CDR GROUP)
-                                                              T)) |as| I |from| 1
-                           |do| (SETQ PAIR (CDAR TAIL))
-                                 (|if| (AND (<= I NFLUSH)
-                                                (OR (NULL (SETQ DATES (GET (CAR GROUP)
-                                                                           'FILEDATES)))
-                                                    (NOT (STRING.EQUAL (CDAR DATES)
-                                                                (CAR PAIR)))))
-                                     |then| 
+                                                    (SORT (CDR GROUP)
+                                                          T)) as I from 1
+                           do (SETQ PAIR (CDAR TAIL))
+                                 (if [AND (<= I NFLUSH)
+                                              (OR [NULL (SETQ DATES (GET (CAR GROUP)
+                                                                         'FILEDATES]
+                                                  (NOT (STRING.EQUAL (CDAR DATES)
+                                                              (CAR PAIR]
+                                     then 
 
-                                 (* |;;| "flush old versions until we have gotten down to limit.  The STRING.EQUAL test is because the \"current version\" of a file might have a lower version number (being on a different directory) than the highest version you have looked at anywhere")
+                                 (* ;; "flush old versions until we have gotten down to limit.  The STRING.EQUAL test is because the %"current version%" of a file might have a lower version number (being on a different directory) than the highest version you have looked at anywhere")
 
                                            (REMHASH (CAR PAIR)
                                                   HARRAY)
-                                           (|add| NUMENTRIES -1)
-                                   |elseif| (|fetch| FMRECENT? |of| (CDR PAIR))
-                                     |then|              (* \; 
+                                           (add NUMENTRIES -1)
+                                   elseif (fetch FMRECENT? of (CDR PAIR))
+                                     then                (* ; 
                                                  "spare recently touched files, but clear the flag")
-                                           (|replace| FMRECENT? |of| (CDR PAIR) |with|
-                                                                                        NIL)
-                                   |elseif| (OR (NOT ONFILELST)
-                                                    (CDR TAIL))
-                                     |then|              (* \; 
+                                           (replace FMRECENT? of (CDR PAIR) with NIL)
+                                   elseif (OR (NOT ONFILELST)
+                                                  (CDR TAIL))
+                                     then                (* ; 
            "trim maps not looked at recently, but spare the highest version of anything on filelst")
                                            (REMHASH (CAR PAIR)
                                                   HARRAY)
-                                           (|add| NUMENTRIES -1)))) 
+                                           (add NUMENTRIES -1] 
 
-               (* |;;| 
+               (* ;; 
              "finally say how big to rehash the array.  Normally we want it not to change size.")
 
-               (IMAX *FILEMAP-LIMIT* (FIXR (FTIMES NUMENTRIES 1.2)))))))
+               (IMAX *FILEMAP-LIMIT* (FIXR (FTIMES NUMENTRIES 1.2])
 
 (FLUSHFILEMAPS
-  (LAMBDA (ROOTNAME)                                     (* |bvm:| "26-Sep-86 11:37")
-    (|if| (EQ ROOTNAME T)
-        |then| (CLRHASH *FILEMAP-HASH*)
-      |else| (MAPHASH *FILEMAP-HASH* (FUNCTION (LAMBDA (ME FULLNAME)
-                                                     (|if| (STRING-EQUAL (|fetch| FMROOTNAME
-                                                                                |of| ME)
-                                                                      ROOTNAME)
-                                                         |then| (REMHASH FULLNAME *FILEMAP-HASH*)
-                                                            )))))
-    ROOTNAME))
+  [LAMBDA (ROOTNAME)                                     (* bvm%: "26-Sep-86 11:37")
+    [if (EQ ROOTNAME T)
+        then (CLRHASH *FILEMAP-HASH*)
+      else (MAPHASH *FILEMAP-HASH* (FUNCTION (LAMBDA (ME FULLNAME)
+                                                   (if (STRING-EQUAL (fetch FMROOTNAME
+                                                                            of ME)
+                                                                  ROOTNAME)
+                                                       then (REMHASH FULLNAME *FILEMAP-HASH*]
+    ROOTNAME])
 
 (LISPSOURCEFILEP
-  (LAMBDA (FILE)                                       (* \; "Edited  9-Jul-2021 22:12 by rmk:")
+  [LAMBDA (FILE)                                        (* ; "Edited  9-Jul-2021 22:12 by rmk:")
 
-(* |;;;| "If the first few characters of FILE `look like' those output by MAKEFILE then return the alleged address in the file of its FILEMAP expression.")
+(* ;;; "If the first few characters of FILE `look like' those output by MAKEFILE then return the alleged address in the file of its FILEMAP expression.")
 
     (RESETLST
         (CL:UNLESS (STREAMP FILE)
-            (RESETSAVE NIL (LIST 'CLOSEF (SETQ FILE (OPENSTREAM FILE 'INPUT)))))
+            [RESETSAVE NIL (LIST 'CLOSEF (SETQ FILE (OPENSTREAM FILE 'INPUT])
         (CL:WHEN (RANDACCESSP FILE)
             (LET ((HERE (GETFILEPTR FILE)))
                  (CL:MULTIPLE-VALUE-BIND (ENV MAP)
-                        (\\PARSE-FILE-HEADER FILE (FUNCTION (LAMBDA (STREAM)
-                                                             (* \; 
+                        [\PARSE-FILE-HEADER FILE (FUNCTION (LAMBDA (STREAM)
+                                                             (* ; 
                                                "Pointed now right after the FILECREATED expression")
-                                                                  (CAR (NLSETQ (SKREAD STREAM)
-                                                                              (SKREAD STREAM)
-                                                                              (FIXP (READ STREAM)))))
-                                                       ))
+                                                                 (CAR (NLSETQ (SKREAD STREAM)
+                                                                             (SKREAD STREAM)
+                                                                             (FIXP (READ STREAM]
                         (SETFILEPTR FILE HERE)
-                        (CL:VALUES ENV MAP)))))))
+                        (CL:VALUES ENV MAP)))))])
 
 (GETFILEMAP
-  (LAMBDA (STREAM FL)                                    (* |bvm:| "27-Aug-86 15:48")
+  [LAMBDA (STREAM FL)                                    (* bvm%: "27-Aug-86 15:48")
 
-(* |;;;| "Value is map for STREAM either obtained from the file itself, or from its property list.  STREAM is presumed open.  FL is (NAMEFIELD STREAM T)")
+(* ;;; "Value is map for STREAM either obtained from the file itself, or from its property list.  STREAM is presumed open.  FL is (NAMEFIELD STREAM T)")
 
     (AND USEMAPFLG (CL:MULTIPLE-VALUE-BIND (ENV MAP)
                           (GET-ENVIRONMENT-AND-FILEMAP STREAM)
-                          MAP))))
+                          MAP])
 
 (PUTFILEMAP
-  (LAMBDA (FILE FILEMAP FILCREATEDLST ENV FROMFILE? FCLOCATION)
-                                                             (* |bvm:| "26-Sep-86 11:51")
-                                                             (* \; 
+  [LAMBDA (FILE FILEMAP FILCREATEDLST ENV FROMFILE? FCLOCATION)
+                                                             (* bvm%: "26-Sep-86 11:51")
+                                                             (* ; 
                                                       "Called from: LOAD LOADFNS PRETTYDEF FILEMAP")
 
-    (* |;;| "As far as I can tell, the only use for FILCREATEDLST is to tell ADDFILE in LOADFNS that the file is a compiled file")
+    (* ;; "As far as I can tell, the only use for FILCREATEDLST is to tell ADDFILE in LOADFNS that the file is a compiled file")
 
-    (|if| (NULL FILEMAP)
-        |then| (REMHASH FILE *FILEMAP-HASH*)
-      |elseif| BUILDMAPFLG
-        |then| (LET* ((OLDENTRY (GETHASH FILE *FILEMAP-HASH*))
-                          (NEWENTRY (|create| FILEMAPHASH
-                                       |using| OLDENTRY FMFROMFILE? _ FROMFILE? FMRECENT? _ T)))
-                         (|if| (NULL OLDENTRY)
-                             |then| (|replace| FMROOTNAME |of| NEWENTRY
-                                           |with| (ROOTFILENAME FILE (CDR FILCREATEDLST))))
-                         (|if| ENV
-                             |then| (|replace| FMENVIRONMENT |of| NEWENTRY |with|
-                                                                                       ENV)
-                           |elseif| (NULL OLDENTRY)
-                             |then| (|replace| FMENVIRONMENT |of| NEWENTRY |with|
-                                                                                       (
+    (if (NULL FILEMAP)
+        then (REMHASH FILE *FILEMAP-HASH*)
+      elseif BUILDMAPFLG
+        then (LET* ((OLDENTRY (GETHASH FILE *FILEMAP-HASH*))
+                        (NEWENTRY (create FILEMAPHASH using OLDENTRY FMFROMFILE? _ FROMFILE?
+                                                                FMRECENT? _ T)))
+                       [if (NULL OLDENTRY)
+                           then (replace FMROOTNAME of NEWENTRY
+                                       with (ROOTFILENAME FILE (CDR FILCREATEDLST]
+                       (if ENV
+                           then (replace FMENVIRONMENT of NEWENTRY with ENV)
+                         elseif (NULL OLDENTRY)
+                           then (replace FMENVIRONMENT of NEWENTRY with (
                                                                               MAKE-READER-ENVIRONMENT
-                                                                                        )))
-                         (|if| (LISTP FILEMAP)
-                             |then| (|replace| FMFILEMAP |of| NEWENTRY |with| FILEMAP
-                                               ))
-                         (|if| FCLOCATION
-                             |then| (|replace| FMFILECREATEDLOC |of| NEWENTRY
-                                           |with| FCLOCATION))
-                         (|if| FILCREATEDLST
-                             |then| (|replace| FMFILECREATEDLST |of| NEWENTRY
-                                           |with| FILCREATEDLST))
-                         (PUTHASH FILE NEWENTRY *FILEMAP-HASH*)))))
+                                                                                         )))
+                       (if (LISTP FILEMAP)
+                           then (replace FMFILEMAP of NEWENTRY with FILEMAP))
+                       (if FCLOCATION
+                           then (replace FMFILECREATEDLOC of NEWENTRY with FCLOCATION
+                                           ))
+                       (if FILCREATEDLST
+                           then (replace FMFILECREATEDLST of NEWENTRY with 
+                                                                                        FILCREATEDLST
+                                           ))
+                       (PUTHASH FILE NEWENTRY *FILEMAP-HASH*])
 
 (UPDATEFILEMAP
-  (LAMBDA (STREAM FILEMAP)                               (* |bvm:| "24-Oct-86 17:15")
+  [LAMBDA (STREAM FILEMAP)                               (* bvm%: "24-Oct-86 17:15")
 
-(* |;;;| "Writes new FILEMAP on file currently open as STREAM.  If we return T, the stream has been closed.
+(* ;;; "Writes new FILEMAP on file currently open as STREAM.  If we return T, the stream has been closed.
 
 This has little hope of working any more.")
 
-    (|if| NIL
-        |then|                                           (* \; 
+    (if NIL
+        then                                             (* ; 
                                                          "This has little hope of working any more")
               (LET ((DECLARESTRING (CONCAT "(DECLARE: DONTCOPY
   " "(FILEMAP"))
                     FILEMAPLOCADR TEM FILEMAPADR FILEMAPLOCLEN FULLNAME)
                    (SETFILEPTR STREAM 0)
-                   (SKIPSEPRS STREAM)                        (* \; 
+                   (SKIPSEPRS STREAM)                        (* ; 
                                                        "Could be some font shifts or other garbage")
-                   (READC STREAM)                            (* \; "Skip paren or bracket")
-                   (|if| (AND (EQ (RATOM STREAM)
-                                      'FILECREATED)
-                                  (PROGN (SKREAD STREAM)     (* \; "Date")
-                                         (SKREAD STREAM)     (* \; "Name")
-                                         (|do| (COND
-                                                      ((EQ (SETQ TEM (READCCODE STREAM))
-                                                           (CHARCODE SPACE))
-                                                             (* \; "found a space")
-                                                       (RETURN T))
-                                                      ((NOT (SYNTAXP TEM 'SEPRCHAR))
-                                                             (* \; "no spaces, lose")
-                                                       (RETURN)))))
-                                  (FIXP (SETQ FILEMAPADR (PROGN 
-                                                             (* \; "skip over seprs")
-                                                                (SETQ FILEMAPLOCADR (GETFILEPTR
-                                                                                     STREAM))
-                                                             (* \; 
+                   (READC STREAM)                            (* ; "Skip paren or bracket")
+                   (if (AND (EQ (RATOM STREAM)
+                                    'FILECREATED)
+                                [PROGN (SKREAD STREAM)       (* ; "Date")
+                                       (SKREAD STREAM)       (* ; "Name")
+                                       (do (COND
+                                                  ((EQ (SETQ TEM (READCCODE STREAM))
+                                                       (CHARCODE SPACE))
+                                                             (* ; "found a space")
+                                                   (RETURN T))
+                                                  ((NOT (SYNTAXP TEM 'SEPRCHAR))
+                                                             (* ; "no spaces, lose")
+                                                   (RETURN]
+                                [FIXP (SETQ FILEMAPADR (PROGN 
+                                                             (* ; "skip over seprs")
+                                                              (SETQ FILEMAPLOCADR (GETFILEPTR STREAM)
+                                                               )
+                                                             (* ; 
                                                   "Address of first character of file-map location")
-                                                                (PROG1 (RATOM STREAM)
-                                                                    (SETQ FILEMAPLOCLEN
-                                                                     (IDIFFERENCE (GETFILEPTR STREAM)
-                                                                            FILEMAPLOCADR))))))
-                                  (SETQ FILEMAPADR (OR (FFILEPOS DECLARESTRING STREAM
-                                                              (FIX (TIMES FILEMAPADR 0.9)))
-                                                       (FFILEPOS DECLARESTRING STREAM 0)))
-                                  (EQ (PROGN (SKREAD STREAM)
-                                             (RATOM STREAM))
-                                      'STOP)
-                                  (ILEQ (NCHARS FILEMAPADR T)
-                                        FILEMAPLOCLEN))
-                       |then| 
+                                                              (PROG1 (RATOM STREAM)
+                                                                  (SETQ FILEMAPLOCLEN
+                                                                   (IDIFFERENCE (GETFILEPTR STREAM)
+                                                                          FILEMAPLOCADR)))]
+                                (SETQ FILEMAPADR (OR (FFILEPOS DECLARESTRING STREAM
+                                                            (FIX (TIMES FILEMAPADR 0.9)))
+                                                     (FFILEPOS DECLARESTRING STREAM 0)))
+                                (EQ (PROGN (SKREAD STREAM)
+                                           (RATOM STREAM))
+                                    'STOP)
+                                (ILEQ (NCHARS FILEMAPADR T)
+                                      FILEMAPLOCLEN))
+                       then 
 
-                             (* |;;| "normally, this will be called so that we are positioned at the filemap.  --- check for (FILECREATED & & number --) first to avoid searching compiled files for filemap.")
+                             (* ;; "normally, this will be called so that we are positioned at the filemap.  --- check for (FILECREATED & & number --) first to avoid searching compiled files for filemap.")
 
                              (SETQ FULLNAME (CLOSEF STREAM))
-                             (|if| (SETQ STREAM (CAR (NLSETQ (OPENSTREAM FULLNAME 'BOTH
-                                                                        'OLD NIL '(DON\'T.CHANGE.DATE
-                                                                                   )))))
-                                 |then| (RESETLST
-                                                (RESETSAVE NIL (LIST 'CLOSEF STREAM))
-                                                (SETFILEPTR STREAM FILEMAPADR)
-                                                (PRIN3 "(DECLARE: DONTCOPY
+                             [if [SETQ STREAM (CAR (NLSETQ (OPENSTREAM FULLNAME 'BOTH
+                                                                      'OLD NIL '(DON'T.CHANGE.DATE]
+                                 then (RESETLST
+                                              (RESETSAVE NIL (LIST 'CLOSEF STREAM))
+                                              (SETFILEPTR STREAM FILEMAPADR)
+                                              (PRIN3 "(DECLARE: DONTCOPY
   " STREAM)
-                                                (SETQ FILEMAPADR (GETFILEPTR STREAM))
-                                                (PRIN3 "(FILEMAP " STREAM)
-                                                (POSITION STREAM (CONSTANT (NCHARS "(FILEMAP ")))
-                                                (LET ((*PRINT-RADIX* 10))
-                                                     (PRIN2 FILEMAP STREAM))
-                                                (PRIN1 "))" STREAM)
-                                                (TERPRI STREAM)
-                                                (PRINT 'STOP STREAM)
-                                                (SETFILEPTR STREAM FILEMAPLOCADR)
-                                                (PRINTNUM (LIST 'FIX FILEMAPLOCLEN)
-                                                       FILEMAPADR STREAM)
-                                                (COND
-                                                   ((NEQ DFNFLG T)
-                                                    (PRIN3 "****rewrote file map for " T)
-                                                    (PRINT FULLNAME T T)))))
-                             T)))))
+                                              (SETQ FILEMAPADR (GETFILEPTR STREAM))
+                                              (PRIN3 "(FILEMAP " STREAM)
+                                              (POSITION STREAM (CONSTANT (NCHARS "(FILEMAP ")))
+                                              (LET ((*PRINT-RADIX* 10))
+                                                   (PRIN2 FILEMAP STREAM))
+                                              (PRIN1 "))" STREAM)
+                                              (TERPRI STREAM)
+                                              (PRINT 'STOP STREAM)
+                                              (SETFILEPTR STREAM FILEMAPLOCADR)
+                                              (PRINTNUM (LIST 'FIX FILEMAPLOCLEN)
+                                                     FILEMAPADR STREAM)
+                                              (COND
+                                                 ((NEQ DFNFLG T)
+                                                  (PRIN3 "****rewrote file map for " T)
+                                                  (PRINT FULLNAME T T))))]
+                             T])
 )
 
 (RPAQ? *FILEMAP-LIMIT* 20)
 
 (RPAQ? *FILEMAP-VERSIONS* 2)
 
-(RPAQ? *FILEMAP-HASH* (HASHARRAY *FILEMAP-LIMIT* (FUNCTION \\FILEMAP-HASHOVERFLOW)
+(RPAQ? *FILEMAP-HASH* (HASHARRAY *FILEMAP-LIMIT* (FUNCTION \FILEMAP-HASHOVERFLOW)
                                  (FUNCTION STRING-EQUAL-HASHBITS)
                                  (FUNCTION STRING.EQUAL)))
-(DECLARE\: EVAL@COMPILE DONTCOPY 
-(DECLARE\: EVAL@COMPILE
+(DECLARE%: EVAL@COMPILE DONTCOPY 
+(DECLARE%: EVAL@COMPILE
 
 (RECORD FILEMAPHASH (FMENVIRONMENT FMROOTNAME FMFROMFILE? FMRECENT? FMFILECREATEDLOC 
                                FMFILECREATEDLST . FMFILEMAP))
 )
 
-(DECLARE\: DOEVAL@COMPILE DONTCOPY
+(DECLARE%: DOEVAL@COMPILE DONTCOPY
 
 (GLOBALVARS *FILEMAP-LIMIT* *FILEMAP-VERSIONS* *FILEMAP-HASH*)
 )
@@ -1799,30 +1789,30 @@ This has little hope of working any more.")
 (DEFINEQ
 
 (LVLPRINT
-  (LAMBDA (X FILE CARLVL CDRLVL TAIL)                        (* |wt:| 12-MAY-76 22 6)
+  [LAMBDA (X FILE CARLVL CDRLVL TAIL)                        (* wt%: 12-MAY-76 22 6)
     (LVLPRIN2 X FILE CARLVL CDRLVL TAIL)
     (TERPRI FILE)
-    X))
+    X])
 
 (LVLPRIN1
-  (LAMBDA (X FILE CARLVL CDRLVL TAIL)
+  [LAMBDA (X FILE CARLVL CDRLVL TAIL)
     (DECLARE (SPECVARS FILE PRIN2FLG))
     (PROG (PRIN2FLG)
           (LVLPRIN X CARLVL CDRLVL TAIL)
-          (RETURN X))))
+          (RETURN X])
 
 (LVLPRIN2
-  (LAMBDA (X FILE CARLVL CDRLVL TAIL)
-    (DECLARE (SPECVARS FILE PRIN2FLG))                   (* |wt:| 12-MAY-76 22 6)
+  [LAMBDA (X FILE CARLVL CDRLVL TAIL)
+    (DECLARE (SPECVARS FILE PRIN2FLG))                   (* wt%: 12-MAY-76 22 6)
     (PROG ((PRIN2FLG T))
           (LVLPRIN X CARLVL CDRLVL TAIL)
-          (RETURN X))))
+          (RETURN X])
 
 (LVLPRIN
-  (LAMBDA (X CARLVL CDRLVL TAIL)                         (* \; "Edited 10-Nov-87 13:10 by jds")
-                                                             (* \; "wt: 12-MAY-76 22 23")
+  [LAMBDA (X CARLVL CDRLVL TAIL)                         (* ; "Edited 10-Nov-87 13:10 by jds")
+                                                             (* ; "wt: 12-MAY-76 22 23")
     (COND
-       ((NLISTP X)
+       [(NLISTP X)
         (COND
            ((AND TAIL (EQ X (CDR (LAST TAIL)))
                  (NOT (MEMB X TAIL)))
@@ -1831,22 +1821,22 @@ This has little hope of working any more.")
                (PRIN2FLG (PRIN2 X FILE T))
                (T (PRIN1 X FILE)))
 
-            (* |;;| "We use standard system read table for printing on grounds that even if this is going to a file, user is only dumping it with bpnt to look at it, not to read it back in.")
+            (* ;; "We use standard system read table for printing on grounds that even if this is going to a file, user is only dumping it with bpnt to look at it, not to read it back in.")
 
             (PRIN1 ")" FILE))
            (PRIN2FLG (PRIN2 X FILE T))
-           (T (PRIN1 X FILE))))
+           (T (PRIN1 X FILE]
        (T (PRIN1 (COND
-                    ((AND TAIL (TAILP X TAIL))               (* \; "Tail")
+                    ((AND TAIL (TAILP X TAIL))               (* ; "Tail")
                      '"... ")
                     (T "("))
                  FILE)
           (LVLPRIN0 X CARLVL CDRLVL)
-          (PRIN1 ")" FILE)))))
+          (PRIN1 ")" FILE])
 
 (LVLPRIN0
-  (LAMBDA (X CARLVL CDRLVL)                              (* \; "Edited 10-Nov-87 13:11 by jds")
-                                                             (* \; 
+  [LAMBDA (X CARLVL CDRLVL)                              (* ; "Edited 10-Nov-87 13:11 by jds")
+                                                             (* ; 
                              "LVLPRIN0 is like subprint.  it prints the interior segment of a list")
     (AND (EQ (CAR X)
              CLISPTRANFLG)
@@ -1867,15 +1857,15 @@ This has little hope of working any more.")
              ((EQ CDRLVL 0)
               (PRIN1 "--" FILE)
               (RETURN))
-             ((NLISTP (CAR X))
+             [(NLISTP (CAR X))
               (COND
                  (PRIN2FLG (PRIN2 (CAR X)
                                   FILE T T))
                  (T (PRIN1 (CAR X)
-                           FILE))))
+                           FILE]
              ((OR (EQ CARLVL 0)
                   (AND CDRLVL0 (EQ (SUB1 CDRLVL0)
-                                   0)))                      (* \; 
+                                   0)))                      (* ; 
    "the reason for the second check is that why bother to recurse only to print (--).  & is better")
               (PRIN1 '& FILE))
              ((AND (EQ FILE T)
@@ -1883,28 +1873,28 @@ This has little hope of working any more.")
                           COMMENTFLG)
                    **COMMENT**FLG)
               (PRIN1 **COMMENT**FLG FILE))
-             (T (PRIN1 '\( FILE)
+             (T (PRIN1 '%( FILE)
                 (LVLPRIN0 (CAR X)
-                       (AND CARLVL (IPLUS CARLVL (COND
+                       [AND CARLVL (IPLUS CARLVL (COND
                                                     ((MINUSP CARLVL)
                                                      1)
-                                                    (T -1))))
+                                                    (T -1]
                        (AND CDRLVL0 (SUB1 CDRLVL0)))
-                (PRIN1 '\) FILE)))
+                (PRIN1 '%) FILE)))
           (AND CDRLVL (SETQ CDRLVL (SUB1 CDRLVL)))
-          (GO LP))))
+          (GO LP])
 )
 
 
 
-(* \; "used by PRINTOUT")
+(* ; "used by PRINTOUT")
 
 (DEFINEQ
 
 (FLUSHRIGHT
-  (LAMBDA (POS X MIN P2FLAG CENTERFLAG FILE)             (* |lmm| "10-Feb-86 12:10")
+  [LAMBDA (POS X MIN P2FLAG CENTERFLAG FILE)             (* lmm "10-Feb-86 12:10")
 
-    (* |;;| "Right-flushes X at position POS.  If P2FLAG, uses PRIN2-pname;  if CENTERFLAG, centers X between current position and POS")
+    (* ;; "Right-flushes X at position POS.  If P2FLAG, uses PRIN2-pname;  if CENTERFLAG, centers X between current position and POS")
 
     (SETQ POS (IDIFFERENCE (COND
                               ((MINUSP POS)
@@ -1914,111 +1904,111 @@ This has little hope of working any more.")
                                (LINELENGTH NIL FILE))
                               (T POS))
                      (NCHARS X P2FLAG)))
-    (COND
+    [COND
        (CENTERFLAG (SETQ POS (QUOTIENT (IPLUS POS (POSITION FILE))
-                                    2))))
+                                    2]
     (TAB POS MIN FILE)
     (COND
        (P2FLAG (PRIN2 X FILE))
-       (T (PRIN1 X FILE)))))
+       (T (PRIN1 X FILE])
 
 (PRINTPARA
-  (LAMBDA (LMARG RMARG LIST P2FLAG PARENFLAG FILE)       (* |rmk:| "22-MAY-81 13:45")
+  [LAMBDA (LMARG RMARG LIST P2FLAG PARENFLAG FILE)       (* rmk%: "22-MAY-81 13:45")
 
-    (* |;;| "Prints LIST in paragraph format.  The first line starts at the current line position, but all subsequent lines begin at LMARG (0 is the left margin, NIL is the current POSITION, negative LMARG is (POSITION) + LMARG).  Printing is with PRIN2 if P2FLAG, otherwise PRIN1.  The right margin is at column RMARG if RMARG is positive, (LINELENGTH NIL FILE) minus RMARG for RMARG LEQ 0")
+    (* ;; "Prints LIST in paragraph format.  The first line starts at the current line position, but all subsequent lines begin at LMARG (0 is the left margin, NIL is the current POSITION, negative LMARG is (POSITION) + LMARG).  Printing is with PRIN2 if P2FLAG, otherwise PRIN1.  The right margin is at column RMARG if RMARG is positive, (LINELENGTH NIL FILE) minus RMARG for RMARG LEQ 0")
 
     (DECLARE (SPECVARS LMARG RMARG P2FLAG FILE))
-    (COND
+    [COND
        ((NULL LMARG)
         (SETQ LMARG (POSITION FILE)))
        ((MINUSP LMARG)
         (SETQ LMARG (IDIFFERENCE (POSITION FILE)
-                           LMARG))))
-    (COND
+                           LMARG]
+    [COND
        ((ILEQ RMARG 0)
-        (SETQ RMARG (IPLUS RMARG (LINELENGTH NIL FILE)))))
+        (SETQ RMARG (IPLUS RMARG (LINELENGTH NIL FILE]
     (POSITION FILE (PRINTPARA1 LIST (POSITION FILE)
                           (COND
                              (PARENFLAG 1)
                              (T 0))
                           (COND
                              (PARENFLAG 1)
-                             (T 0))))))
+                             (T 0])
 
 (PRINTPARA1
-  (LAMBDA (LIST POS OPENCOUNT CLOSECOUNT)                (* |wt:| " 9-SEP-78 09:54")
+  [LAMBDA (LIST POS OPENCOUNT CLOSECOUNT)                (* wt%: " 9-SEP-78 09:54")
 
-    (* |;;| "PRIN3 and PRIN4 are used here, so we don't have to set and unset LINELENGTH.  We keep our own idea of the current line position in POS, which is returned as the value of PRINTPARA1.  OPENCOUNT is the number of open parens that must precede the first non-list we print, CLOSECOUNT is the number of close parens that should follow the last non-list we print.  They are passed as arguments so that their numbers can be taken into account in deciding whether a non-list fits on the line or not.")
+    (* ;; "PRIN3 and PRIN4 are used here, so we don't have to set and unset LINELENGTH.  We keep our own idea of the current line position in POS, which is returned as the value of PRINTPARA1.  OPENCOUNT is the number of open parens that must precede the first non-list we print, CLOSECOUNT is the number of close parens that should follow the last non-list we print.  They are passed as arguments so that their numbers can be taken into account in deciding whether a non-list fits on the line or not.")
 
     (PROG ($$VAL L LEN (CC 0))
       $$LP
-          (SETQ L (CAR (OR (LISTP LIST)
-                           (GO $$OUT))))                     (* \; 
+          [SETQ L (CAR (OR (LISTP LIST)
+                           (GO $$OUT]                        (* ; 
                                   "POS is the correct column position at the end of each iteration")
           (COND
              ((NLISTP (CDR LIST))
-              (SETQ CC CLOSECOUNT)))                         (* \; 
+              (SETQ CC CLOSECOUNT)))                         (* ; 
                   "The last iteration.  Now we really want to use CLOSECOUNT, so we move it to CC.")
-          (COND
+          [COND
              ((LISTP L)
               (SETQ POS (PRINTPARA1 L POS (ADD1 OPENCOUNT)
                                (ADD1 CC)))
-              (SETQ OPENCOUNT 0)                             (* \; 
+              (SETQ OPENCOUNT 0)                             (* ; 
     "The lower call printed the open and closed parens, including the ones for this level, if any.")
               (SETQ CC 0))
-             (T (COND
-                   ((ILESSP RMARG (IPLUS OPENCOUNT CC (SETQ POS (IPLUS POS (SETQ LEN (NCHARS L P2FLAG
-                                                                                            ))))))
-                    (TERPRI FILE)                            (* \; 
+             (T [COND
+                   ([ILESSP RMARG (IPLUS OPENCOUNT CC (SETQ POS (IPLUS POS (SETQ LEN (NCHARS L P2FLAG
+                                                                                            ]
+                    (TERPRI FILE)                            (* ; 
                                      "TAB wouldn't work, cause POSITION doesn't know where we are.")
-                    (RPTQ LMARG (PRIN3 '\  FILE))
-                    (SETQ POS (IPLUS LMARG LEN))))
+                    (RPTQ LMARG (PRIN3 '%  FILE))
+                    (SETQ POS (IPLUS LMARG LEN]
                 (COND
                    ((IGREATERP OPENCOUNT 0)
-                    (RPTQ OPENCOUNT (PRIN3 '\( FILE))
+                    (RPTQ OPENCOUNT (PRIN3 '%( FILE))
                     (SETQ POS (IPLUS POS OPENCOUNT))
                     (SETQ OPENCOUNT 0)))
                 (COND
                    (P2FLAG (PRIN4 L FILE))
-                   (T (PRIN3 L FILE)))))
-          (COND
+                   (T (PRIN3 L FILE]
+          [COND
              ((AND (IGREATERP RMARG (ADD1 POS))
                    (LISTP (CDR LIST)))
-              (PRIN3 '\  FILE)
-              (SETQ POS (ADD1 POS))))
+              (PRIN3 '%  FILE)
+              (SETQ POS (ADD1 POS]
       $$ITERATE
           (SETQ LIST (CDR LIST))
           (GO $$LP)
       $$OUT
-          (RPTQ CC (COND
+          [RPTQ CC (COND
                       ((ILESSP RMARG (SETQ POS (ADD1 POS)))
-                       (TERPRI FILE)                         (* \; 
+                       (TERPRI FILE)                         (* ; 
                    "We do the closes one-by-one, in case they won't fit on a line with only 1 atom")
-                       (RPTQ LMARG (PRIN3 '\  FILE))
-                       (PRIN3 '\) FILE)
+                       (RPTQ LMARG (PRIN3 '%  FILE))
+                       (PRIN3 '%) FILE)
                        (SETQ POS (ADD1 LMARG)))
-                      (T (PRIN3 '\) FILE))))
+                      (T (PRIN3 '%) FILE]
           (RETURN $$VAL))
-    POS))
+    POS])
 )
 
 
 
-(* \; "SUBLIS and friends")
+(* ; "SUBLIS and friends")
 
 (DEFINEQ
 
 (SUBLIS
-  (LAMBDA (ALST EXPR FLG)
+  [LAMBDA (ALST EXPR FLG)
     (COND
        ((LISTP EXPR)
-        ((LAMBDA (D A)
+        ([LAMBDA (D A)
            (COND
               ((OR (NEQ A (CAR EXPR))
                    (NEQ D (CDR EXPR))
                    FLG)
                (CONS A D))
-              (T EXPR)))
+              (T EXPR]
          (AND (CDR EXPR)
               (SUBLIS ALST (CDR EXPR)
                      FLG))
@@ -2026,22 +2016,22 @@ This has little hope of working any more.")
                 FLG)))
        (T (LET ((Y (FASSOC EXPR ALST)))
                (COND
-                  (Y (COND
+                  [Y (COND
                         (FLG (COPY (CDR Y)))
-                        (T (CDR Y))))
-                  (T EXPR)))))))
+                        (T (CDR Y]
+                  (T EXPR])
 
 (SUBPAIR
-  (LAMBDA (OLD NEW EXPR FLG)                         (* |lmm| "25-FEB-82 15:29")
+  [LAMBDA (OLD NEW EXPR FLG)                         (* lmm "25-FEB-82 15:29")
     (COND
        ((LISTP EXPR)
-        ((LAMBDA (D A)
+        ([LAMBDA (D A)
            (COND
               ((OR (NEQ A (CAR EXPR))
                    (NEQ D (CDR EXPR))
                    FLG)
                (CONS A D))
-              (T EXPR)))
+              (T EXPR]
          (AND (CDR EXPR)
               (SUBPAIR OLD NEW (CDR EXPR)
                      FLG))
@@ -2058,16 +2048,16 @@ This has little hope of working any more.")
                                    (FLG (COPY NEW))
                                    (T NEW)))
                                (T EXPR)))
-                           ((EQ EXPR (CAR OLD))
+                           [(EQ EXPR (CAR OLD))
                             (COND
                                (FLG (COPY (CAR NEW)))
-                               (T (CAR NEW))))
+                               (T (CAR NEW]
                            (T (SETQ OLD (CDR OLD))
                               (SETQ NEW (CDR NEW))
-                              (GO LP)))))))))
+                              (GO LP])
 
 (DSUBLIS
-  (LAMBDA (ALST EXPR FLG)
+  [LAMBDA (ALST EXPR FLG)
     (COND
        ((NLISTP EXPR)
         (SUBLIS ALST EXPR FLG))
@@ -2079,14 +2069,14 @@ This has little hope of working any more.")
                           FLG)))
                (OR (EQ D (CDR EXPR))
                    (RPLACD EXPR D)))
-          EXPR))))
+          EXPR])
 )
 (* * CONSTANTS)
 
 (DEFINEQ
 
 (CONSTANTOK
-  (LAMBDA (X DEPTH)                                      (* |lmm| " 1-OCT-78 22:03")
+  [LAMBDA (X DEPTH)                                      (* lmm " 1-OCT-78 22:03")
     (OR DEPTH (SETQ DEPTH 100))
     (COND
        ((OR (SMALLP X)
@@ -2104,7 +2094,7 @@ This has little hope of working any more.")
         (AND (SETQ DEPTH (CONSTANTOK (CAR X)
                                 (SUB1 DEPTH)))
              (CONSTANTOK (CDR X)
-                    DEPTH))))))
+                    DEPTH])
 )
 
 (MOVD? 'EVQ 'CONSTANT)
@@ -2116,7 +2106,7 @@ This has little hope of working any more.")
 
 
 (PUTPROPS SCRATCHLIST MACRO ((SCRATCHLIST . FORMS)
-                                     ((LAMBDA (!SCRATCHLIST !SCRATCHTAIL)
+                                     ([LAMBDA (!SCRATCHLIST !SCRATCHTAIL)
                                         (DECLARE (SPECVARS !SCRATCHLIST !SCRATCHTAIL))
                                         (SETQ !SCRATCHTAIL !SCRATCHLIST)
                                         (PROGN . FORMS)
@@ -2129,19 +2119,19 @@ This has little hope of working any more.")
                                                                                        NIL)))
                                                     (FRPLACD (FLAST !SCRATCHLIST)
                                                            L2)
-                                                    (RETURN L2)))))
+                                                    (RETURN L2]
                                       (OR (LISTP SCRATCHLIST)
                                           (CONS))
                                       NIL)))
 
 (PUTPROPS ADDTOSCRATCHLIST MACRO ((VALUE)
-                                          (FRPLACA (SETQ !SCRATCHTAIL (OR (LISTP (CDR !SCRATCHTAIL))
+                                          (FRPLACA [SETQ !SCRATCHTAIL (OR (LISTP (CDR !SCRATCHTAIL))
                                                                           (CDR (FRPLACD !SCRATCHTAIL
-                                                                                      (CONS)))))
+                                                                                      (CONS]
                                                  VALUE)))
 
 (PUTPROPS SCRATCHLIST INFO EVAL)
-(DECLARE\: DOEVAL@COMPILE DONTCOPY
+(DECLARE%: DOEVAL@COMPILE DONTCOPY
 
 (GLOBALVARS SYSFILES LOADOPTIONS LISPXCOMS CLISPTRANFLG COMMENTFLG HISTSTR4 LISPXREADFN REREADFLG 
        HISTSTR0 CTRLUFLG NOLINKMESS PROMPTCHARFORMS PROMPT#FLG FILERDTBL SPELLINGS2 USERWORDS BELLS 
@@ -2150,26 +2140,26 @@ This has little hope of working any more.")
 (DEFINEQ
 
 (NLAMBDA.ARGS
-  (LAMBDA (X)                                            (* |bvm:| "26-Apr-86 16:41")
+  [LAMBDA (X)                                            (* bvm%: "26-Apr-86 16:41")
 
-(* |;;;| "Standard function to take argument to NLAMBDA function, e.g. BREAK, and check to see if accidentally quoted.")
+(* ;;; "Standard function to take argument to NLAMBDA function, e.g. BREAK, and check to see if accidentally quoted.")
 
-(* |;;;| "Handles both BREAK 'FOO as a command and (BREAK 'FOO 'BAR).  In the former case, X is (QUOTE FOO), in the latter it is ((QUOTE FOO) (QUOTE BAR)).")
+(* ;;; "Handles both BREAK 'FOO as a command and (BREAK 'FOO 'BAR).  In the former case, X is (QUOTE FOO), in the latter it is ((QUOTE FOO) (QUOTE BAR)).")
 
     (COND
        ((NLISTP X)
         (AND X (LIST X)))
-       ((AND (EQ (CAR X)
+       [(AND (EQ (CAR X)
                  'QUOTE)
-             (LISTP (CDR X))))
-       ((AND (LISTP (CAR X))
+             (LISTP (CDR X]
+       [(AND (LISTP (CAR X))
              (EQ (CAAR X)
                  'QUOTE))
         (CONS (CADR (CAR X))
-              (NLAMBDA.ARGS (CDR X))))
-       (T X))))
+              (NLAMBDA.ARGS (CDR X]
+       (T X])
 )
-(DECLARE\: DONTEVAL@LOAD DOCOPY 
+(DECLARE%: DONTEVAL@LOAD DOCOPY 
 
 (ADDTOVAR CLISPARRAY )
 
@@ -2233,7 +2223,7 @@ This has little hope of working any more.")
 
 (RPAQ? CLEARSTKLST T)
 
-(RPAQ? CLISPTRANFLG 'CLISP\ )
+(RPAQ? CLISPTRANFLG 'CLISP% )
 
 (RPAQ? HISTSTR0 "<c.r.>")
 
@@ -2248,7 +2238,7 @@ This has little hope of working any more.")
 (RPAQ? USEMAPFLG T)
 
 
-(MAPC '((APPLY BLKAPPLY)
+[MAPC '((APPLY BLKAPPLY)
         (SETTOPVAL SETATOMVAL)
         (GETTOPVAL GETATOMVAL)
         (APPLY* BLKAPPLY*)
@@ -2303,9 +2293,9 @@ This has little hope of working any more.")
         (COPYBYTES COPYCHARS))
       (FUNCTION (LAMBDA (X)
                   (MOVD? (CAR X)
-                         (CADR X)))))
+                         (CADR X]
 
-(MAPC '((TIME PRIN1 LISPXPRIN1)
+[MAPC '((TIME PRIN1 LISPXPRIN1)
         (TIME SPACES LISPXSPACES)
         (TIME PRINT LISPXPRINT)
         (DEFC PRINT LISPXPRINT)
@@ -2318,35 +2308,35 @@ This has little hope of working any more.")
         (MKSWAPBLOCK PUTD /PUTD))
       (FUNCTION (LAMBDA (X)
                   (AND (CCODEP (CAR X))
-                       (APPLY 'CHANGENAME X)))))
+                       (APPLY 'CHANGENAME X]
 
-(MAPC '((EVALQT (LAMBDA NIL
+[MAPC '[[EVALQT (LAMBDA NIL
                   (PROG (TEM)
                         (RESETRESTORE NIL 'RESET)
                     LP  (PROMPTCHAR '_ T)
                         (LISPX (LISPXREAD T T))
-                        (GO LP))))
-        (LISPX (LAMBDA (LISPXX)
-                 (PRINT (AND LISPXX (PROG (LISPXLINE LISPXHIST TEM)
+                        (GO LP]
+        [LISPX (LAMBDA (LISPXX)
+                 (PRINT [AND LISPXX (PROG (LISPXLINE LISPXHIST TEM)
                                           (RETURN (COND
                                                      ((AND (NLISTP LISPXX)
                                                            (SETQ LISPXLINE (READLINE T NIL T)))
                                                       (APPLY LISPXX (CAR LISPXLINE)))
-                                                     (T (EVAL LISPXX))))))
-                        T T)))
-        (LISPXREAD (LAMBDA (FILE RDTBL)
+                                                     (T (EVAL LISPXX]
+                        T T]
+        [LISPXREAD (LAMBDA (FILE RDTBL)
                      (COND
-                        (READBUF (PROG1 (CAR READBUF)
-                                     (SETQ READBUF (CDR READBUF))))
-                        (T (READ FILE RDTBL)))))
-        (LISPXREADP (LAMBDA (FLG)
+                        [READBUF (PROG1 (CAR READBUF)
+                                     (SETQ READBUF (CDR READBUF)))]
+                        (T (READ FILE RDTBL]
+        [LISPXREADP (LAMBDA (FLG)
                       (COND
                          ((AND READBUF (SETQ READBUF (LISPXREADBUF READBUF)))
                           T)
-                         (T (READP T FLG)))))
-        (LISPXUNREAD (LAMBDA (LST)
-                       (SETQ READBUF (APPEND LST (CONS HISTSTR0 READBUF)))))
-        (LISPXREADBUF (LAMBDA (RDBUF)
+                         (T (READP T FLG]
+        [LISPXUNREAD (LAMBDA (LST)
+                       (SETQ READBUF (APPEND LST (CONS HISTSTR0 READBUF]
+        [LISPXREADBUF (LAMBDA (RDBUF)
                         (PROG NIL
                           LP  (COND
                                  ((NLISTP RDBUF)
@@ -2355,28 +2345,28 @@ This has little hope of working any more.")
                                       HISTSTR0)
                                   (SETQ RDBUF (CDR RDBUF))
                                   (GO LP))
-                                 (T (RETURN RDBUF))))))
-        (LISPX/ (LAMBDA (X)
-                  X))
-        (LOWERCASE (LAMBDA (FLG)
+                                 (T (RETURN RDBUF]
+        [LISPX/ (LAMBDA (X)
+                  X]
+        [LOWERCASE (LAMBDA (FLG)
                      (PROG1 LCASEFLG
                          (RAISE (NULL FLG))
-                         (RPAQ LCASEFLG FLG))))
-        (FILEPOS (LAMBDA (STR FILE)
+                         (RPAQ LCASEFLG FLG))]
+        [FILEPOS (LAMBDA (STR FILE)
                    (PROG NIL
                      LP  (COND
                             ((EQ (PEEKC FILE)
                                  (NTHCHAR STR 1))
                              (RETURN T)))
                          (READC FILE)
-                         (GO LP))))
-        (FILEPKGCOM (NLAMBDA NIL NIL)))
+                         (GO LP]
+        (FILEPKGCOM (NLAMBDA NIL NIL]
       (FUNCTION (LAMBDA (L)
                   (OR (GETD (CAR L))
                       (PUTD (CAR L)
-                            (CADR L))))))
+                            (CADR L]
 )
-(DECLARE\: DONTEVAL@LOAD DOEVAL@COMPILE DONTCOPY COMPILERVARS 
+(DECLARE%: DONTEVAL@LOAD DOEVAL@COMPILE DONTCOPY COMPILERVARS 
 
 (ADDTOVAR NLAMA RESETBUFS DMPHASH FILESLOAD)
 
@@ -2384,30 +2374,30 @@ This has little hope of working any more.")
 
 (ADDTOVAR LAMA READFILE NLIST)
 )
-(DECLARE\: DOEVAL@COMPILE DONTCOPY
+(DECLARE%: DOEVAL@COMPILE DONTCOPY
 
 (LOCALVARS . T)
 )
 (PUTPROPS MACHINEINDEPENDENT COPYRIGHT ("Venue & Xerox Corporation" T 1983 1984 1985 1986 1987 1988 
 1989 1990 1991 2021))
-(DECLARE\: DONTCOPY
-  (FILEMAP (NIL (12878 26882 (LOAD? 12888 . 14854) (FILESLOAD 14856 . 15151) (DOFILESLOAD 15153 . 22678)
- (FINDFILE-WITH-EXTENSIONS 22680 . 26433) (READ-FILECREATED 26435 . 26880)) (27000 32493 (DMPHASH 
-27010 . 28626) (HASHOVERFLOW 28628 . 32491)) (33295 65128 (BKBUFS 33305 . 34433) (CHANGENAME 34435 . 
-34699) (CHNGNM 34701 . 36588) (CLBUFS 36590 . 37874) (DEFINE 37876 . 38616) (FNS.PUTDEF 38618 . 42072)
- (EQMEMB 42074 . 42259) (EQUALN 42261 . 43102) (FNCHECK 43104 . 45383) (FNTYP1 45385 . 45484) (LCSKIP 
-45486 . 46358) (MAPRINT 46360 . 47316) (MKLIST 47318 . 47472) (NAMEFIELD 47474 . 49013) (NLIST 49015
- . 49356) (PRINTBELLS 49358 . 49486) (PROMPTCHAR 49488 . 51400) (RAISEP 51402 . 51668) (READFILE 51670
- . 54036) (READLINE 54038 . 59521) (REMPROPLIST 59523 . 60418) (RESETBUFS 60420 . 60877) (TAB 60879 . 
-61480) (UNSAVED1 61482 . 62602) (WRITEFILE 62604 . 64209) (CLOSE-AND-MAYBE-DELETE 64211 . 64564) (
-UNSAFE.TO.MODIFY 64566 . 65126)) (67455 70434 (FILEDATE 67465 . 70432)) (70666 95124 (FILEMAP 70676 . 
-71151) (\\PARSE-FILE-HEADER 71153 . 74998) (GET-ENVIRONMENT-AND-FILEMAP 75000 . 77274) (
-LOOKUP-ENVIRONMENT-AND-FILEMAP 77276 . 79557) (GET-FILEMAP-FROM-FILECREATED 79559 . 80392) (
-\\FILEMAP-HASHOVERFLOW 80394 . 84972) (FLUSHFILEMAPS 84974 . 85690) (LISPSOURCEFILEP 85692 . 86943) (
-GETFILEMAP 86945 . 87369) (PUTFILEMAP 87371 . 89781) (UPDATEFILEMAP 89783 . 95122)) (95742 99356 (
-LVLPRINT 95752 . 95926) (LVLPRIN1 95928 . 96112) (LVLPRIN2 96114 . 96349) (LVLPRIN 96351 . 97376) (
-LVLPRIN0 97378 . 99354)) (99391 104358 (FLUSHRIGHT 99401 . 100226) (PRINTPARA 100228 . 101340) (
-PRINTPARA1 101342 . 104356)) (104395 106706 (SUBLIS 104405 . 105023) (SUBPAIR 105025 . 106267) (
-DSUBLIS 106269 . 106704)) (106729 107335 (CONSTANTOK 106739 . 107333)) (109421 110139 (NLAMBDA.ARGS 
-109431 . 110137)))))
+(DECLARE%: DONTCOPY
+  (FILEMAP (NIL (12841 26148 (LOAD? 12851 . 14702) (FILESLOAD 14704 . 14993) (DOFILESLOAD 14995 . 22243)
+ (FINDFILE-WITH-EXTENSIONS 22245 . 25704) (READ-FILECREATED 25706 . 26146)) (26265 31586 (DMPHASH 
+26275 . 27869) (HASHOVERFLOW 27871 . 31584)) (32382 63719 (BKBUFS 32392 . 33511) (CHANGENAME 33513 . 
+33774) (CHNGNM 33776 . 35624) (CLBUFS 35626 . 36899) (DEFINE 36901 . 37625) (FNS.PUTDEF 37627 . 41042)
+ (EQMEMB 41044 . 41226) (EQUALN 41228 . 42057) (FNCHECK 42059 . 44066) (FNTYP1 44068 . 44165) (LCSKIP 
+44167 . 45011) (MAPRINT 45013 . 45959) (MKLIST 45961 . 46111) (NAMEFIELD 46113 . 47638) (NLIST 47640
+ . 47975) (PRINTBELLS 47977 . 48103) (PROMPTCHAR 48105 . 49995) (RAISEP 49997 . 50258) (READFILE 50260
+ . 52604) (READLINE 52606 . 58046) (REMPROPLIST 58048 . 58936) (RESETBUFS 58938 . 59388) (TAB 59390 . 
+59986) (UNSAVED1 59988 . 61093) (WRITEFILE 61095 . 62837) (CLOSE-AND-MAYBE-DELETE 62839 . 63183) (
+UNSAFE.TO.MODIFY 63185 . 63717)) (66043 68987 (FILEDATE 66053 . 68985)) (69217 92956 (FILEMAP 69227 . 
+69697) (\PARSE-FILE-HEADER 69699 . 73514) (GET-ENVIRONMENT-AND-FILEMAP 73516 . 75743) (
+LOOKUP-ENVIRONMENT-AND-FILEMAP 75745 . 77936) (GET-FILEMAP-FROM-FILECREATED 77938 . 78762) (
+\FILEMAP-HASHOVERFLOW 78764 . 83428) (FLUSHFILEMAPS 83430 . 84053) (LISPSOURCEFILEP 84055 . 85234) (
+GETFILEMAP 85236 . 85655) (PUTFILEMAP 85657 . 87848) (UPDATEFILEMAP 87850 . 92954)) (93573 97159 (
+LVLPRINT 93583 . 93756) (LVLPRIN1 93758 . 93940) (LVLPRIN2 93942 . 94174) (LVLPRIN 94176 . 95190) (
+LVLPRIN0 95192 . 97157)) (97193 102110 (FLUSHRIGHT 97203 . 98018) (PRINTPARA 98020 . 99118) (
+PRINTPARA1 99120 . 102108)) (102146 104431 (SUBLIS 102156 . 102764) (SUBPAIR 102766 . 103994) (DSUBLIS
+ 103996 . 104429)) (104454 105054 (CONSTANTOK 104464 . 105052)) (107132 107837 (NLAMBDA.ARGS 107142 . 
+107835)))))
 STOP
diff --git a/sources/MACHINEINDEPENDENT.LCOM b/sources/MACHINEINDEPENDENT.LCOM
index db5b998c..00fd88da 100644
Binary files a/sources/MACHINEINDEPENDENT.LCOM and b/sources/MACHINEINDEPENDENT.LCOM differ
