diff --git a/sources/CMLARITH b/sources/CMLARITH
index 9e0d3a7a..86733ee2 100644
--- a/sources/CMLARITH
+++ b/sources/CMLARITH
@@ -1,15 +1,17 @@
-(DEFINE-FILE-INFO READTABLE "XCL" PACKAGE "LISP")
-(IL:FILECREATED " 4-Jan-93 17:38:48" IL:|{DSK}<python>lde>lispcore>sources>CMLARITH.;2| 102283 
+(DEFINE-FILE-INFO PACKAGE "LISP" READTABLE "XCL" BASE 10)
 
-      IL:|previous| IL:|date:| "16-May-90 12:46:36" IL:|{DSK}<python>lde>lispcore>sources>CMLARITH.;1|
-)
+(IL:FILECREATED "23-Sep-2023 23:15:39" IL:|{WMEDLEY}<sources>CMLARITH.;2| 100545 
+
+      :EDIT-BY IL:|rmk|
+
+      :PREVIOUS-DATE " 4-Jan-93 17:38:48" IL:|{WMEDLEY}<sources>CMLARITH.;1|)
 
 
-; Copyright (c) 1985, 1986, 1987, 1988, 1989, 1990, 1993 by Venue & Xerox Corporation.  All rights reserved.
+; Copyright (c) 1985-1990, 1993 by Venue & Xerox Corporation.
 
 (IL:PRETTYCOMPRINT IL:CMLARITHCOMS)
 
-(IL:RPAQQ IL:CMLARITHCOMS 
+(IL:RPAQQ IL:CMLARITHCOMS
           (
 
 (IL:* IL:|;;;| "Common Lisp Arithmetic ")
@@ -64,14 +66,14 @@
 
                   
                   (IL:* IL:|;;| 
-             "cl:floatp is defined in cmltypes (has an optimizer). il:floatp is defined on llbasic")
+               "cl:floatp is defined in cmltypes (has an optimizer). il:floatp is defined on llbasic")
 
                   
                   (IL:* IL:|;;| "cl:complexp is a defstruct predicate (compiles in line)")
 
                   
                   (IL:* IL:|;;| 
-           "cl:numberp is defined in cmltypes (has an optimizer). il:numberp is defined on llbasic")
+             "cl:numberp is defined in cmltypes (has an optimizer). il:numberp is defined on llbasic")
 )
            (IL:COMS 
 
@@ -79,7 +81,7 @@
 
                   
                   (IL:* IL:|;;| 
-       "cl:zerop  is not shared with il:zerop, although they are equivalent. There is no il;plusp ")
+         "cl:zerop  is not shared with il:zerop, although they are equivalent. There is no il;plusp ")
 
                   (IL:COMS (IL:FUNCTIONS ZEROP PLUSP)
                          (XCL:OPTIMIZERS ZEROP PLUSP))
@@ -102,24 +104,24 @@
                                                              (IL:* IL:\; "For the byte compiler")
                          (IL:PROP IL:DMACRO %> %< %>= %<=)
                          (IL:DECLARE\: IL:DONTEVAL@LOAD IL:DOCOPY (IL:P 
-                                                                        (IL:* IL:|;;|
-                                                                      "Backward compatibility")
+                                                                        (IL:* IL:|;;| 
+                                                                        "Backward compatibility")
 
                                                                         
                                                              (IL:* IL:\; 
-                                           " il:%= is listed as the punt function for the = opcode")
+                                             " il:%= is listed as the punt function for the = opcode")
                                                                         (IL:MOVD '%= 'IL:%=)
                                                                         
                                                              (IL:* IL:\; 
-                    "Greaterp is the UFN for the greaterp opcode. Effectively redefines the opcode")
+                      "Greaterp is the UFN for the greaterp opcode. Effectively redefines the opcode")
                                                                         (IL:MOVD '%> 'IL:GREATERP)
                                                                         
                                                              (IL:* IL:\; 
-                                              "Interlisp Greaterp and Lessp are defined in llarith")
+                                                "Interlisp Greaterp and Lessp are defined in llarith")
                                                                         (IL:MOVD '%< 'IL:LESSP))))
                   
                   (IL:* IL:|;;| 
-                "=, <, >, <=, and >= are shared with il:, but cl:/= is NOT shared (?!)")
+                  "=, <, >, <=, and >= are shared with il:, but cl:/= is NOT shared (?!)")
 
                   (IL:COMS (IL:DECLARE\: IL:DONTCOPY IL:DOEVAL@COMPILE (IL:FUNCTIONS 
                                                                               %COMPARISON-MACRO))
@@ -143,14 +145,14 @@
                                                              (IL:* IL:\; "For the byte compiler")
                          (IL:PROP IL:DMACRO %+ %- %*)
                          (IL:DECLARE\: IL:DONTEVAL@LOAD IL:DOCOPY (IL:P 
-                                                                        (IL:* IL:|;;|
-                                                                      "Backward compatibility")
+                                                                        (IL:* IL:|;;| 
+                                                                        "Backward compatibility")
 
                                                                         (IL:MOVD '%/ 'IL:%/)
                                                                         
 
                                                           (IL:* IL:|;;| 
-               "Redefine UFNs for generic plus, difference, and times. Old UFN defined in llarith.")
+                 "Redefine UFNs for generic plus, difference, and times. Old UFN defined in llarith.")
 
                                                                         (IL:MOVD '%+ 'IL:\\SLOWPLUS2)
                                                                         (IL:MOVD '%- 
@@ -174,7 +176,7 @@
                                                                         
 
                                                                      (IL:* IL:|;;| 
-                                   "So Interlisp quotient will do something reasonable with ratios")
+                                     "So Interlisp quotient will do something reasonable with ratios")
 
                                                                         (IL:* (IL:MOVD 
                                                                                      'IL:NEW-QUOTIENT
@@ -182,7 +184,7 @@
                                                                         
 
                                                       (IL:* IL:|;;| 
-      "because QUOTIENT is already defined in LLARITH to do something useful with ratios. AR 8062.")
+        "because QUOTIENT is already defined in LLARITH to do something useful with ratios. AR 8062.")
 )))
                   
                   (IL:* IL:|;;| "INCF and DECF implemented by CMLSETF.")
@@ -192,7 +194,7 @@
            (IL:COMS 
 
                   (IL:* IL:|;;| 
-              "Optimizers for Interlisp functions, so that they compile open with the PavCompiler.")
+                "Optimizers for Interlisp functions, so that they compile open with the PavCompiler.")
 
                   
                   (IL:* IL:|;;| "optimizer of IL:minus")
@@ -220,11 +222,11 @@
 
                   (IL:DECLARE\: IL:DONTCOPY IL:DOEVAL@COMPILE (IL:FILES IL:UNBOXEDOPS))
                                                              (IL:* IL:\; 
-                                                           "These should be exported from xcl")
+                                                             "These should be exported from xcl")
                   (IL:COMS (IL:FUNCTIONS XCL::STRUNCATE XCL::SFLOOR XCL::SCEILING XCL::SROUND)
                          (XCL:OPTIMIZERS XCL::STRUNCATE XCL::SROUND))
                                                              (IL:* IL:\; 
-                                                           "Round is shared with il: (?!)")
+                                                             "Round is shared with il: (?!)")
                   (IL:COMS (IL:DECLARE\: IL:DONTCOPY IL:DOEVAL@COMPILE (IL:FUNCTIONS 
                                                                               %INTEGER-COERCE-MACRO))
                          (IL:FUNCTIONS TRUNCATE FLOOR CEILING ROUND)
@@ -340,9 +342,9 @@
 
 
 (DEFSTRUCT (RATIO (:CONSTRUCTOR %MAKE-RATIO (NUMERATOR DENOMINATOR))
-                      (:PREDICATE %RATIO-P)
-                      (:COPIER NIL)
-                      (:PRINT-FUNCTION %RATIO-PRINT))
+                  (:PREDICATE %RATIO-P)
+                  (:COPIER NIL)
+                  (:PRINT-FUNCTION %RATIO-PRINT))
    (NUMERATOR :READ-ONLY)
    (DENOMINATOR :READ-ONLY))
 
@@ -385,7 +387,7 @@
         (COND
            ((NOT (IL:|fetch| (READTABLEP IL:COMMONNUMSYNTAX) IL:|of| *READTABLE*))
                                                              (IL:* IL:\; 
-                                                       "Can't print nice ratios to old read tables")
+                                                         "Can't print nice ratios to old read tables")
             (IL:PRIN1 "|." STREAM)
             (IL:\\PRINDATUM (LIST '/ TOP BOTTOM)
                    STREAM))
@@ -395,30 +397,31 @@
               (IF *PRINT-RADIX*
                   (SETQ PR (CONCATENATE 'STRING (STRING (CODE-CHAR (IL:|fetch| (READTABLEP 
                                                                                      IL:HASHMACROCHAR
-                                                                                          )
-                                                                      IL:|of| *READTABLE*)))
+                                                                                      ) IL:|of|
+                                                                                        *READTABLE*))
+                                                       )
                                   (CASE *PRINT-BASE*
                                       (2                     (IL:* IL:\; "Binary")
                                          "b")
                                       (8 "o")
                                       (16 "x")
                                       (T                     (IL:* IL:\; 
-                                                      "generalized radix prefix, even for decimal!")
+                                                        "generalized radix prefix, even for decimal!")
                                          (CONCATENATE 'STRING (LET* ((X *PRINT-BASE*)
                                                                      (*PRINT-BASE* 10)
                                                                      (*PRINT-RADIX* NIL))
                                                                     (PRINC-TO-STRING X))
                                                 "r"))))))
               (IL:.SPACECHECK. STREAM (+ 1 (IL:NCHARS TOP)
-                                             (IL:NCHARS BOTTOM)
-                                             (IF PR
-                                                 (IL:NCHARS PR)
-                                                 0)))
+                                         (IL:NCHARS BOTTOM)
+                                         (IF PR
+                                             (IL:NCHARS PR)
+                                             0)))
               (LET ((IL:\\THISFILELINELENGTH NIL)
                     (*PRINT-RADIX* NIL))
                    (DECLARE (IL:SPECVARS IL:\\THISFILELINELENGTH))
                                                              (IL:* IL:\; 
-                "Turn off linelength check just in case the NCHARS count is off because of radices")
+                  "Turn off linelength check just in case the NCHARS count is off because of radices")
                    (IF PR (IL:\\SOUT PR STREAM))
                    (IL:\\PRINDATUM TOP STREAM)
                    (IL:\\SOUT "/" STREAM)
@@ -427,7 +430,7 @@
 (DEFUN %BUILD-RATIO (X Y)
 
    (IL:* IL:|;;| 
-"%BUILD-RATIO takes two integer arguments and builds the rational number which is their quotient.  ")
+ "%BUILD-RATIO takes two integer arguments and builds the rational number which is their quotient.  ")
 
    (LET ((REM (IL:IREMAINDER X Y)))
         (IF (EQ 0 REM)
@@ -467,11 +470,11 @@
    (LET ((GCD-D (%GCD DENOMINATOR-1 DENOMINATOR-2)))
         (IF (EQ GCD-D 1)
             (%MAKE-RATIO (+ (* NUMERATOR-1 DENOMINATOR-2)
-                                (* NUMERATOR-2 DENOMINATOR-1))
+                            (* NUMERATOR-2 DENOMINATOR-1))
                    (* DENOMINATOR-1 DENOMINATOR-2))
             (LET* ((D1/GCD-D (IL:IQUOTIENT DENOMINATOR-1 GCD-D))
                    (TOP (+ (* NUMERATOR-1 (IL:IQUOTIENT DENOMINATOR-2 GCD-D))
-                               (* NUMERATOR-2 D1/GCD-D)))
+                           (* NUMERATOR-2 D1/GCD-D)))
                    (GCD-TOP (%GCD TOP GCD-D))
                    (D2/GCD-TOP DENOMINATOR-2))
                   (UNLESS (EQ GCD-TOP 1)
@@ -506,9 +509,9 @@
 
 
 (DEFSTRUCT (COMPLEX (:CONSTRUCTOR %MAKE-COMPLEX (REALPART IMAGPART))
-                        (:PREDICATE COMPLEXP)
-                        (:COPIER NIL)
-                        (:PRINT-FUNCTION %COMPLEX-PRINT))
+                    (:PREDICATE COMPLEXP)
+                    (:COPIER NIL)
+                    (:PRINT-FUNCTION %COMPLEX-PRINT))
    (REALPART :READ-ONLY)
    (IMAGPART :READ-ONLY))
 
@@ -592,7 +595,7 @@
    (LET ((REALPART (COMPLEX-REALPART NUMBER))
          (IMAGPART (COMPLEX-IMAGPART NUMBER)))
         (IL:.SPACECHECK. STREAM (+ 5 (IL:NCHARS REALPART)
-                                       (IL:NCHARS IMAGPART)))
+                                   (IL:NCHARS IMAGPART)))
         (IL:\\OUTCHAR STREAM (IL:FETCH (READTABLEP IL:HASHMACROCHAR) IL:OF *READTABLE*))
         (IL:\\SOUT "C" STREAM)
         (IL:\\SOUT "(" STREAM)
@@ -632,30 +635,30 @@
        (COMPLEX (* REAL-1 REAL-2)
               (* IMAG-1 REAL-2)))
       (T (COMPLEX (- (* REAL-1 REAL-2)
-                             (* IMAG-1 IMAG-2))
+                     (* IMAG-1 IMAG-2))
                 (+ (* IMAG-1 REAL-2)
-                       (* REAL-1 IMAG-2))))))
+                   (* REAL-1 IMAG-2))))))
 
 (DEFUN %COMPLEX-/ (REAL-1 IMAG-1 REAL-2 IMAG-2)
    (COND
       ((= 0 IMAG-1)
        (LET ((MODULUS (+ (* REAL-2 REAL-2)
-                             (* IMAG-2 IMAG-2))))
+                         (* IMAG-2 IMAG-2))))
             (COMPLEX (/ (* REAL-1 REAL-2)
-                                MODULUS)
+                        MODULUS)
                    (/ (- (* REAL-1 IMAG-2))
-                          MODULUS))))
+                      MODULUS))))
       ((= 0 IMAG-2)
        (COMPLEX (/ REAL-1 REAL-2)
               (/ IMAG-1 REAL-2)))
       (T (LET ((MODULUS (+ (* REAL-2 REAL-2)
-                               (* IMAG-2 IMAG-2))))
+                           (* IMAG-2 IMAG-2))))
               (COMPLEX (/ (+ (* REAL-1 REAL-2)
-                                         (* IMAG-1 IMAG-2))
-                                  MODULUS)
+                             (* IMAG-1 IMAG-2))
+                          MODULUS)
                      (/ (- (* IMAG-1 REAL-2)
-                                   (* REAL-1 IMAG-2))
-                            MODULUS))))))
+                           (* REAL-1 IMAG-2))
+                        MODULUS))))))
 
 (DEFUN %COMPLEX-ABS (Z)
    (LET ((X (FLOAT (COMPLEX-REALPART Z)))
@@ -665,7 +668,7 @@
         (IL:* IL:|;;| "Might want to use a BLUE algorithm here")
 
         (SQRT (SETQ X (+ (* X X)
-                             (* Y Y))))))
+                         (* Y Y))))))
 
 
 
@@ -679,8 +682,7 @@
 
 
 
-(IL:* IL:|;;| "cl:floatp is defined in cmltypes (has an optimizer). il:floatp is defined on llbasic"
-)
+(IL:* IL:|;;| "cl:floatp is defined in cmltypes (has an optimizer). il:floatp is defined on llbasic")
 
 
 
@@ -690,8 +692,8 @@
 
 
 
-(IL:* IL:|;;| 
-"cl:numberp is defined in cmltypes (has an optimizer). il:numberp is defined on llbasic")
+(IL:* IL:|;;| "cl:numberp is defined in cmltypes (has an optimizer). il:numberp is defined on llbasic"
+)
 
 
 
@@ -712,10 +714,10 @@
    (> NUMBER 0))
 
 (XCL:DEFOPTIMIZER ZEROP (NUMBER)
-                            `(= 0 ,NUMBER))
+                        `(= 0 ,NUMBER))
 
 (XCL:DEFOPTIMIZER PLUSP (NUMBER)
-                            `(> ,NUMBER 0))
+                        `(> ,NUMBER 0))
 
 
 
@@ -728,7 +730,7 @@
    (< NUMBER 0))
 
 (XCL:DEFOPTIMIZER MINUSP (NUMBER)
-                             `(< ,NUMBER 0))
+                         `(< ,NUMBER 0))
 
 
 
@@ -750,16 +752,16 @@
        (NOT (ZEROP (MOD INTEGER MODULUS)))))
 
 (XCL:DEFOPTIMIZER EVENP (INTEGER &OPTIONAL (MODULUS NIL MODULUS-P))
-                            (IF (NULL MODULUS-P)
-                                `(EQ (LOGAND ,INTEGER 1)
-                                     0)
-                                'COMPILER:PASS))
+                        (IF (NULL MODULUS-P)
+                            `(EQ (LOGAND ,INTEGER 1)
+                                 0)
+                            'COMPILER:PASS))
 
 (XCL:DEFOPTIMIZER ODDP (INTEGER &OPTIONAL (MODULUS NIL MODULUS-P))
-                           (IF (NULL MODULUS-P)
-                               `(EQ (LOGAND ,INTEGER 1)
-                                    1)
-                               'COMPILER:PASS))
+                       (IF (NULL MODULUS-P)
+                           `(EQ (LOGAND ,INTEGER 1)
+                                1)
+                           'COMPILER:PASS))
 
 
 
@@ -798,9 +800,9 @@
                   (OTHERWISE (%NOT-NUMBER-ERROR Y))))
        (COMPLEX (TYPECASE Y
                     (COMPLEX (AND (= (COMPLEX-REALPART X)
-                                         (COMPLEX-REALPART Y))
+                                     (COMPLEX-REALPART Y))
                                   (= (COMPLEX-IMAGPART X)
-                                         (COMPLEX-IMAGPART Y))))
+                                     (COMPLEX-IMAGPART Y))))
                     (NUMBER (AND (= Y (COMPLEX-REALPART X))
                                  (= 0 (COMPLEX-IMAGPART X))))
                     (OTHERWISE (%NOT-NUMBER-ERROR Y))))
@@ -815,33 +817,33 @@
 
    (IL:* IL:|;;| "Compiles out to greaterp opcode")
                                                              (IL:* IL:\; 
-                                                           "So we appear as > in a frame backtrace")
+                                                             "So we appear as > in a frame backtrace")
    (IL:\\CALLME '>)
    (TYPECASE X
        (INTEGER (TYPECASE Y
                     (INTEGER (IL:IGREATERP X Y))
                     (FLOAT (IL:FGREATERP X Y))
                     (RATIO (IL:IGREATERP (* (RATIO-DENOMINATOR Y)
-                                                X)
+                                            X)
                                   (RATIO-NUMERATOR Y)))
                     (OTHERWISE (%NOT-NONCOMPLEX-NUMBER-ERROR Y))))
        (FLOAT (TYPECASE Y
                   ((OR INTEGER FLOAT) (IL:FGREATERP X Y))
                   (RATIO (IL:FGREATERP (* (RATIO-DENOMINATOR Y)
-                                              X)
+                                          X)
                                 (RATIO-NUMERATOR Y)))
                   (OTHERWISE (%NOT-NONCOMPLEX-NUMBER-ERROR Y))))
        (RATIO (TYPECASE Y
                   (INTEGER (IL:IGREATERP (RATIO-NUMERATOR X)
                                   (* (RATIO-DENOMINATOR X)
-                                         Y)))
+                                     Y)))
                   (FLOAT (IL:FGREATERP (RATIO-NUMERATOR X)
                                 (* (RATIO-DENOMINATOR X)
-                                       Y)))
+                                   Y)))
                   (RATIO (IL:IGREATERP (* (RATIO-NUMERATOR X)
-                                              (RATIO-DENOMINATOR Y))
+                                          (RATIO-DENOMINATOR Y))
                                 (* (RATIO-NUMERATOR Y)
-                                       (RATIO-DENOMINATOR X))))
+                                   (RATIO-DENOMINATOR X))))
                   (OTHERWISE (%NOT-NONCOMPLEX-NUMBER-ERROR Y))))
        (OTHERWISE (%NOT-NONCOMPLEX-NUMBER-ERROR X))))
 
@@ -854,24 +856,24 @@
 (DEFMACRO %<= (X Y)
    `(NOT (%> ,X ,Y)))
 
-(IL:PUTPROPS %= IL:DOPVAL (2 =))
+(IL:PUTPROPS %= IL:DOPVAL (2 =))
 
-(IL:PUTPROPS %> IL:DOPVAL (2 IL:GREATERP))
+(IL:PUTPROPS %> IL:DOPVAL (2 IL:GREATERP))
 
-(IL:PUTPROPS %< IL:DOPVAL (2 IL:SWAP IL:GREATERP))
+(IL:PUTPROPS %< IL:DOPVAL (2 IL:SWAP IL:GREATERP))
 
 
 
 (IL:* IL:\; "For the byte compiler")
 
 
-(IL:PUTPROPS %> IL:DMACRO (= . IL:GREATERP))
+(IL:PUTPROPS %> IL:DMACRO (= . IL:GREATERP))
 
-(IL:PUTPROPS %< IL:DMACRO (= . IL:LESSP))
+(IL:PUTPROPS %< IL:DMACRO (= . IL:LESSP))
 
-(IL:PUTPROPS %>= IL:DMACRO (= . IL:GEQ))
+(IL:PUTPROPS %>= IL:DMACRO (= . IL:GEQ))
 
-(IL:PUTPROPS %<= IL:DMACRO (= . IL:LEQ))
+(IL:PUTPROPS %<= IL:DMACRO (= . IL:LEQ))
 (IL:DECLARE\: IL:DONTEVAL@LOAD IL:DOCOPY 
 
 
@@ -879,17 +881,17 @@
 
 
                                                              (IL:* IL:\; 
-                                           " il:%= is listed as the punt function for the = opcode")
+                                             " il:%= is listed as the punt function for the = opcode")
 
 (IL:MOVD '%= 'IL:%=)
 
                                                              (IL:* IL:\; 
-                    "Greaterp is the UFN for the greaterp opcode. Effectively redefines the opcode")
+                      "Greaterp is the UFN for the greaterp opcode. Effectively redefines the opcode")
 
 (IL:MOVD '%> 'IL:GREATERP)
 
                                                              (IL:* IL:\; 
-                                              "Interlisp Greaterp and Lessp are defined in llarith")
+                                                "Interlisp Greaterp and Lessp are defined in llarith")
 
 (IL:MOVD '%< 'IL:LESSP)
 )
@@ -977,58 +979,56 @@
       ((NULL THIRD-NUMBER)
        `(,PREDICATE ,FIRST-NUMBER ,SECOND-NUMBER))
       (T `((IL:OPENLAMBDA (SI::%$$COMPARISON-FIRST-NUMBER SI::%$$COMPARISON-MIDDLE-NUMBER)
-                  (AND (,PREDICATE SI::%$$COMPARISON-FIRST-NUMBER SI::%$$COMPARISON-MIDDLE-NUMBER)
-                       (,PREDICATE SI::%$$COMPARISON-MIDDLE-NUMBER ,THIRD-NUMBER)))
+             (AND (,PREDICATE SI::%$$COMPARISON-FIRST-NUMBER SI::%$$COMPARISON-MIDDLE-NUMBER)
+                  (,PREDICATE SI::%$$COMPARISON-MIDDLE-NUMBER ,THIRD-NUMBER)))
            ,FIRST-NUMBER
            ,SECOND-NUMBER))))
 
 (XCL:DEFOPTIMIZER = (FIRST-NUMBER &OPTIONAL (SECOND-NUMBER NIL SECOND-NUMBER-P)
-                               &REST MORE-NUMBERS)
-                        (COND
-                           ((NULL SECOND-NUMBER-P)
-                            'COMPILER:PASS)
-                           ((NULL MORE-NUMBERS)
-                            `(%= ,FIRST-NUMBER ,SECOND-NUMBER))
-                           (T
-                            (SETQ MORE-NUMBERS (CONS SECOND-NUMBER MORE-NUMBERS))
-                            `((IL:OPENLAMBDA
-                               (SI::%$$=FIRST-NUMBER)
-                               (AND ,@(LET ((RESULT NIL)
-                                            (RESULT-TAIL NIL))
-                                           (DOLIST (NUMBER MORE-NUMBERS RESULT)
-                                               (%LIST-COLLECT RESULT RESULT-TAIL
-                                                      (LIST `(%= SI::%$$=FIRST-NUMBER
-                                                                    ,NUMBER)))))))
-                              ,FIRST-NUMBER))))
+                           &REST MORE-NUMBERS)
+                    (COND
+                       ((NULL SECOND-NUMBER-P)
+                        'COMPILER:PASS)
+                       ((NULL MORE-NUMBERS)
+                        `(%= ,FIRST-NUMBER ,SECOND-NUMBER))
+                       (T
+                        (SETQ MORE-NUMBERS (CONS SECOND-NUMBER MORE-NUMBERS))
+                        `((IL:OPENLAMBDA (SI::%$$=FIRST-NUMBER)
+                            (AND ,@(LET ((RESULT NIL)
+                                         (RESULT-TAIL NIL))
+                                        (DOLIST (NUMBER MORE-NUMBERS RESULT)
+                                            (%LIST-COLLECT RESULT RESULT-TAIL
+                                                   (LIST `(%= SI::%$$=FIRST-NUMBER ,NUMBER)))))))
+                          ,FIRST-NUMBER))))
 
 (XCL:DEFOPTIMIZER /= (FIRST-NUMBER &OPTIONAL (SECOND-NUMBER NIL SECOND-NUMBER-P)
-                                &REST MORE-NUMBERS)
-                         (COND
-                            ((NULL SECOND-NUMBER-P)
-                             'COMPILER:PASS)
-                            ((NULL MORE-NUMBERS)
-                             `(%/= ,FIRST-NUMBER ,SECOND-NUMBER))
-                            (T 'COMPILER:PASS)))
+                            &REST MORE-NUMBERS)
+                     (COND
+                        ((NULL SECOND-NUMBER-P)
+                         'COMPILER:PASS)
+                        ((NULL MORE-NUMBERS)
+                         `(%/= ,FIRST-NUMBER ,SECOND-NUMBER))
+                        (T 'COMPILER:PASS)))
 
 (XCL:DEFOPTIMIZER < (FIRST-NUMBER &OPTIONAL SECOND-NUMBER THIRD-NUMBER &REST MORE-NUMBERS)
-                        (IF (NULL MORE-NUMBERS)
-                            (%COMPARISON-OPTIMIZER '%< FIRST-NUMBER SECOND-NUMBER THIRD-NUMBER)
-                            'COMPILER:PASS))
+                    (IF (NULL MORE-NUMBERS)
+                        (%COMPARISON-OPTIMIZER '%< FIRST-NUMBER SECOND-NUMBER THIRD-NUMBER)
+                        'COMPILER:PASS))
 
 (XCL:DEFOPTIMIZER > (FIRST-NUMBER &OPTIONAL SECOND-NUMBER THIRD-NUMBER &REST MORE-NUMBERS)
-                        (IF (NULL MORE-NUMBERS)
-                            (%COMPARISON-OPTIMIZER '%> FIRST-NUMBER SECOND-NUMBER THIRD-NUMBER)
-                            'COMPILER:PASS))
+                    (IF (NULL MORE-NUMBERS)
+                        (%COMPARISON-OPTIMIZER '%> FIRST-NUMBER SECOND-NUMBER THIRD-NUMBER)
+                        'COMPILER:PASS))
 
 (XCL:DEFOPTIMIZER <= (FIRST-NUMBER &OPTIONAL SECOND-NUMBER THIRD-NUMBER &REST MORE-NUMBERS)
-                         (IF (NULL MORE-NUMBERS)
-                             (%COMPARISON-OPTIMIZER '%<= FIRST-NUMBER SECOND-NUMBER THIRD-NUMBER)
-                             'COMPILER:PASS))
+                     (IF (NULL MORE-NUMBERS)
+                         (%COMPARISON-OPTIMIZER '%<= FIRST-NUMBER SECOND-NUMBER THIRD-NUMBER)
+                         'COMPILER:PASS))
 
 (XCL:DEFOPTIMIZER >= (FIRST-NUMBER &OPTIONAL SECOND-NUMBER THIRD-NUMBER &REST MORE-NUMBERS)
-                         (IF (NULL MORE-NUMBERS)
-                             (%COMPARISON-OPTIMIZER '%>= FIRST-NUMBER SECOND-NUMBER THIRD-NUMBER)
-                             'COMPILER:PASS))
+                     (IF (NULL MORE-NUMBERS)
+                         (%COMPARISON-OPTIMIZER '%>= FIRST-NUMBER SECOND-NUMBER THIRD-NUMBER)
+                         'COMPILER:PASS))
 
 
 
@@ -1045,30 +1045,30 @@
 
 
 (XCL:DEFOPTIMIZER MIN (&OPTIONAL (X NIL X-P)
-                                 (Y NIL Y-P)
-                                 &REST OTHER-NUMBERS)
-                          (IF (AND (NULL OTHER-NUMBERS)
-                                   X-P Y-P)
-                              `((IL:OPENLAMBDA (SI::%$$MIN-X SI::%$$MIN-Y)
-                                       (IF (< SI::%$$MIN-X SI::%$$MIN-Y)
-                                           SI::%$$MIN-X
-                                           SI::%$$MIN-Y))
-                                ,X
-                                ,Y)
-                              'COMPILER:PASS))
+                             (Y NIL Y-P)
+                             &REST OTHER-NUMBERS)
+                      (IF (AND (NULL OTHER-NUMBERS)
+                               X-P Y-P)
+                          `((IL:OPENLAMBDA (SI::%$$MIN-X SI::%$$MIN-Y)
+                              (IF (< SI::%$$MIN-X SI::%$$MIN-Y)
+                                  SI::%$$MIN-X
+                                  SI::%$$MIN-Y))
+                            ,X
+                            ,Y)
+                          'COMPILER:PASS))
 
 (XCL:DEFOPTIMIZER MAX (&OPTIONAL (X NIL X-P)
-                                 (Y NIL Y-P)
-                                 &REST OTHER-NUMBERS)
-                          (IF (AND (NULL OTHER-NUMBERS)
-                                   X-P Y-P)
-                              `((IL:OPENLAMBDA (SI::%$$MAX-X SI::%$$MAX-Y)
-                                       (IF (> SI::%$$MAX-X SI::%$$MAX-Y)
-                                           SI::%$$MAX-X
-                                           SI::%$$MAX-Y))
-                                ,X
-                                ,Y)
-                              'COMPILER:PASS))
+                             (Y NIL Y-P)
+                             &REST OTHER-NUMBERS)
+                      (IF (AND (NULL OTHER-NUMBERS)
+                               X-P Y-P)
+                          `((IL:OPENLAMBDA (SI::%$$MAX-X SI::%$$MAX-Y)
+                              (IF (> SI::%$$MAX-X SI::%$$MAX-Y)
+                                  SI::%$$MAX-X
+                                  SI::%$$MAX-Y))
+                            ,X
+                            ,Y)
+                          'COMPILER:PASS))
 
 
 
@@ -1255,7 +1255,7 @@
            (FLOAT (TYPECASE Y
                       ((OR INTEGER FLOAT) (IL:FQUOTIENT X Y))
                       (RATIO (IL:FQUOTIENT (* (RATIO-DENOMINATOR Y)
-                                                  X)
+                                              X)
                                     (RATIO-NUMERATOR Y)))
                       (COMPLEX (%COMPLEX-/ X 0.0 (COMPLEX-REALPART Y)
                                       (COMPLEX-IMAGPART Y)))
@@ -1266,7 +1266,7 @@
                                       1 Y))
                       (FLOAT (IL:FQUOTIENT (RATIO-NUMERATOR X)
                                     (* (RATIO-DENOMINATOR X)
-                                           Y)))
+                                       Y)))
                       (RATIO (%RATIO-TIMES (RATIO-NUMERATOR X)
                                     (RATIO-DENOMINATOR X)
                                     (RATIO-DENOMINATOR Y)
@@ -1295,22 +1295,22 @@
 )
 
 
-(IL:PUTPROPS %+ IL:DOPVAL (2 IL:PLUS2))
+(IL:PUTPROPS %+ IL:DOPVAL (2 IL:PLUS2))
 
-(IL:PUTPROPS %- IL:DOPVAL (2 IL:DIFFERENCE))
+(IL:PUTPROPS %- IL:DOPVAL (2 IL:DIFFERENCE))
 
-(IL:PUTPROPS %* IL:DOPVAL (2 IL:TIMES2))
+(IL:PUTPROPS %* IL:DOPVAL (2 IL:TIMES2))
 
 
 
 (IL:* IL:\; "For the byte compiler")
 
 
-(IL:PUTPROPS %+ IL:DMACRO (= . IL:PLUS))
+(IL:PUTPROPS %+ IL:DMACRO (= . IL:PLUS))
 
-(IL:PUTPROPS %- IL:DMACRO (= . IL:DIFFERENCE))
+(IL:PUTPROPS %- IL:DMACRO (= . IL:DIFFERENCE))
 
-(IL:PUTPROPS %* IL:DMACRO (= . IL:TIMES))
+(IL:PUTPROPS %* IL:DMACRO (= . IL:TIMES))
 (IL:DECLARE\: IL:DONTEVAL@LOAD IL:DOCOPY 
 
 
@@ -1401,55 +1401,55 @@
        (/ 1 NUMBER)))
 
 (XCL:DEFOPTIMIZER + (&REST NUMBERS)
-                        (IF (NULL NUMBERS)
-                            0
-                            (LET ((FORM (CAR NUMBERS)))
-                                 (DOLIST (NUM (CDR NUMBERS)
-                                              FORM)
-                                     (SETQ FORM `(%+ ,FORM ,NUM))))))
+                    (IF (NULL NUMBERS)
+                        0
+                        (LET ((FORM (CAR NUMBERS)))
+                             (DOLIST (NUM (CDR NUMBERS)
+                                          FORM)
+                                 (SETQ FORM `(%+ ,FORM ,NUM))))))
 
 (XCL:DEFOPTIMIZER - (NUMBER &REST NUMBERS)
-                        (IF (NULL NUMBERS)
-                            `(%- 0 ,NUMBER)
-                            (LET ((FORM NUMBER))
-                                 (DOLIST (NUM NUMBERS FORM)
-                                     (SETQ FORM `(%- ,FORM ,NUM))))))
+                    (IF (NULL NUMBERS)
+                        `(%- 0 ,NUMBER)
+                        (LET ((FORM NUMBER))
+                             (DOLIST (NUM NUMBERS FORM)
+                                 (SETQ FORM `(%- ,FORM ,NUM))))))
 
 (XCL:DEFOPTIMIZER * (&REST NUMBERS)
-                        (IF (NULL NUMBERS)
-                            1
-                            (LET ((FORM (CAR NUMBERS)))
-                                 (DOLIST (NUM (CDR NUMBERS)
-                                              FORM)
-                                     (SETQ FORM `(%* ,FORM ,NUM))))))
+                    (IF (NULL NUMBERS)
+                        1
+                        (LET ((FORM (CAR NUMBERS)))
+                             (DOLIST (NUM (CDR NUMBERS)
+                                          FORM)
+                                 (SETQ FORM `(%* ,FORM ,NUM))))))
 
 (XCL:DEFOPTIMIZER / (NUMBER &REST NUMBERS)
-                        (IF (NULL NUMBERS)
-                            `(%RECIPROCOL ,NUMBER)
-                            (LET ((FORM NUMBER))
-                                 (DOLIST (NUM NUMBERS FORM)
-                                     (SETQ FORM `(%/ ,FORM ,NUM))))))
+                    (IF (NULL NUMBERS)
+                        `(%RECIPROCOL ,NUMBER)
+                        (LET ((FORM NUMBER))
+                             (DOLIST (NUM NUMBERS FORM)
+                                 (SETQ FORM `(%/ ,FORM ,NUM))))))
 
 (XCL:DEFOPTIMIZER 1+ (NUMBER)
-                         `(+ ,NUMBER 1))
+                     `(+ ,NUMBER 1))
 
 (XCL:DEFOPTIMIZER 1- (NUMBER)
-                         `(- ,NUMBER 1))
+                     `(- ,NUMBER 1))
 
 
 
 (IL:* IL:\; "For the byte compiler")
 
 
-(IL:PUTPROPS + IL:DMACRO (IL:ARGS (IL:|if| (IL:GREATERP (IL:LENGTH IL:ARGS)
-                                                          1)
-                                          IL:|then| `(IL:PLUS ,@IL:ARGS)
-                                        IL:|else| 'IL:IGNOREMACRO)))
+(IL:PUTPROPS + IL:DMACRO (IL:ARGS (IL:|if| (IL:GREATERP (IL:LENGTH IL:ARGS)
+                                                  1)
+                                      IL:|then| `(IL:PLUS ,@IL:ARGS)
+                                    IL:|else| 'IL:IGNOREMACRO)))
 
-(IL:PUTPROPS * IL:DMACRO (IL:ARGS (IL:|if| (IL:GREATERP (IL:LENGTH IL:ARGS)
-                                                          1)
-                                          IL:|then| `(IL:TIMES ,@IL:ARGS)
-                                        IL:|else| 'IL:IGNOREMACRO)))
+(IL:PUTPROPS * IL:DMACRO (IL:ARGS (IL:|if| (IL:GREATERP (IL:LENGTH IL:ARGS)
+                                                  1)
+                                      IL:|then| `(IL:TIMES ,@IL:ARGS)
+                                    IL:|else| 'IL:IGNOREMACRO)))
 
 
 
@@ -1469,8 +1469,8 @@
 (IL:* IL:|;;| "So Interlisp quotient will do something reasonable with ratios")
 
 
-                                                             (IL:* (IL:MOVD (QUOTE 
-                                                           IL:NEW-QUOTIENT) (QUOTE IL:QUOTIENT)))
+                                                             (IL:* (IL:MOVD (QUOTE IL:NEW-QUOTIENT)
+                                                             (QUOTE IL:QUOTIENT)))
 
 
 (IL:* IL:|;;| 
@@ -1532,7 +1532,7 @@
               (IF (EQ GCD 1)
                   (* X Y)
                   (* (IL:IQUOTIENT X GCD)
-                         Y))))))
+                     Y))))))
 (IL:DEFINEQ
 
 (GCD
@@ -1585,73 +1585,73 @@
 
 
 (XCL:DEFOPTIMIZER IL:MINUS (IL:X)
-                               `(- 0 ,IL:X))
+                           `(- 0 ,IL:X))
 
 (XCL:DEFOPTIMIZER IL:PLUS (&REST NUMBERS)
-                              (IF (NULL NUMBERS)
-                                  0
-                                  (LET ((FORM (CAR NUMBERS)))
-                                       (DOLIST (NUM (CDR NUMBERS)
-                                                    FORM)
-                                           (SETQ FORM `(IL:PLUS2 ,FORM ,NUM))))))
+                          (IF (NULL NUMBERS)
+                              0
+                              (LET ((FORM (CAR NUMBERS)))
+                                   (DOLIST (NUM (CDR NUMBERS)
+                                                FORM)
+                                       (SETQ FORM `(IL:PLUS2 ,FORM ,NUM))))))
 
 (XCL:DEFOPTIMIZER IL:IPLUS (&REST NUMBERS)
-                               (IF (NULL NUMBERS)
-                                   0
-                                   (LET ((FORM (CAR NUMBERS)))
-                                        (COND
-                                           ((CDR NUMBERS)
-                                            (DOLIST (NUM (CDR NUMBERS)
-                                                         FORM)
-                                                (SETQ FORM `(IL:IPLUS2 ,FORM ,NUM))))
-                                           (T `(IL:IPLUS2 ,FORM 0))))))
+                           (IF (NULL NUMBERS)
+                               0
+                               (LET ((FORM (CAR NUMBERS)))
+                                    (COND
+                                       ((CDR NUMBERS)
+                                        (DOLIST (NUM (CDR NUMBERS)
+                                                     FORM)
+                                            (SETQ FORM `(IL:IPLUS2 ,FORM ,NUM))))
+                                       (T `(IL:IPLUS2 ,FORM 0))))))
 
 (XCL:DEFOPTIMIZER IL:FPLUS (&REST NUMBERS)
-                               (IF (NULL NUMBERS)
-                                   0
-                                   (LET ((FORM (CAR NUMBERS)))
-                                        (DOLIST (NUM (CDR NUMBERS)
-                                                     FORM)
-                                            (SETQ FORM `(IL:FPLUS2 ,FORM ,NUM))))))
+                           (IF (NULL NUMBERS)
+                               0
+                               (LET ((FORM (CAR NUMBERS)))
+                                    (DOLIST (NUM (CDR NUMBERS)
+                                                 FORM)
+                                        (SETQ FORM `(IL:FPLUS2 ,FORM ,NUM))))))
 
 (XCL:DEFOPTIMIZER IL:TIMES (&REST NUMBERS)
-                               (IF (NULL NUMBERS)
-                                   0
-                                   (LET ((FORM (CAR NUMBERS)))
-                                        (DOLIST (NUM (CDR NUMBERS)
-                                                     FORM)
-                                            (SETQ FORM `(IL:TIMES2 ,FORM ,NUM))))))
+                           (IF (NULL NUMBERS)
+                               0
+                               (LET ((FORM (CAR NUMBERS)))
+                                    (DOLIST (NUM (CDR NUMBERS)
+                                                 FORM)
+                                        (SETQ FORM `(IL:TIMES2 ,FORM ,NUM))))))
 
 (XCL:DEFOPTIMIZER IL:ITIMES (&REST NUMBERS)
-                                (IF (NULL NUMBERS)
-                                    0
-                                    (LET ((FORM (CAR NUMBERS)))
-                                         (DOLIST (NUM (CDR NUMBERS)
-                                                      FORM)
-                                             (SETQ FORM `(IL:ITIMES2 ,FORM ,NUM))))))
+                            (IF (NULL NUMBERS)
+                                0
+                                (LET ((FORM (CAR NUMBERS)))
+                                     (DOLIST (NUM (CDR NUMBERS)
+                                                  FORM)
+                                         (SETQ FORM `(IL:ITIMES2 ,FORM ,NUM))))))
 
 (XCL:DEFOPTIMIZER IL:FTIMES (&REST NUMBERS)
-                                (IF (NULL NUMBERS)
-                                    1.0
-                                    (LET ((FORM (CAR NUMBERS)))
-                                         (DOLIST (NUM (CDR NUMBERS)
-                                                      FORM)
-                                             (SETQ FORM `(IL:FTIMES2 ,FORM ,NUM))))))
+                            (IF (NULL NUMBERS)
+                                1.0
+                                (LET ((FORM (CAR NUMBERS)))
+                                     (DOLIST (NUM (CDR NUMBERS)
+                                                  FORM)
+                                         (SETQ FORM `(IL:FTIMES2 ,FORM ,NUM))))))
 
 (XCL:DEFOPTIMIZER IL:RSH (IL:VALUE IL:SHIFT-AMOUNT)
-                             `(IL:LSH ,IL:VALUE (IL:IMINUS ,IL:SHIFT-AMOUNT)))
+                         `(IL:LSH ,IL:VALUE (IL:IMINUS ,IL:SHIFT-AMOUNT)))
 
-(IL:PUTPROPS IL:PLUS2 IL:DOPVAL (2 IL:PLUS2))
+(IL:PUTPROPS IL:PLUS2 IL:DOPVAL (2 IL:PLUS2))
 
-(IL:PUTPROPS IL:IPLUS2 IL:DOPVAL (2 IL:IPLUS2))
+(IL:PUTPROPS IL:IPLUS2 IL:DOPVAL (2 IL:IPLUS2))
 
-(IL:PUTPROPS IL:FPLUS2 IL:DOPVAL (2 IL:FPLUS2))
+(IL:PUTPROPS IL:FPLUS2 IL:DOPVAL (2 IL:FPLUS2))
 
-(IL:PUTPROPS IL:TIMES2 IL:DOPVAL (2 IL:TIMES2))
+(IL:PUTPROPS IL:TIMES2 IL:DOPVAL (2 IL:TIMES2))
 
-(IL:PUTPROPS IL:ITIMES2 IL:DOPVAL (2 IL:ITIMES2))
+(IL:PUTPROPS IL:ITIMES2 IL:DOPVAL (2 IL:ITIMES2))
 
-(IL:PUTPROPS IL:FTIMES2 IL:DOPVAL (2 IL:FTIMES2))
+(IL:PUTPROPS IL:FTIMES2 IL:DOPVAL (2 IL:FTIMES2))
 
 
 
@@ -1669,19 +1669,19 @@
               :NAME INTEGER :VALUE INTEGER :MESSAGE "a nonnegative integer"))
    (LET* ((ILENGTH (INTEGER-LENGTH INTEGER))
           (LOW (ASH 1 (ASH (1- ILENGTH)
-                                 -1)))
+                           -1)))
           (HIGH (+ LOW (ASH LOW (IF (ODDP ILENGTH)
-                                            -1
-                                            0)))))
+                                    -1
+                                    0)))))
          (DO ((MID (ASH (+ LOW HIGH)
-                          -1)
+                        -1)
                    (ASH (+ LOW HIGH)
-                          -1)))
+                        -1)))
              ((<= (1- HIGH)
-                     LOW)
+                  LOW)
               LOW)
            (IF (<= (* MID MID)
-                      INTEGER)
+                   INTEGER)
                (SETQ LOW MID)
                (SETQ HIGH MID)))))
 
@@ -1699,7 +1699,7 @@
                   (- 0.0 NUMBER)
                   NUMBER))
        (RATIO (IF (< (RATIO-NUMERATOR NUMBER)
-                         0)
+                     0)
                   (%MAKE-RATIO (- 0 (RATIO-NUMERATOR NUMBER))
                          (RATIO-DENOMINATOR NUMBER))
                   NUMBER))
@@ -1711,9 +1711,9 @@
    (IL:* IL:|;;| "Integer version of abs")
 
    `((IL:OPENLAMBDA (X)
-            (IF (< X 0)
-                (- 0 X)
-                X))
+       (IF (< X 0)
+           (- 0 X)
+           X))
      ,INTEGER))
 
 (DEFUN SIGNUM (NUMBER)
@@ -1737,12 +1737,12 @@
    (IL:* IL:|;;| "Integer version of signum")
 
    `((IL:OPENLAMBDA (X)
-            (COND
-               ((EQ X 0)
-                0)
-               ((PLUSP X)
-                1)
-               (T -1)))
+       (COND
+          ((EQ X 0)
+           0)
+          ((PLUSP X)
+           1)
+          (T -1)))
      ,INTEGER))
 
 
@@ -1802,7 +1802,7 @@
                (T RESULT)))
        (LET ((RESULT (XCL::STRUNCATE NUMBER DIVISOR)))
             (IF (= (REM NUMBER DIVISOR)
-                       0)
+                   0)
                 RESULT
                 (IF (< NUMBER 0)
                     (IF (< DIVISOR 0)
@@ -1826,7 +1826,7 @@
                (T (1+ RESULT))))
        (LET ((RESULT (XCL::STRUNCATE NUMBER DIVISOR)))
             (IF (= (REM NUMBER DIVISOR)
-                       0)
+                   0)
                 RESULT
                 (IF (< NUMBER 0)
                     (IF (< DIVISOR 0)
@@ -1848,14 +1848,14 @@
            (IL:FIXR (/ NUMBER DIVISOR)))))
 
 (XCL:DEFOPTIMIZER XCL::STRUNCATE (NUMBER &OPTIONAL DIVISOR)
-                                     (IF (INTEGERP DIVISOR)
-                                         `(IL:IQUOTIENT ,NUMBER ,DIVISOR)
-                                         'COMPILER:PASS))
+                                 (IF (INTEGERP DIVISOR)
+                                     `(IL:IQUOTIENT ,NUMBER ,DIVISOR)
+                                     'COMPILER:PASS))
 
 (XCL:DEFOPTIMIZER XCL::SROUND (NUMBER &OPTIONAL (DIVISOR NIL DIVISOR-P))
-                                  (IF (NULL DIVISOR-P)
-                                      `(IL:FIXR ,NUMBER)
-                                      'COMPILER:PASS))
+                              (IF (NULL DIVISOR-P)
+                                  `(IL:FIXR ,NUMBER)
+                                  'COMPILER:PASS))
 
 
 
@@ -1909,16 +1909,16 @@
        'COMPILER:PASS))
 
 (XCL:DEFOPTIMIZER TRUNCATE (NUMBER &OPTIONAL DIVISOR XCL:&CONTEXT CONTEXT)
-                               (%INTEGER-COERCE-OPTIMIZER 'XCL::STRUNCATE NUMBER DIVISOR CONTEXT))
+                           (%INTEGER-COERCE-OPTIMIZER 'XCL::STRUNCATE NUMBER DIVISOR CONTEXT))
 
 (XCL:DEFOPTIMIZER FLOOR (NUMBER &OPTIONAL DIVISOR XCL:&CONTEXT CONTEXT)
-                            (%INTEGER-COERCE-OPTIMIZER 'XCL::SFLOOR NUMBER DIVISOR CONTEXT))
+                        (%INTEGER-COERCE-OPTIMIZER 'XCL::SFLOOR NUMBER DIVISOR CONTEXT))
 
 (XCL:DEFOPTIMIZER CEILING (NUMBER &OPTIONAL DIVISOR XCL:&CONTEXT CONTEXT)
-                              (%INTEGER-COERCE-OPTIMIZER 'XCL::SCEILING NUMBER DIVISOR CONTEXT))
+                          (%INTEGER-COERCE-OPTIMIZER 'XCL::SCEILING NUMBER DIVISOR CONTEXT))
 
 (XCL:DEFOPTIMIZER ROUND (NUMBER &OPTIONAL DIVISOR XCL:&CONTEXT CONTEXT)
-                            (%INTEGER-COERCE-OPTIMIZER 'XCL::SROUND NUMBER DIVISOR CONTEXT))
+                        (%INTEGER-COERCE-OPTIMIZER 'XCL::SROUND NUMBER DIVISOR CONTEXT))
 
 (DEFUN FTRUNCATE (NUMBER &OPTIONAL DIVISOR)
 
@@ -1945,18 +1945,16 @@
    (%INTEGER-COERCE-MACRO XCL::SROUND NUMBER DIVISOR T))
 
 (XCL:DEFOPTIMIZER FTRUNCATE (NUMBER &OPTIONAL DIVISOR XCL:&CONTEXT CONTEXT)
-                                (%INTEGER-COERCE-OPTIMIZER 'XCL::STRUNCATE NUMBER DIVISOR CONTEXT
-                                       T))
+                            (%INTEGER-COERCE-OPTIMIZER 'XCL::STRUNCATE NUMBER DIVISOR CONTEXT T))
 
 (XCL:DEFOPTIMIZER FFLOOR (NUMBER &OPTIONAL DIVISOR XCL:&CONTEXT CONTEXT)
-                             (%INTEGER-COERCE-OPTIMIZER 'XCL::SFLOOR NUMBER DIVISOR CONTEXT T))
+                         (%INTEGER-COERCE-OPTIMIZER 'XCL::SFLOOR NUMBER DIVISOR CONTEXT T))
 
 (XCL:DEFOPTIMIZER FCEILING (NUMBER &OPTIONAL DIVISOR XCL:&CONTEXT CONTEXT)
-                               (%INTEGER-COERCE-OPTIMIZER 'XCL::SCEILING NUMBER DIVISOR CONTEXT T
-                                      ))
+                           (%INTEGER-COERCE-OPTIMIZER 'XCL::SCEILING NUMBER DIVISOR CONTEXT T))
 
 (XCL:DEFOPTIMIZER FROUND (NUMBER &OPTIONAL DIVISOR XCL:&CONTEXT CONTEXT)
-                             (%INTEGER-COERCE-OPTIMIZER 'XCL::SROUND NUMBER DIVISOR CONTEXT T))
+                         (%INTEGER-COERCE-OPTIMIZER 'XCL::SROUND NUMBER DIVISOR CONTEXT T))
 
 (DEFUN MOD (NUMBER DIVISOR)
 
@@ -1969,7 +1967,7 @@
              REM)
             (DECLARE (TYPE FLOAT FX FY REM))
             (SETQ REM (- FX (* (FLOAT (IL:UFIX (IL:FQUOTIENT FX FY)))
-                                       FY)))
+                               FY)))
             (IF (IL:UFEQP REM 0.0)
                 0.0
                 (IF (IF (IL:UFGREATERP 0.0 FY)
@@ -1999,7 +1997,7 @@
              (FY (FLOAT DIVISOR)))
             (DECLARE (TYPE FLOAT FX FY))
             (SETQ FX (- FX (* (FLOAT (IL:UFIX (IL:FQUOTIENT FX FY)))
-                                      FY)))))
+                              FY)))))
       (T (- NUMBER (* DIVISOR (XCL::STRUNCATE NUMBER DIVISOR))))))
 
 
@@ -2037,16 +2035,16 @@
                   (SETQ FORM `(,BINARY-LOGICAL-FN ,FORM ,INTEGER)))))))
 
 (XCL:DEFOPTIMIZER LOGXOR (FIRST-INTEGER SECOND-INTEGER &REST MORE-INTEGERS)
-                             (IF (AND COMPILER::*NEW-COMPILER-IS-EXPANDING* MORE-INTEGERS)
-                                 (%LOGICAL-OPTIMIZER 'LOGXOR 0 FIRST-INTEGER SECOND-INTEGER 
-                                        MORE-INTEGERS)
-                                 'COMPILER:PASS))
+                         (IF (AND COMPILER::*NEW-COMPILER-IS-EXPANDING* MORE-INTEGERS)
+                             (%LOGICAL-OPTIMIZER 'LOGXOR 0 FIRST-INTEGER SECOND-INTEGER MORE-INTEGERS
+                                    )
+                             'COMPILER:PASS))
 
 (XCL:DEFOPTIMIZER LOGAND (FIRST-INTEGER SECOND-INTEGER &REST MORE-INTEGERS)
-                             (IF (AND COMPILER::*NEW-COMPILER-IS-EXPANDING* MORE-INTEGERS)
-                                 (%LOGICAL-OPTIMIZER 'LOGAND -1 FIRST-INTEGER SECOND-INTEGER 
-                                        MORE-INTEGERS)
-                                 'COMPILER:PASS))
+                         (IF (AND COMPILER::*NEW-COMPILER-IS-EXPANDING* MORE-INTEGERS)
+                             (%LOGICAL-OPTIMIZER 'LOGAND -1 FIRST-INTEGER SECOND-INTEGER 
+                                    MORE-INTEGERS)
+                             'COMPILER:PASS))
 
 (DEFUN %LOGIOR (X Y)
    (IL:LOGOR X Y))
@@ -2054,14 +2052,14 @@
 (DEFMACRO %LOGEQV (X Y)
    `(LOGNOT (LOGXOR ,X ,Y)))
 
-(IL:PUTPROPS %LOGIOR IL:DOPVAL (2 IL:LOGOR2))
+(IL:PUTPROPS %LOGIOR IL:DOPVAL (2 IL:LOGOR2))
 
 
 
 (IL:* IL:\; "for the byte compiler")
 
 
-(IL:PUTPROPS %LOGIOR IL:DMACRO (= . IL:LOGOR))
+(IL:PUTPROPS %LOGIOR IL:DMACRO (= . IL:LOGOR))
 (IL:DEFINEQ
 
 (LOGIOR
@@ -2108,12 +2106,10 @@
 )
 
 (XCL:DEFOPTIMIZER LOGIOR (FIRST-INTEGER SECOND-INTEGER &REST MORE-INTEGERS)
-                             (%LOGICAL-OPTIMIZER '%LOGIOR 0 FIRST-INTEGER SECOND-INTEGER 
-                                    MORE-INTEGERS))
+                         (%LOGICAL-OPTIMIZER '%LOGIOR 0 FIRST-INTEGER SECOND-INTEGER MORE-INTEGERS))
 
 (XCL:DEFOPTIMIZER LOGEQV (FIRST-INTEGER SECOND-INTEGER &REST MORE-INTEGERS)
-                             (%LOGICAL-OPTIMIZER '%LOGEQV -1 FIRST-INTEGER SECOND-INTEGER 
-                                    MORE-INTEGERS))
+                         (%LOGICAL-OPTIMIZER '%LOGEQV -1 FIRST-INTEGER SECOND-INTEGER MORE-INTEGERS))
 
 (DEFUN LOGNAND (INTEGER1 INTEGER2)
    (LOGNOT (LOGAND INTEGER1 INTEGER2)))
@@ -2136,24 +2132,24 @@
    (LOGIOR INTEGER1 (LOGNOT INTEGER2)))
 
 (XCL:DEFOPTIMIZER LOGNAND (INTEGER1 INTEGER2)
-                              `(LOGNOT (LOGAND ,INTEGER1 ,INTEGER2)))
+                          `(LOGNOT (LOGAND ,INTEGER1 ,INTEGER2)))
 
 (XCL:DEFOPTIMIZER LOGNOR (INTEGER1 INTEGER2)
-                             `(LOGNOT (LOGIOR ,INTEGER1 ,INTEGER2)))
+                         `(LOGNOT (LOGIOR ,INTEGER1 ,INTEGER2)))
 
 (XCL:DEFOPTIMIZER LOGANDC1 (INTEGER1 INTEGER2)
-                               `(LOGAND (LOGNOT ,INTEGER1)
-                                       ,INTEGER2))
+                           `(LOGAND (LOGNOT ,INTEGER1)
+                                   ,INTEGER2))
 
 (XCL:DEFOPTIMIZER LOGANDC2 (INTEGER1 INTEGER2)
-                               `(LOGAND ,INTEGER1 (LOGNOT ,INTEGER2)))
+                           `(LOGAND ,INTEGER1 (LOGNOT ,INTEGER2)))
 
 (XCL:DEFOPTIMIZER LOGORC1 (INTEGER1 INTEGER2)
-                              `(LOGIOR (LOGNOT ,INTEGER1)
-                                      ,INTEGER2))
+                          `(LOGIOR (LOGNOT ,INTEGER1)
+                                  ,INTEGER2))
 
 (XCL:DEFOPTIMIZER LOGORC2 (INTEGER1 INTEGER2)
-                              `(LOGIOR ,INTEGER1 (LOGNOT ,INTEGER2)))
+                          `(LOGIOR ,INTEGER1 (LOGNOT ,INTEGER2)))
 
 (DEFCONSTANT BOOLE-CLR 0)
 
@@ -2235,19 +2231,19 @@
    (EQ 1 (LOGAND 1 (ASH INTEGER (- INDEX)))))
 
 (XCL:DEFOPTIMIZER LOGTEST (INTEGER1 INTEGER2)
-                              `(NOT (EQ 0 (LOGAND ,INTEGER1 ,INTEGER2))))
+                          `(NOT (EQ 0 (LOGAND ,INTEGER1 ,INTEGER2))))
 
 (DEFUN ASH (INTEGER COUNT)
    (IL:LSH INTEGER COUNT))
 
-(IL:PUTPROPS ASH IL:DOPVAL (2 IL:LSH))
+(IL:PUTPROPS ASH IL:DOPVAL (2 IL:LSH))
 
 
 
 (IL:* IL:\; "For the byte compiler")
 
 
-(IL:PUTPROPS ASH IL:DMACRO (= . IL:LSH))
+(IL:PUTPROPS ASH IL:DMACRO (= . IL:LSH))
 
 (DEFUN LOGCOUNT (INTEGER)
 
@@ -2266,10 +2262,10 @@
    (IL:* IL:|;;| "Returns number of 1 bits in nonnegative integer N.  ")
 
    (LET ((CNT 0))                                            (IL:* IL:\; 
-                              "This loop uses a LOGAND trick to reduce the number of iterations.  ")
+                                "This loop uses a LOGAND trick to reduce the number of iterations.  ")
         (LOOP (IF (EQ 0 POSITIVE-INTEGER)
                   (RETURN CNT))                              (IL:* IL:\; 
-                                                        "Change rightmost 1 bit of N to a 0 bit.  ")
+                                                          "Change rightmost 1 bit of N to a 0 bit.  ")
               (SETQ CNT (1+ CNT))
               (SETQ POSITIVE-INTEGER (LOGAND POSITIVE-INTEGER (1- POSITIVE-INTEGER))))))
 (IL:DECLARE\: IL:DONTCOPY IL:DOEVAL@COMPILE 
@@ -2353,49 +2349,49 @@
 (DEFUN %LRSH1 (X)
    (IL:LRSH X 1))
 
-(IL:PUTPROPS %LLSH8 IL:DOPVAL (1 IL:LLSH8))
+(IL:PUTPROPS %LLSH8 IL:DOPVAL (1 IL:LLSH8))
 
-(IL:PUTPROPS %LLSH1 IL:DOPVAL (1 IL:LLSH1))
+(IL:PUTPROPS %LLSH1 IL:DOPVAL (1 IL:LLSH1))
 
-(IL:PUTPROPS %LRSH8 IL:DOPVAL (1 IL:LRSH8))
+(IL:PUTPROPS %LRSH8 IL:DOPVAL (1 IL:LRSH8))
 
-(IL:PUTPROPS %LRSH1 IL:DOPVAL (1 IL:LRSH1))
+(IL:PUTPROPS %LRSH1 IL:DOPVAL (1 IL:LRSH1))
 
 (XCL:DEFOPTIMIZER IL:LLSH (X N)
-                              (IF COMPILER::*NEW-COMPILER-IS-EXPANDING*
-                                  (LET ((M (AND (CONSTANTP N)
-                                                (EVAL N))))
-                                       (IF (TYPEP M '(INTEGER 0))
-                                           (LET ((FORM X))
-                                                (LOOP (IF (< M 8)
-                                                          (RETURN NIL))
-                                                      (SETQ FORM `(%LLSH8 ,FORM))
-                                                      (DECF M 8))
-                                                (LOOP (IF (<= M 0)
-                                                          (RETURN NIL))
-                                                      (SETQ FORM `(%LLSH1 ,FORM))
-                                                      (DECF M 1))
-                                                FORM)
-                                           'COMPILER:PASS))
-                                  'COMPILER:PASS))
+                          (IF COMPILER::*NEW-COMPILER-IS-EXPANDING*
+                              (LET ((M (AND (CONSTANTP N)
+                                            (EVAL N))))
+                                   (IF (TYPEP M '(INTEGER 0))
+                                       (LET ((FORM X))
+                                            (LOOP (IF (< M 8)
+                                                      (RETURN NIL))
+                                                  (SETQ FORM `(%LLSH8 ,FORM))
+                                                  (DECF M 8))
+                                            (LOOP (IF (<= M 0)
+                                                      (RETURN NIL))
+                                                  (SETQ FORM `(%LLSH1 ,FORM))
+                                                  (DECF M 1))
+                                            FORM)
+                                       'COMPILER:PASS))
+                              'COMPILER:PASS))
 
 (XCL:DEFOPTIMIZER IL:LRSH (X N)
-                              (IF COMPILER::*NEW-COMPILER-IS-EXPANDING*
-                                  (LET ((M (AND (CONSTANTP N)
-                                                (EVAL N))))
-                                       (IF (TYPEP M '(INTEGER 0))
-                                           (LET ((FORM X))
-                                                (LOOP (IF (< M 8)
-                                                          (RETURN NIL))
-                                                      (SETQ FORM `(%LRSH8 ,FORM))
-                                                      (DECF M 8))
-                                                (LOOP (IF (<= M 0)
-                                                          (RETURN NIL))
-                                                      (SETQ FORM `(%LRSH1 ,FORM))
-                                                      (DECF M 1))
-                                                FORM)
-                                           'COMPILER:PASS))
-                                  'COMPILER:PASS))
+                          (IF COMPILER::*NEW-COMPILER-IS-EXPANDING*
+                              (LET ((M (AND (CONSTANTP N)
+                                            (EVAL N))))
+                                   (IF (TYPEP M '(INTEGER 0))
+                                       (LET ((FORM X))
+                                            (LOOP (IF (< M 8)
+                                                      (RETURN NIL))
+                                                  (SETQ FORM `(%LRSH8 ,FORM))
+                                                  (DECF M 8))
+                                            (LOOP (IF (<= M 0)
+                                                      (RETURN NIL))
+                                                  (SETQ FORM `(%LRSH1 ,FORM))
+                                                  (DECF M 1))
+                                            FORM)
+                                       'COMPILER:PASS))
+                              'COMPILER:PASS))
 
 
 
@@ -2409,7 +2405,7 @@
        (IF (AND (< SIZE 256)
                 (< POSITION 256))
            (+ (ASH SIZE 8)
-                  POSITION)
+              POSITION)
            (CONS SIZE POSITION))))
 
 (XCL:DEFINLINE BYTE-SIZE (BYTESPEC)
@@ -2433,18 +2429,18 @@
    (IF (AND (TYPEP SIZE '(INTEGER 0 255))
             (TYPEP POSITION '(INTEGER 0 255)))
        (+ (ASH SIZE 8)
-              POSITION)
+          POSITION)
        'COMPILER:PASS))
 
-(IL:PUTPROPS BYTE IL:DMACRO (IL:ARGS (OPTIMIZE-BYTE (CAR IL:ARGS)
-                                                (CADR IL:ARGS))))
+(IL:PUTPROPS BYTE IL:DMACRO (IL:ARGS (OPTIMIZE-BYTE (CAR IL:ARGS)
+                                            (CADR IL:ARGS))))
 (IL:DECLARE\: IL:DONTCOPY IL:DOEVAL@COMPILE 
 
 (DEFMACRO %MAKE-BYTE-MASK-1 (SIZE POSITION)
    (IF (EQ POSITION 0)
        `(1- (ASH 1 ,SIZE))
        `(ASH (1- (ASH 1 ,SIZE))
-               ,POSITION)))
+             ,POSITION)))
 
 (DEFMACRO %MAKE-BYTE-MASK-0 (SIZE POSITION)
    `(LOGNOT (%MAKE-BYTE-MASK-1 ,SIZE ,POSITION)))
@@ -2460,7 +2456,7 @@
    (LET ((SIZE (BYTE-SIZE BYTESPEC))
          (POSITION (BYTE-POSITION BYTESPEC)))
         (LOGIOR (ASH (LOGAND NEWBYTE (%MAKE-BYTE-MASK-1 SIZE 0))
-                           POSITION)
+                     POSITION)
                (LOGAND INTEGER (%MAKE-BYTE-MASK-0 SIZE POSITION)))))
 
 (DEFUN MASK-FIELD (BYTESPEC INTEGER)
@@ -2488,58 +2484,53 @@
       (T NIL)))
 
 (XCL:DEFOPTIMIZER LDB (BYTESPEC INTEGER)
-                          (LET ((CONSTANT-BYTE (%CONSTANT-BYTESPEC-P BYTESPEC)))
-                               (IF CONSTANT-BYTE
-                                   (LET ((SIZE (BYTE-SIZE CONSTANT-BYTE))
-                                         (POSITION (BYTE-POSITION CONSTANT-BYTE)))
-                                        (IF (ZEROP POSITION)
-                                            `(LOGAND ,INTEGER ,(%MAKE-BYTE-MASK-1 SIZE 0))
-                                            `(LOGAND (ASH ,INTEGER ,(- POSITION))
-                                                    ,(%MAKE-BYTE-MASK-1 SIZE 0))))
-                                   'COMPILER:PASS)))
+                      (LET ((CONSTANT-BYTE (%CONSTANT-BYTESPEC-P BYTESPEC)))
+                           (IF CONSTANT-BYTE
+                               (LET ((SIZE (BYTE-SIZE CONSTANT-BYTE))
+                                     (POSITION (BYTE-POSITION CONSTANT-BYTE)))
+                                    (IF (ZEROP POSITION)
+                                        `(LOGAND ,INTEGER ,(%MAKE-BYTE-MASK-1 SIZE 0))
+                                        `(LOGAND (ASH ,INTEGER ,(- POSITION))
+                                                ,(%MAKE-BYTE-MASK-1 SIZE 0))))
+                               'COMPILER:PASS)))
 
 (XCL:DEFOPTIMIZER DPB (NEWBYTE BYTESPEC INTEGER)
-                          (LET ((CONSTANT-BYTE (%CONSTANT-BYTESPEC-P BYTESPEC)))
-                               (IF CONSTANT-BYTE
-                                   (LET ((SIZE (BYTE-SIZE CONSTANT-BYTE))
-                                         (POSITION (BYTE-POSITION CONSTANT-BYTE)))
-                                        (IF (ZEROP POSITION)
-                                            `(LOGIOR (LOGAND ,NEWBYTE ,(%MAKE-BYTE-MASK-1
-                                                                            SIZE 0))
-                                                    (LOGAND ,INTEGER ,(%MAKE-BYTE-MASK-0 SIZE 0))
-                                                    )
-                                            `(LOGIOR (ASH (LOGAND ,NEWBYTE
-                                                                         ,(%MAKE-BYTE-MASK-1
-                                                                           SIZE 0))
-                                                                ,POSITION)
-                                                    (LOGAND ,INTEGER ,(%MAKE-BYTE-MASK-0 SIZE 
-                                                                             POSITION)))))
-                                   'COMPILER:PASS)))
+                      (LET ((CONSTANT-BYTE (%CONSTANT-BYTESPEC-P BYTESPEC)))
+                           (IF CONSTANT-BYTE
+                               (LET ((SIZE (BYTE-SIZE CONSTANT-BYTE))
+                                     (POSITION (BYTE-POSITION CONSTANT-BYTE)))
+                                    (IF (ZEROP POSITION)
+                                        `(LOGIOR (LOGAND ,NEWBYTE ,(%MAKE-BYTE-MASK-1 SIZE 0))
+                                                (LOGAND ,INTEGER ,(%MAKE-BYTE-MASK-0 SIZE 0)))
+                                        `(LOGIOR (ASH (LOGAND ,NEWBYTE ,(%MAKE-BYTE-MASK-1 SIZE 0))
+                                                      ,POSITION)
+                                                (LOGAND ,INTEGER ,(%MAKE-BYTE-MASK-0 SIZE POSITION))))
+                                    )
+                               'COMPILER:PASS)))
 
 (XCL:DEFOPTIMIZER MASK-FIELD (BYTESPEC INTEGER)
-                                 (LET ((CONSTANT-BYTE (%CONSTANT-BYTESPEC-P BYTESPEC)))
-                                      (IF CONSTANT-BYTE
-                                          (LET ((SIZE (BYTE-SIZE CONSTANT-BYTE))
-                                                (POSITION (BYTE-POSITION CONSTANT-BYTE)))
-                                               `(LOGAND ,INTEGER ,(%MAKE-BYTE-MASK-1 SIZE 
-                                                                         POSITION)))
-                                          'COMPILER:PASS)))
+                             (LET ((CONSTANT-BYTE (%CONSTANT-BYTESPEC-P BYTESPEC)))
+                                  (IF CONSTANT-BYTE
+                                      (LET ((SIZE (BYTE-SIZE CONSTANT-BYTE))
+                                            (POSITION (BYTE-POSITION CONSTANT-BYTE)))
+                                           `(LOGAND ,INTEGER ,(%MAKE-BYTE-MASK-1 SIZE POSITION)))
+                                      'COMPILER:PASS)))
 
 (XCL:DEFOPTIMIZER DEPOSIT-FIELD (NEWBYTE BYTESPEC INTEGER)
-                                    (LET ((CONSTANT-BYTE (%CONSTANT-BYTESPEC-P BYTESPEC)))
-                                         (IF CONSTANT-BYTE
-                                             (LET* ((SIZE (BYTE-SIZE CONSTANT-BYTE))
-                                                    (POSITION (BYTE-POSITION CONSTANT-BYTE))
-                                                    (MASK (%MAKE-BYTE-MASK-1 SIZE POSITION)))
-                                                   `(LOGIOR (LOGAND ,NEWBYTE ,MASK)
-                                                           (LOGAND ,INTEGER ,(LOGNOT MASK))))
-                                             'COMPILER:PASS)))
+                                (LET ((CONSTANT-BYTE (%CONSTANT-BYTESPEC-P BYTESPEC)))
+                                     (IF CONSTANT-BYTE
+                                         (LET* ((SIZE (BYTE-SIZE CONSTANT-BYTE))
+                                                (POSITION (BYTE-POSITION CONSTANT-BYTE))
+                                                (MASK (%MAKE-BYTE-MASK-1 SIZE POSITION)))
+                                               `(LOGIOR (LOGAND ,NEWBYTE ,MASK)
+                                                       (LOGAND ,INTEGER ,(LOGNOT MASK))))
+                                         'COMPILER:PASS)))
 
 (DEFUN LDB-TEST (BYTESPEC INTEGER)
    (NOT (EQ 0 (LDB BYTESPEC INTEGER))))
 
 (XCL:DEFOPTIMIZER LDB-TEST (BYTESPEC INTEGER)
-                               `(NOT (EQ 0 (LDB ,BYTESPEC ,INTEGER))))
+                           `(NOT (EQ 0 (LDB ,BYTESPEC ,INTEGER))))
 (IL:DECLARE\: IL:DONTCOPY IL:DOEVAL@COMPILE 
 (IL:DECLARE\: IL:DOEVAL@COMPILE IL:DONTCOPY
 
@@ -2547,9 +2538,9 @@
 )
 )
 
-(IL:PUTPROPS IL:CMLARITH IL:MAKEFILE-ENVIRONMENT (:READTABLE "XCL" :PACKAGE "LISP"))
+(IL:PUTPROPS IL:CMLARITH IL:MAKEFILE-ENVIRONMENT (:READTABLE "XCL" :PACKAGE "LISP"))
 
-(IL:PUTPROPS IL:CMLARITH IL:FILETYPE COMPILE-FILE)
+(IL:PUTPROPS IL:CMLARITH IL:FILETYPE COMPILE-FILE)
 (IL:DECLARE\: IL:DONTEVAL@LOAD IL:DOEVAL@COMPILE IL:DONTCOPY IL:COMPILERVARS 
 
 (IL:ADDTOVAR IL:NLAMA )
@@ -2561,8 +2552,47 @@
 (IL:PUTPROPS IL:CMLARITH IL:COPYRIGHT ("Venue & Xerox Corporation" 1985 1986 1987 1988 1989 1990 1993)
 )
 (IL:DECLARE\: IL:DONTCOPY
-  (IL:FILEMAP (NIL (39320 41192 (= 39333 . 39855) (/= 39857 . 40582) (< 40584 . 40733) (> 40735 . 40884)
- (<= 40886 . 41037) (>= 41039 . 41190)) (57727 59881 (+ 57740 . 58248) (- 58250 . 58830) (* 58832 . 
-59340) (/ 59342 . 59879)) (64441 65951 (GCD 64454 . 65229) (LCM 65231 . 65949)) (83940 85510 (LOGIOR 
-83953 . 84729) (LOGEQV 84731 . 85508)))))
+  (IL:FILEMAP (NIL (17111 17229 (%NOT-NUMBER-ERROR 17111 . 17229)) (17231 17444 (
+%NOT-NONCOMPLEX-NUMBER-ERROR 17231 . 17444)) (17446 17566 (%NOT-INTEGER-ERROR 17446 . 17566)) (17568 
+17690 (%NOT-RATIONAL-ERROR 17568 . 17690)) (17692 17808 (%NOT-FLOAT-ERROR 17692 . 17808)) (18334 18571
+ (DENOMINATOR 18334 . 18571)) (18573 18809 (NUMERATOR 18573 . 18809)) (18902 21818 (%RATIO-PRINT 18902
+ . 21818)) (21820 22424 (%BUILD-RATIO 21820 . 22424)) (22426 22885 (RATIONAL 22426 . 22885)) (22887 
+23368 (RATIONALIZE 22887 . 23368)) (23370 24386 (%RATIO-PLUS 23370 . 24386)) (24388 25187 (
+%RATIO-TIMES 24388 . 25187)) (26169 27030 (COMPLEX 26169 . 27030)) (27032 27198 (REALPART 27032 . 
+27198)) (27200 27380 (IMAGPART 27200 . 27380)) (27382 27622 (CONJUGATE 27382 . 27622)) (27624 28101 (
+PHASE 27624 . 28101)) (28103 28670 (%COMPLEX-PRINT 28103 . 28670)) (28672 28996 (%COMPLEX-+ 28672 . 
+28996)) (28998 29330 (%COMPLEX-- 28998 . 29330)) (29332 29786 (%COMPLEX-* 29332 . 29786)) (29788 30654
+ (%COMPLEX-/ 29788 . 30654)) (30656 30961 (%COMPLEX-ABS 30656 . 30961)) (31580 31626 (ZEROP 31580 . 
+31626)) (31628 31674 (PLUSP 31628 . 31674)) (31977 32024 (MINUSP 31977 . 32024)) (32352 32509 (EVENP 
+32352 . 32509)) (32511 32673 (ODDP 32511 . 32673)) (33247 35130 (%= 33247 . 35130)) (35132 35181 (%/= 
+35132 . 35181)) (35183 36942 (%> 35183 . 36942)) (36944 36980 (%< 36944 . 36980)) (36982 37031 (%>= 
+36982 . 37031)) (37033 37082 (%<= 37033 . 37082)) (38352 39211 (%COMPARISON-MACRO 38352 . 39211)) (
+39214 41086 (= 39227 . 39749) (/= 39751 . 40476) (< 40478 . 40627) (> 40629 . 40778) (<= 40780 . 40931
+) (>= 40933 . 41084)) (41088 41629 (%COMPARISON-OPTIMIZER 41088 . 41629)) (45755 48239 (%+ 45755 . 
+48239)) (48241 50782 (%- 48241 . 50782)) (50784 53230 (%* 50784 . 53230)) (53232 56469 (%/ 53232 . 
+56469)) (57279 59433 (+ 57292 . 57800) (- 57802 . 58382) (* 58384 . 58892) (/ 58894 . 59431)) (59435 
+59478 (1+ 59435 . 59478)) (59480 59523 (1- 59480 . 59523)) (59525 59638 (%RECIPROCOL 59525 . 59638)) (
+62448 63497 (%GCD 62448 . 63497)) (63499 63869 (%LCM 63499 . 63869)) (63870 65380 (GCD 63883 . 64658) 
+(LCM 64660 . 65378)) (68708 69947 (ISQRT 68708 . 69947)) (70029 70583 (ABS 70029 . 70583)) (70585 
+70763 (%ABS 70585 . 70763)) (70765 71259 (SIGNUM 70765 . 71259)) (71261 71489 (%SIGNUM 71261 . 71489))
+ (71776 72741 (XCL::STRUNCATE 71776 . 72741)) (72743 73561 (XCL::SFLOOR 72743 . 73561)) (73563 74377 (
+XCL::SCEILING 73563 . 74377)) (74379 74732 (XCL::SROUND 74379 . 74732)) (75310 75848 (
+%INTEGER-COERCE-MACRO 75310 . 75848)) (75852 76100 (TRUNCATE 75852 . 76100)) (76102 76352 (FLOOR 76102
+ . 76352)) (76354 76608 (CEILING 76354 . 76608)) (76610 76865 (ROUND 76610 . 76865)) (76867 77206 (
+%INTEGER-COERCE-OPTIMIZER 76867 . 77206)) (77903 78154 (FTRUNCATE 77903 . 78154)) (78156 78340 (FFLOOR
+ 78156 . 78340)) (78342 78599 (FCEILING 78342 . 78599)) (78601 78859 (FROUND 78601 . 78859)) (79572 
+80517 (MOD 79572 . 80517)) (80519 81086 (REM 80519 . 81086)) (81495 81989 (%LOGICAL-OPTIMIZER 81495 . 
+81989)) (82708 82751 (%LOGIOR 82708 . 82751)) (82753 82809 (%LOGEQV 82753 . 82809)) (82966 84536 (
+LOGIOR 82979 . 83755) (LOGEQV 83757 . 84534)) (84911 84989 (LOGNAND 84911 . 84989)) (84991 85072 (
+LOGNOR 84991 . 85072)) (85074 85163 (LOGANDC1 85074 . 85163)) (85165 85244 (LOGANDC2 85165 . 85244)) (
+85246 85338 (LOGORC1 85246 . 85338)) (85340 85422 (LOGORC2 85340 . 85422)) (86712 87701 (BOOLE 86712
+ . 87701)) (87768 87850 (LOGTEST 87768 . 87850)) (88071 88128 (ASH 88071 . 88128)) (88273 88742 (
+LOGCOUNT 88273 . 88742)) (88744 89405 (%LOGCOUNT 88744 . 89405)) (89548 89780 (%BIGNUM-LOGCOUNT 89548
+ . 89780)) (89782 91478 (INTEGER-LENGTH 89782 . 91478)) (91540 91579 (%LLSH8 91540 . 91579)) (91581 
+91620 (%LLSH1 91581 . 91620)) (91622 91661 (%LRSH8 91622 . 91661)) (91663 91702 (%LRSH1 91663 . 91702)
+) (94077 94389 (BYTE 94077 . 94389)) (94815 95019 (OPTIMIZE-BYTE 94815 . 95019)) (95203 95378 (
+%MAKE-BYTE-MASK-1 95203 . 95378)) (95380 95481 (%MAKE-BYTE-MASK-0 95380 . 95481)) (95485 95709 (LDB 
+95485 . 95709)) (95711 96024 (DPB 95711 . 96024)) (96026 96222 (MASK-FIELD 96026 . 96222)) (96224 
+96516 (DEPOSIT-FIELD 96224 . 96516)) (96518 96821 (%CONSTANT-BYTESPEC-P 96518 . 96821)) (99730 99812 (
+LDB-TEST 99730 . 99812)))))
 IL:STOP
diff --git a/sources/CMLARITH.LCOM b/sources/CMLARITH.LCOM
index ec11e77b..e26b23ae 100644
--- a/sources/CMLARITH.LCOM
+++ b/sources/CMLARITH.LCOM
@@ -1,9 +1,10 @@
-(DEFINE-FILE-INFO READTABLE "XCL" PACKAGE "LISP")
-(IL:FILECREATED "13-Jun-2021 21:16:13" ("compiled on " 
-IL:|{DSK}<Users>kaplan>Local>medley3.5>git-medley>sources>CMLARITH.;1|) "13-Jun-2021 14:44:27" 
-"COMPILE-FILEd" IL:|in| "FULL 13-Jun-2021 ..." IL:|dated| "13-Jun-2021 14:44:40")
-(IL:FILECREATED " 4-Jan-93 17:38:48" IL:|{DSK}<python>lde>lispcore>sources>CMLARITH.;2| 102283 
-IL:|previous| IL:|date:| "16-May-90 12:46:36" IL:|{DSK}<python>lde>lispcore>sources>CMLARITH.;1|)
+(DEFINE-FILE-INFO PACKAGE "LISP" READTABLE "XCL" BASE 10)
+
+(IL:FILECREATED "23-Sep-2023 23:16:18" ("compiled on " IL:|{WMEDLEY}<sources>CMLARITH.;2|) 
+"23-Sep-2023 23:13:47" "COMPILE-FILEd" IL:|in| "FULL 23-Sep-2023 ..." IL:|dated| 
+"23-Sep-2023 23:13:54")
+(IL:FILECREATED "23-Sep-2023 23:15:39" IL:|{WMEDLEY}<sources>CMLARITH.;2| 100545 :EDIT-BY IL:|rmk| 
+:PREVIOUS-DATE " 4-Jan-93 17:38:48" IL:|{WMEDLEY}<sources>CMLARITH.;1|)
 (IL:RPAQQ IL:CMLARITHCOMS ((IL:* IL:|;;;| "Common Lisp Arithmetic ") (IL:COMS (IL:* IL:|;;| 
 "Error utilities") (IL:FUNCTIONS %NOT-NUMBER-ERROR %NOT-NONCOMPLEX-NUMBER-ERROR %NOT-INTEGER-ERROR 
 %NOT-RATIONAL-ERROR %NOT-FLOAT-ERROR)) (IL:COMS (IL:* IL:|;;;| "Section 2.1.2 Ratios. ") (IL:COMS (
@@ -688,9 +689,9 @@ NIL
 ( 10 (IL:OPENLAMBDA (X) (COND ((EQ X 0) 0) ((PLUSP X) 1) (T -1))))
 (IL:SETF-MACRO-FUNCTION (QUOTE %SIGNUM) (QUOTE |expand-%SIGNUM|))
 XCL::STRUNCATE :D8
-(IL:L (1 DIVISOR 0 NUMBER)) tAµ9@dÃ—¿@	dÃ²¿@É@ÉÛ3 ‘@@	Hd3 ”¿@AÛÃš@íAíìíHÃœ@A
-	A	(113 %NOT-NONCOMPLEX-NUMBER-ERROR 106 XCL::STRUNCATE 101 %/ 56 %NOT-NONCOMPLEX-NUMBER-ERROR 17 IL:\\FIXP.FROM.FLOATP)
-(93 RATIO 75 IL:FLOATP 41 RATIO 33 RATIO 24 RATIO 9 IL:FLOATP)
+(IL:L (1 DIVISOR 0 NUMBER)) }Aµ9@dÃ—¿@	dÃ²¿@É@ÉÛ3 ‘@@	Hd3 ”¿@AÛÃ²@íAí¹íIíë	HÃœ@A
+	A	(122 %NOT-NONCOMPLEX-NUMBER-ERROR 115 XCL::STRUNCATE 110 %/ 95 IL:UFIX 56 %NOT-NONCOMPLEX-NUMBER-ERROR 17 IL:\\FIXP.FROM.FLOATP)
+(102 RATIO 75 IL:FLOATP 41 RATIO 33 RATIO 24 RATIO 9 IL:FLOATP)
 ()
 XCL::SFLOOR :D8
 (IL:L (1 DIVISOR 0 NUMBER)) GA³@	H@ÿ‘Hj@ó²ûHkÕ@A
@@ -814,14 +815,17 @@ QUOTE FFLOOR) (QUOTE COMPILER:OPTIMIZER-LIST))))
 (IL:PUTPROP (QUOTE FROUND) (QUOTE COMPILER:OPTIMIZER-LIST) (ADJOIN (QUOTE |optimize-FROUND|) (GET (
 QUOTE FROUND) (QUOTE COMPILER:OPTIMIZER-LIST))))
 MOD :D8
-(IL:L (1 DIVISOR 0 NUMBER)) l@µA²D@íAíhHdIìíIíÖíìZddhì²¿hIì´Hh€Hì™JíIíÔí€Jí@A
-jHÿ®jAó’@j�j@ó“HAÔH(82 REM)
-(31 IL:FLOATP)
-()
+(IL:L (1 DIVISOR 0 NUMBER)) “@µA²k@íAíhHdíIíë	IíÖíìZddío
+³3¿oIí
+˜Hío‡oHí
+™JíIíÔí€Jí@A
+jHÿ®jAó’@j�j@ó“HAÔH(121 REM 99 IL:UFGREATERP 76 IL:UFGREATERP 60 IL:UFEQP 32 IL:UFIX)
+(37 IL:FLOATP)
+( 91 0.0 85 0.0 68 0.0 55 0.0)
 REM :D8
-(IL:L (1 DIVISOR 0 NUMBER)) D@d3 ™¿A3 “@AÜ@¤A²"@íAíHdIìíIíÖíìí@A@A
-ÖÕ(63 XCL::STRUNCATE)
-(43 IL:FLOATP)
+(IL:L (1 DIVISOR 0 NUMBER)) J@d3 ™¿A3 “@AÜ@¤A²(@íAíHdíIíë	IíÖíìí@A@A
+ÖÕ(69 XCL::STRUNCATE 44 IL:UFIX)
+(49 IL:FLOATP)
 ()
 %LOGICAL-OPTIMIZER :D8
 (IL:L (4 MORE-INTEGERS 3 SECOND-INTEGER 2 FIRST-INTEGER 1 IDENTITY 0 BINARY-LOGICAL-FN)) 1B¡AC¡BD§@BCh@BCh!DYµHº@HJh¸I°ïNIL
