diff --git a/books/bookvol5.pamphlet b/books/bookvol5.pamphlet
index a85da3d..13ea50b 100644
--- a/books/bookvol5.pamphlet
+++ b/books/bookvol5.pamphlet
@@ -364,15 +364,13 @@ information is initialized.
 Starts the interpreter but does not read in profiles, etc.
 <<defun spad>>=
 (defun |spad| () 
- (prog (|$PrintCompilerMessageIfTrue| |$inLispVM|) 
+ (let (|$PrintCompilerMessageIfTrue| |$inLispVM|) 
   (declare (special |$PrintCompilerMessageIfTrue| |$inLispVM|)) 
-   (return 
-    (progn 
-     (spadlet |$PrintCompilerMessageIfTrue| nil) 
-     (spadlet |$inLispVM| nil) 
-     (|setOutputAlgebra| '|%initialize%|) 
-     (|runspad|) 
-     '|EndOfSpad|))))
+  (setq |$PrintCompilerMessageIfTrue| nil) 
+  (setq |$inLispVM| nil) 
+  (|setOutputAlgebra| '|%initialize%|) 
+  (|runspad|) 
+  '|EndOfSpad|))
 
 @
 \subsection{defun runspad}
@@ -382,16 +380,16 @@ Starts the interpreter but does not read in profiles, etc.
   (return 
    (seq 
     (progn 
-     (spadlet mode '|restart|) 
+     (setq mode '|restart|) 
      (do () 
-         ((null (boot-equal mode '|restart|)) nil)
+         ((null (eq mode '|restart|)) nil)
       (seq 
        (exit 
         (progn 
          (|resetStackLimits|) 
          (catch |$quitTag| 
           (catch '|coerceFailure| 
-           (spadlet mode (catch '|top_level| (|ncTopLevel|))))))))))))))
+           (setq mode (catch '|top_level| (|ncTopLevel|))))))))))))))
 
 @
 \subsection{defun ncTopLevel}
@@ -1166,34 +1164,34 @@ constructor name {\tt VectorFunctions2} from the system:
     (cond
      ((null arg) (|helpSpad2Cmd| '(|abbreviations|)))
      (t
-      (spadlet abopts '(|query| |domain| |category| |package| |remove|))
-      (spadlet quiet NIL)
+      (setq abopts '(|query| |domain| |category| |package| |remove|))
+      (setq quiet NIL)
       (do ((t0 |$options| (cdr t0)) (t1 nil))
           ((or (atom t0) 
                (progn (setq t1 (car t0)) nil)
-               (progn (progn (spadlet opt (car t1)) t1) nil))
+               (progn (progn (setq opt (car t1)) t1) nil))
             nil)
        (seq
         (exit
          (progn
-          (spadlet opt
+          (setq opt
            (|selectOptionLC| opt '(|quiet|) '|optionError|))
-          (cond ((boot-equal opt '|quiet|)
-            (spadlet quiet t)))))))
+          (cond ((eq opt '|quiet|)
+            (setq quiet t)))))))
       (cond
        ((and (pairp arg) 
              (progn 
-              (spadlet opt (qcar arg))
-              (spadlet al (qcdr arg))
+              (setq opt (qcar arg))
+              (setq al (qcdr arg))
               t))
-         (spadlet key (|opOf| (car al)))
-         (spadlet type
+         (setq key (|opOf| (car al)))
+         (setq type
            (|selectOptionLC| opt abopts '|optionError|))
          (cond
           ((eq type '|query|)
            (cond 
             ((null al) (|listConstructorAbbreviations|))
-            ((spadlet constructor (|abbreviation?| key))
+            ((setq constructor (|abbreviation?| key))
               (|abbQuery| constructor))
             (t (|abbQuery| key))))
           ((eq type '|remove|)
@@ -1207,10 +1205,10 @@ constructor name {\tt VectorFunctions2} from the system:
               (cond
                ((null al) (return '|fromLoop|))
                (t
-                 (spadlet t2 al)
-                 (spadlet a (CAR t2))
-                 (spadlet b (CADR t2))
-                 (spadlet al (CDDR t2))
+                 (setq t2 al)
+                 (setq a (CAR t2))
+                 (setq b (CADR t2))
+                 (setq al (CDDR t2))
                  (|mkUserConstructorAbbreviation| b a type)
                  (setdatabase b 'abbreviation a)
                  (setdatabase b 'constructorkind type))))))
@@ -1238,7 +1236,7 @@ constructor name {\tt VectorFunctions2} from the system:
  (prog (x)
   (return
    (progn
-    (spadlet x (upcase (|queryUserKeyedMsg| 's2iz0056 nil)))
+    (setq x (upcase (|queryUserKeyedMsg| 's2iz0056 nil)))
     (cond
      ((memq (string2id-n x 1) '(Y YES))
        (|whatSpad2Cmd| '(|categories|))
@@ -1657,12 +1655,12 @@ system function and constructor caches.
   (return
    (seq
     (progn
-     (spadlet |$clearExcept| nil)
+     (setq |$clearExcept| nil)
      (cond 
       (|$options|
-       (spadlet |$clearExcept|
+       (setq |$clearExcept|
         (prog (t0)
-         (spadlet t0 t)
+         (setq t0 t)
          (return
           (do ((t1 nil (null t0))
                (t2 |$options| (cdr t2))
@@ -1670,20 +1668,20 @@ system function and constructor caches.
               ((or t1 
                    (atom t2)
                    (progn (setq t3 (car t2)) nil)
-                   (progn (progn (spadlet |opt| (car t3)) t3) nil))
+                   (progn (progn (setq |opt| (car t3)) t3) nil))
                  t0)
            (seq 
             (exit 
              (setq t0
               (and t0 
-                   (boot-equal
+                   (eq
                     (|selectOptionLC| |opt| '(|except|) '|optionError|)
                     '|except|)))))))))))
      (cond
       ((null |l|)
-        (spadlet |optList|
+        (setq |optList|
          (prog (t4)
-          (spadlet t4 nil)
+          (setq t4 nil)
           (return
            (do ((t5 |$clearOptions| (cdr t5)) (|x| nil))
                ((or (atom t5) (progn (setq |x| (car t5)) nil)) t4)
@@ -1693,12 +1691,12 @@ system function and constructor caches.
                (append t4 (cons '|%l| (cons "       " (cons |x| nil)))))))))))
         (|sayKeyedMsg| 's2iz0010 (cons |optList| nil)))
       (t
-        (spadlet |arg|
+        (setq |arg|
          (|selectOptionLC| (car |l|) '(|all| |completely| |scaches|) nil))
         (cond
-         ((boot-equal |arg| '|all|) (|clearCmdAll|))
-         ((boot-equal |arg| '|completely|) (|clearCmdCompletely|))
-         ((boot-equal |arg| '|scaches|) (|clearCmdSortedCaches|))
+         ((eq |arg| '|all|) (|clearCmdAll|))
+         ((eq |arg| '|completely|) (|clearCmdCompletely|))
+         ((eq |arg| '|scaches|) (|clearCmdSortedCaches|))
          (|$clearExcept| (|clearCmdExcept| |l|))
          (t
           (|clearCmdParts| |l|) (|updateCurrentInterpreterFrame|)))))))))) 
@@ -1721,17 +1719,17 @@ system function and constructor caches.
   (return
    (seq 
     (progn 
-     (spadlet |$lookupDefaults| nil)
+     (setq |$lookupDefaults| nil)
      (do ((t0 (hget |$ConstructorCache| '|SortedCache|) (cdr t0)) 
           (t1 nil))
          ((or (atom t0) 
               (progn (setq t1 (car t0)) nil)
-              (progn (progn (spadlet |domain| (cddr t1)) t1) nil))
+              (progn (progn (setq |domain| (cddr t1)) t1) nil))
             nil)
       (seq
        (exit
         (progn
-         (spadlet |pair|
+         (setq |pair|
           (|compiledLookupCheck| '|clearCache| (cons |$Void| nil) |domain|))
          (spadcall |pair|)))))))))) 
 
@@ -1762,18 +1760,18 @@ system function and constructor caches.
 <<defun clearCmdCompletely>>=
 (defun |clearCmdCompletely| ()
  (progn (|clearCmdAll|)
-  (spadlet |$localExposureData| (copy-seq |$localExposureDataDefault|))
-  (spadlet |$xdatabase| nil)
-  (spadlet |$CatOfCatDatabase| nil)
-  (spadlet |$DomOfCatDatabase| nil)
-  (spadlet |$JoinOfCatDatabase| nil)
-  (spadlet |$JoinOfDomDatabase| nil)
-  (spadlet |$attributeDb| nil)
-  (spadlet |$functionTable| nil)
+  (setq |$localExposureData| (copy-seq |$localExposureDataDefault|))
+  (setq |$xdatabase| nil)
+  (setq |$CatOfCatDatabase| nil)
+  (setq |$DomOfCatDatabase| nil)
+  (setq |$JoinOfCatDatabase| nil)
+  (setq |$JoinOfDomDatabase| nil)
+  (setq |$attributeDb| nil)
+  (setq |$functionTable| nil)
   (|sayKeyedMsg| 's2iz0013 nil)
   (|clearClams|)
   (|clearConstructorCaches|)
-  (spadlet |$existingFiles| (make-hashtable 'UEQUAL))
+  (setq |$existingFiles| (make-hashtable 'UEQUAL))
   (|sayKeyedMsg| 's2iz0014 nil)
   (reclaim)
   (|sayKeyedMsg| 's2iz0015 nil)
@@ -1807,18 +1805,18 @@ system function and constructor caches.
 (defun |clearCmdAll| ()
  (progn
   (|clearCmdSortedCaches|)
-  (spadlet |$frameRecord| nil)
-  (spadlet |$previousBindings| nil)
-  (spadlet |$variableNumberAlist| nil)
+  (setq |$frameRecord| nil)
+  (setq |$previousBindings| nil)
+  (setq |$variableNumberAlist| nil)
   (|untraceMapSubNames| /tracenames)
-  (spadlet |$InteractiveFrame| (list (list nil)))
+  (setq |$InteractiveFrame| (list (list nil)))
   (|resetInCoreHist|)
   (cond
-   (|$useInternalHistoryTable| (spadlet |$internalHistoryTable| nil))
+   (|$useInternalHistoryTable| (setq |$internalHistoryTable| nil))
    (t (|deleteFile| (|histFileName|))))
-  (spadlet |$IOindex| 1)
+  (setq |$IOindex| 1)
   (|updateCurrentInterpreterFrame|)
-  (spadlet |$currentLine| ")clear all")
+  (setq |$currentLine| ")clear all")
   (|clearMacroTable|)
   (cond 
    (|$frameMessages|
@@ -1842,8 +1840,8 @@ system function and constructor caches.
   (return
    (seq
     (progn
-     (spadlet opt (car arg))
-     (spadlet vl (cdr arg))
+     (setq opt (car arg))
+     (setq vl (cdr arg))
      (do ((t0 |$clearOptions| (cdr t0)) (option nil))
          ((or (atom t0) (progn (setq option (car t0)) nil)) nil)
       (seq
@@ -1908,26 +1906,26 @@ system function and constructor caches.
   (return
    (seq
     (progn
-     (spadlet |opt| (car arg))
-     (spadlet |vl| (cdr arg))
-     (spadlet |option| (|selectOptionLC| |opt| |$clearOptions| '|optionError|))
-     (spadlet |option| (intern (pname |option|)))
-     (spadlet |option|
+     (setq |opt| (car arg))
+     (setq |vl| (cdr arg))
+     (setq |option| (|selectOptionLC| |opt| |$clearOptions| '|optionError|))
+     (setq |option| (intern (pname |option|)))
+     (setq |option|
       (cond 
-       ((boot-equal |option| '|types|) '|mode|)
-       ((boot-equal |option| '|modes|) '|mode|)
-       ((boot-equal |option| '|values|) '|value|)
+       ((eq |option| '|types|) '|mode|)
+       ((eq |option| '|modes|) '|mode|)
+       ((eq |option| '|values|) '|value|)
        (t |option|)))
      (cond
       ((null |vl|) (|sayKeyedMsg| 's2iz0055 nil))
       (t
-       (spadlet |pmacs| (|getParserMacroNames|))
-       (spadlet |imacs| (|getInterpMacroNames|))
+       (setq |pmacs| (|getParserMacroNames|))
+       (setq |imacs| (|getInterpMacroNames|))
        (cond
         ((boot-equal |vl| '(|all|))
-         (spadlet |vl| (assocleft (caar |$InteractiveFrame|)))
-         (spadlet |vl| (remdup (append |vl| |pmacs|)))))
-       (spadlet |$e| |$InteractiveFrame|)
+         (setq |vl| (assocleft (caar |$InteractiveFrame|)))
+         (setq |vl| (remdup (append |vl| |pmacs|)))))
+       (setq |$e| |$InteractiveFrame|)
        (do ((t0 |vl| (cdr t0)) (|x| nil))
            ((or (atom t0) (progn (setq |x| (car t0)) nil)) nil)
         (seq
@@ -1935,10 +1933,10 @@ system function and constructor caches.
           (progn
            (|clearDependencies| |x| t)
            (cond
-            ((and (boot-equal |option| '|properties|) (|member| |x| |pmacs|))
+            ((and (eq |option| '|properties|) (|member| |x| |pmacs|))
               (|clearParserMacro| |x|)))
            (cond 
-            ((and (boot-equal |option| '|properties|) 
+            ((and (eq |option| '|properties|) 
                   (|member| |x| |imacs|)
                   (null (|member| |x| |pmacs|)))
              (|sayMessage| (cons 
@@ -1946,14 +1944,14 @@ system function and constructor caches.
                (cons (|fixObjectForPrinting| |x|) 
                      (cons (intern "." "BOOT") nil))))))
            (cond
-            ((spadlet |p1| (|assoc| |x| (caar |$InteractiveFrame|)))
+            ((setq |p1| (|assoc| |x| (caar |$InteractiveFrame|)))
              (cond
-              ((boot-equal |option| '|properties|)
+              ((eq |option| '|properties|)
                (cond
                 ((|isMap| |x|)
                  (seq
                   (cond
-                   ((spadlet |lm| 
+                   ((setq |lm| 
                      (|get| |x| '|localModemap| |$InteractiveFrame|))
                     (cond
                      ((pairp |lm|)
@@ -1964,12 +1962,12 @@ system function and constructor caches.
                 (seq
                  (exit
                   (progn
-                   (spadlet |prop| (car |p2|))
+                   (setq |prop| (car |p2|))
                    (|recordOldValue| |x| |prop| (cdr |p2|))
                    (|recordNewValue| |x| |prop| nil)))))
                (setf (caar |$InteractiveFrame|)
                 (|deleteAssoc| |x| (caar |$InteractiveFrame|))))
-              ((spadlet |p2| (|assoc| |option| (cdr |p1|)))
+              ((setq |p2| (|assoc| |option| (cdr |p1|)))
                (|recordOldValue| |x| |option| (cdr |p2|))
                (|recordNewValue| |x| |option| nil)
                (rplacd |p2| nil)))))))))
@@ -2066,11 +2064,11 @@ Returns the number of active scratchpad clients
        " The )close  system command is obsolete in this version of AXIOM."
        (cons " Please use Close from the File menu instead." nil))))
      (t
-      (spadlet quiet nil)
+      (setq quiet nil)
       (cond
        ((null |$SpadServer|) (|throwKeyedMsg| 's2iz0071 nil))
        (t
-        (spadlet numClients (|queryClients|))
+        (setq numClients (|queryClients|))
         (cond
          ((> numClients 1)
            (|sockSendInt| |$SessionManager| |$CloseClient|)
@@ -2080,22 +2078,22 @@ Returns the number of active scratchpad clients
           (do ((t0 |$options| (cdr t0)) (t1 nil))
               ((or (atom t0) 
                    (progn (setq t1 (car t0)) nil)
-                   (progn (progn (spadlet opt (car t1)) t1) nil))
+                   (progn (progn (setq opt (car t1)) t1) nil))
                  nil)
            (seq
             (exit
              (progn
-              (spadlet fullopt
+              (setq fullopt
                 (|selectOptionLC| opt '(|quiet|) '|optionError|))
-              (cond ((boot-equal fullopt '|quiet|)
-               (spadlet quiet t)))))))
+              (cond ((eq fullopt '|quiet|)
+               (setq quiet t)))))))
           (cond
            (quiet
             (|sockSendInt| |$SessionManager| |$CloseClient|)
             (|sockSendInt| |$SessionManager| |$currentFrameNum|)
             (|closeInterpreterFrame| NIL))
            (t
-            (spadlet x (upcase (|queryUserKeyedMsg| 's2iz0072 nil)))
+            (setq x (upcase (|queryUserKeyedMsg| 's2iz0072 nil)))
             (cond
              ((memq (string2id-n x 1) '(yes y)) (bye))
              (t nil)))))))))))))) 
@@ -2501,15 +2499,15 @@ The value of the {\tt )set break} variable then controls what happens.
   (return
    (seq
     (progn
-     (spadlet |$newConlist| nil)
+     (setq |$newConlist| nil)
      (cond
       ((and (null args) (null |$options|) (null /editfile))
         (|helpSpad2Cmd| '(|compiler|)))
       (t
-       (cond ((null args) (spadlet args (cons /editfile nil))))
-       (spadlet optlist '(|new| |old| |translate| |constructor|))
-       (spadlet havenew nil)
-       (spadlet haveold nil)
+       (cond ((null args) (setq args (cons /editfile nil))))
+       (setq optlist '(|new| |old| |translate| |constructor|))
+       (setq havenew nil)
+       (setq haveold nil)
        (do ((t0 |$options| (CDR t0)) (|opt| NIL))
            ((or (atom t0) 
                 (progn (setq |opt| (car t0)) nil)
@@ -2518,89 +2516,89 @@ The value of the {\tt )set break} variable then controls what happens.
         (seq
          (exit
           (progn
-           (spadlet optname (car |opt|))
-           (spadlet optargs (cdr |opt|))
-           (spadlet fullopt (|selectOptionLC| optname optlist nil))
+           (setq optname (car |opt|))
+           (setq optargs (cdr |opt|))
+           (setq fullopt (|selectOptionLC| optname optlist nil))
            (cond
-            ((boot-equal fullopt '|new|) (spadlet havenew t))
-            ((boot-equal fullopt '|translate|) (spadlet haveold t))
-            ((boot-equal fullopt '|constructor|) (spadlet haveold t))
-            ((boot-equal fullopt '|old|) (spadlet haveold t)))))))
+            ((eq fullopt '|new|) (setq havenew t))
+            ((eq fullopt '|translate|) (setq haveold t))
+            ((eq fullopt '|constructor|) (setq haveold t))
+            ((eq fullopt '|old|) (setq haveold t)))))))
        (cond
         ((and havenew haveold) (|throwKeyedMsg| 's2iz0081 nil))
         (t
-         (spadlet af (|pathname| args))
-         (spadlet aft (|pathnameType| af))
+         (setq af (|pathname| args))
+         (setq aft (|pathnameType| af))
          (cond
-          ((or havenew (boot-equal aft "as"))
+          ((or havenew (string= aft "as"))
            (cond
-            ((null (spadlet af1 ($findfile af '(|as|))))
+            ((null (setq af1 ($findfile af '(|as|))))
              (|throwKeyedMsg| 's2il0003 (cons (namestring af) nil)))
             (t
              (|compileAsharpCmd| (cons af1 nil)))))
-          ((or haveold (boot-equal aft "spad"))
+          ((or haveold (string= aft "spad"))
            (cond
-            ((null (spadlet af1 ($findfile af '(|spad|))))
+            ((null (setq af1 ($findfile af '(|spad|))))
               (|throwKeyedMsg| 's2il0003 (cons (namestring af) nil)))
             (t
               (|compileSpad2Cmd| (cons af1 nil)))))
-          ((boot-equal aft "lsp")
+          ((string= aft "lsp")
            (cond
-            ((null (spadlet af1 ($findfile af '(|lsp|))))
+            ((null (setq af1 ($findfile af '(|lsp|))))
              (|throwKeyedMsg| 's2il0003 (cons (namestring af) nil)))
             (t
              (|compileAsharpLispCmd| (CONS af1 NIL)))))
-          ((boot-equal aft "nrlib")
+          ((string= aft "nrlib")
            (cond
-            ((null (spadlet af1 ($findfile af '(|nrlib|))))
+            ((null (setq af1 ($findfile af '(|nrlib|))))
              (|throwKeyedMsg| 'S2IL0003 (cons (namestring af) nil)))
             (t
              (|compileSpadLispCmd| (cons af1 nil)))))
-          ((boot-equal aft "ao")
+          ((string= aft "ao")
            (cond
-            ((null (spadlet af1 ($findfile af '(|ao|))))
+            ((null (setq af1 ($findfile af '(|ao|))))
              (|throwKeyedMsg| 's2il0003 (cons (namestring af) nil)))
             (t (|compileAsharpCmd| (cons af1 nil)))))
-          ((boot-equal aft "al")
+          ((string= aft "al")
            (cond
-            ((null (spadlet af1 ($findfile af '(|al|))))
+            ((null (setq af1 ($findfile af '(|al|))))
              (|throwKeyedMsg| 's2il0003 (cons (namestring af) nil)))
             (t (|compileAsharpArchiveCmd| (cons af1 nil)))))
           (t
-           (spadlet af1 ($findfile af '(|as| |spad| |ao| |asy|)))
+           (setq af1 ($findfile af '(|as| |spad| |ao| |asy|)))
            (cond
-            ((and af1 (boot-equal (|pathnameType| af1) "as"))
+            ((and af1 (string= (|pathnameType| af1) "as"))
              (|compileAsharpCmd| (CONS af1 NIL)))
-            ((and af1 (boot-equal (|pathnameType| af1) "ao"))
+            ((and af1 (string= (|pathnameType| af1) "ao"))
              (|compileAsharpCmd| (CONS af1 NIL)))
-            ((and af1 (boot-equal (|pathnameType| af1) "spad"))
+            ((and af1 (string= (|pathnameType| af1) "spad"))
              (|compileSpad2Cmd| (CONS af1 NIL)))
-            ((and af1 (boot-equal (|pathnameType| af1) "asy"))
+            ((and af1 (string= (|pathnameType| af1) "asy"))
              (|compileAsharpArchiveCmd| (CONS af1 NIL)))
             (t
-             (spadlet ef (|pathname| /editfile))
-             (spadlet ef (|mergePathnames| af ef))
+             (setq ef (|pathname| /editfile))
+             (setq ef (|mergePathnames| af ef))
              (cond
               ((boot-equal ef af) (|throwKeyedMsg| 's2iz0039 nil))
               (t
-               (spadlet af ef)
+               (setq af ef)
                (cond
-                ((boot-equal (|pathnameType| af) "as")
+                ((string= (|pathnameType| af) "as")
                  (|compileAsharpCmd| args))
-                ((boot-equal (|pathnameType| af) "ao")
+                ((string= (|pathnameType| af) "ao")
                  (|compileAsharpCmd| args))
-                ((boot-equal (|pathnameType| af) "spad")
+                ((string= (|pathnameType| af) "spad")
                  (|compileSpad2Cmd| args))
                 (t
-                 (spadlet af1 ($findfile af '(|as| |spad| |ao| |asy|)))
+                 (setq af1 ($findfile af '(|as| |spad| |ao| |asy|)))
                  (cond
-                  ((and af1 (boot-equal (|pathnameType| af1) "as"))
+                  ((and af1 (string= (|pathnameType| af1) "as"))
                     (|compileAsharpCmd| (CONS af1 NIL)))
-                  ((and af1 (boot-equal (|pathnameType| af1) "ao"))
+                  ((and af1 (string= (|pathnameType| af1) "ao"))
                     (|compileAsharpCmd| (CONS af1 NIL)))
-                  ((and af1 (boot-equal (|pathnameType| af1) "spad"))
+                  ((and af1 (string= (|pathnameType| af1) "spad"))
                     (|compileSpad2Cmd| (CONS af1 NIL)))
-                  ((and af1 (boot-equal (|pathnameType| af1) "asy"))
+                  ((and af1 (string= (|pathnameType| af1) "asy"))
                    (|compileAsharpArchiveCmd| (CONS af1 NIL)))
                   (t (|throwKeyedMsg| 's2iz0039 nil)))))))))))))))))))) 
 
@@ -2706,8 +2704,8 @@ The value of the {\tt )set break} variable then controls what happens.
    (return
     (seq
      (progn
-      (spadlet path (|pathname| args))
-      (spadlet pathtype (|pathnameType| path))
+      (setq path (|pathname| args))
+      (setq pathtype (|pathnameType| path))
       (cond
       ((and (nequal pathtype "as") (nequal pathtype "ao"))
         (|throwKeyedMsg| 's2iz0083 nil))
@@ -2716,44 +2714,44 @@ The value of the {\tt )set break} variable then controls what happens.
       (t
        (setq /editfile path)
        (|updateSourceFiles| path)
-       (spadlet optlist
+       (setq optlist
         '(|new| |old| |translate| |onlyargs| |moreargs| |quiet| 
           |nolispcompile| |noquiet| |library| |nolibrary|))
-       (spadlet bequiet nil)
-       (spadlet dolibrary t)
-       (spadlet docompilelisp t)
-       (spadlet moreargs nil)
-       (spadlet onlyargs nil)
+       (setq bequiet nil)
+       (setq dolibrary t)
+       (setq docompilelisp t)
+       (setq moreargs nil)
+       (setq onlyargs nil)
        (do ((t0 |$options| (cdr t0)) (|opt| nil))
            ((or (atom t0) (progn (setq |opt| (car t0)) nil)) nil)
         (seq
          (exit
           (progn
-           (spadlet optname (car |opt|))
-           (spadlet optargs (cdr |opt|))
-           (spadlet fullopt (|selectOptionLC| optname optlist nil))
+           (setq optname (car |opt|))
+           (setq optargs (cdr |opt|))
+           (setq fullopt (|selectOptionLC| optname optlist nil))
            (cond
-            ((boot-equal fullopt '|new|) nil)
-            ((boot-equal fullopt '|old|)
+            ((eq fullopt '|new|) nil)
+            ((eq fullopt '|old|)
              (|error| '|Internal error: compileAsharpCmd got )old|))
-            ((boot-equal fullopt '|translate|)
+            ((eq fullopt '|translate|)
              (|error| '|Internal error: compileAsharpCmd got )translate|))
-            ((boot-equal fullopt '|quiet|) (spadlet bequiet t))
-            ((boot-equal fullopt '|noquiet|) (spadlet bequiet nil))
-            ((boot-equal fullopt '|nolispcompile|) 
-              (spadlet docompilelisp nil))
-            ((boot-equal fullopt '|moreargs|) (spadlet moreargs optargs))
-            ((boot-equal fullopt '|onlyargs|) (spadlet onlyargs optargs))
-            ((boot-equal fullopt '|library|) (spadlet dolibrary t))
-            ((boot-equal fullopt '|nolibrary|) (spadlet dolibrary nil))
+            ((eq fullopt '|quiet|) (setq bequiet t))
+            ((eq fullopt '|noquiet|) (setq bequiet nil))
+            ((eq fullopt '|nolispcompile|) 
+              (setq docompilelisp nil))
+            ((eq fullopt '|moreargs|) (setq moreargs optargs))
+            ((eq fullopt '|onlyargs|) (setq onlyargs optargs))
+            ((eq fullopt '|library|) (setq dolibrary t))
+            ((eq fullopt '|nolibrary|) (setq dolibrary nil))
             (t 
              (|throwKeyedMsg| 's2iz0036
               (cons (strconc ")" (|object2String| optname)) nil))))))))
-       (spadlet tempargs
+       (setq tempargs
         (cond
-         ((boot-equal pathtype "ao")
+         ((string= pathtype "ao")
           (cond
-           ((spadlet p (strpos "-Fao" |$asharpCmdlineFlags| 0 nil))
+           ((setq p (strpos "-Fao" |$asharpCmdlineFlags| 0 nil))
             (cond
              ((eql p 0) (substring |$asharpCmdlineFlags| 5 nil))
              (t
@@ -2761,36 +2759,36 @@ The value of the {\tt )set break} variable then controls what happens.
                 " " (substring |$asharpCmdlineFlags| (plus p 5) nil)))))
            (t |$asharpCmdlineFlags|)))
          (t |$asharpCmdlineFlags|)))
-       (spadlet asharpargs
+       (setq asharpargs
         (cond
          (onlyargs
-          (spadlet s '||)
+          (setq s '||)
           (do ((t1 onlyargs (cdr t1)) (|a| nil))
               ((or (atom t1) (progn (setq |a| (car t1)) nil)) nil)
            (seq
             (exit
-             (spadlet s (strconc s " " (|object2String| |a|))))))
+             (setq s (strconc s " " (|object2String| |a|))))))
           s)
          (moreargs
-          (spadlet s tempargs)
+          (setq s tempargs)
           (do ((t2 moreargs (cdr t2)) (|a| nil))
               ((or (atom t2) (progn (setq |a| (car t2)) nil)) nil)
            (seq
             (exit
-             (spadlet s (strconc s " " (|object2String| |a|))))))
+             (setq s (strconc s " " (|object2String| |a|))))))
           s)
          (t tempargs)))
        (cond ((null bequiet)
         (|sayKeyedMsg| 's2iz0038a 
          (cons (|namestring| args) (cons asharpargs nil)))))
-       (spadlet command
+       (setq command
         (strconc
          (strconc (getenv "ALDORROOT") "/bin/")
          '|aldor | asharpargs " " (|namestring| args)))
-       (spadlet rc (obey command))
+       (setq rc (obey command))
        (cond
         ((and (eql rc 0) docompilelisp)
-          (spadlet lsp (|fnameMake| "." (|pathnameName| args) "lsp"))
+          (setq lsp (|fnameMake| "." (|pathnameName| args) "lsp"))
           (cond
            ((|fnameReadable?| lsp)
             (cond
@@ -2862,14 +2860,14 @@ The value of the {\tt )set break} variable then controls what happens.
   (return
    (seq
     (progn 
-     (spadlet path (|pathname| args))
+     (setq path (|pathname| args))
      (cond
       ((null (probe-file path))
        (|throwKeyedMsg| 's2il0003 (cons (|namestring| args) nil)))
       (t
-       (spadlet dir (|fnameMake| "." (|pathnameName| path) "axldir"))
-       (spadlet exists (probe-file dir))
-       (spadlet isdir (|directoryp| (|namestring| dir)))
+       (setq dir (|fnameMake| "." (|pathnameName| path) "axldir"))
+       (setq exists (probe-file dir))
+       (setq isdir (|directoryp| (|namestring| dir)))
        (cond
         ((and exists (nequal isdir 1))
           (|throwKeyedMsg| 's2il0027
@@ -2877,23 +2875,23 @@ The value of the {\tt )set break} variable then controls what happens.
         (t
          (cond
           ((nequal isdir 1)
-           (spadlet cmd (strconc "mkdir " (|namestring| dir)))
-           (spadlet rc (obey cmd))
+           (setq cmd (strconc "mkdir " (|namestring| dir)))
+           (setq rc (obey cmd))
            (cond
             ((nequal rc 0)
              (|throwKeyedMsg| 's2il0027 
               (cons (|namestring| dir) (cons (|namestring| args) nil)))))))
-         (spadlet curdir $current-directory)
+         (setq curdir $current-directory)
          (|cd| (cons (|object2Identifier| (|namestring| dir)) nil))
-         (spadlet cmd (strconc "ar x " (|namestring| path)))
-         (spadlet rc (obey cmd))
+         (setq cmd (strconc "ar x " (|namestring| path)))
+         (setq rc (obey cmd))
          (cond
           ((nequal rc 0)
            (|cd| (cons (|object2Identifier| (|namestring| curdir)) nil))
            (|throwKeyedMsg| 's2il0028
             (cons (|namestring| dir) (cons (|namestring| args) nil))))
           (t
-           (spadlet asos (directory (makestring "*.ao")))
+           (setq asos (directory (makestring "*.ao")))
            (cond
             ((null asos)
              (|cd| (cons (|object2Identifier| (|namestring| curdir)) nil))
@@ -2957,31 +2955,31 @@ The value of the {\tt )set break} variable then controls what happens.
   (return 
    (seq 
     (progn 
-     (spadlet path (|pathname| args))
+     (setq path (|pathname| args))
      (cond
       ((null (probe-file path)) 
          (|throwKeyedMsg| 's2il0003 (CONS (|namestring| args) NIL)))
       (t
-       (spadlet optlist '(|quiet| |noquiet| |library| |nolibrary|))
-       (spadlet bequiet nil)
-       (spadlet dolibrary t)
+       (setq optlist '(|quiet| |noquiet| |library| |nolibrary|))
+       (setq bequiet nil)
+       (setq dolibrary t)
        (do ((t0 |$options| (cdr t0)) (|opt| nil))
            ((or (atom t0) (progn (setq |opt| (car t0)) nil)) nil)
         (seq
          (exit
           (progn
-           (spadlet optname (car |opt|))
-           (spadlet optargs (cdr |opt|))
-           (spadlet fullopt (|selectOptionLC| optname optlist nil))
+           (setq optname (car |opt|))
+           (setq optargs (cdr |opt|))
+           (setq fullopt (|selectOptionLC| optname optlist nil))
            (cond
-            ((boot-equal fullopt '|quiet|) (spadlet bequiet t))
-            ((boot-equal fullopt '|noquiet|) (spadlet bequiet nil))
-            ((boot-equal fullopt '|library|) (spadlet dolibrary t))
-            ((boot-equal fullopt '|nolibrary|) (spadlet dolibrary nil))
+            ((eq fullopt '|quiet|) (setq bequiet t))
+            ((eq fullopt '|noquiet|) (setq bequiet nil))
+            ((eq fullopt '|library|) (setq dolibrary t))
+            ((eq fullopt '|nolibrary|) (setq dolibrary nil))
             (t
              (|throwKeyedMsg| 's2iz0036 
               (cons (strconc ")" (|object2String| optname)) nil))))))))
-       (spadlet lsp
+       (setq lsp
         (|fnameMake|
          (|pathnameDirectory| path)
          (|pathnameName| path)
@@ -3052,31 +3050,31 @@ The value of the {\tt )set break} variable then controls what happens.
   (return
    (seq
     (progn
-     (spadlet path (|pathname| (|fnameMake| (car args) "code" "lsp")))
+     (setq path (|pathname| (|fnameMake| (car args) "code" "lsp")))
      (cond
       ((null (probe-file path))
         (|throwKeyedMsg| 's2il0003 (cons (|namestring| args) nil)))
       (t
-       (spadlet optlist '(|quiet| |noquiet| |library| |nolibrary|))
-       (spadlet beQuiet nil)
-       (spadlet dolibrary t)
+       (setq optlist '(|quiet| |noquiet| |library| |nolibrary|))
+       (setq beQuiet nil)
+       (setq dolibrary t)
        (do ((t0 |$options| (cdr t0)) (|opt| nil))
            ((or (atom t0) (progn (setq |opt| (car t0)) nil)) nil)
         (seq
          (exit
           (progn
-           (spadlet optname (car |opt|))
-           (spadlet optargs (cdr |opt|))
-           (spadlet fullopt (|selectOptionLC| optname optlist nil))
+           (setq optname (car |opt|))
+           (setq optargs (cdr |opt|))
+           (setq fullopt (|selectOptionLC| optname optlist nil))
            (cond
-            ((boot-equal fullopt '|quiet|) (spadlet beQuiet t))
-            ((boot-equal fullopt '|noquiet|) (spadlet beQuiet nil))
-            ((boot-equal fullopt '|library|) (spadlet dolibrary t))
-            ((boot-equal fullopt '|nolibrary|) (spadlet dolibrary nil))
+            ((eq fullopt '|quiet|) (setq beQuiet t))
+            ((eq fullopt '|noquiet|) (setq beQuiet nil))
+            ((eq fullopt '|library|) (setq dolibrary t))
+            ((eq fullopt '|nolibrary|) (setq dolibrary nil))
             (t
              (|throwKeyedMsg| 's2iz0036
               (cons (strconc ")" (|object2String| optname)) nil))))))))
-       (spadlet lsp
+       (setq lsp
         (|fnameMake|
          (|pathnameDirectory| path)
          (|pathnameName| path)
@@ -4056,12 +4054,12 @@ changeToNamedInterpreterFrame(name) ==
   (return
    (progn 
     (|updateCurrentInterpreterFrame|)
-    (spadlet frame (|findFrameInRing| name))
+    (setq frame (|findFrameInRing| name))
     (cond 
      ((null frame) 
        nil)
      (t 
-       (spadlet |$interpreterFrameRing|
+       (setq |$interpreterFrameRing|
         (cons frame (nremove |$interpreterFrameRing| frame)))
        (|updateFromCurrentInterpreterFrame|))))))) 
 
@@ -4085,10 +4083,10 @@ previousInterpreterFrame() ==
      ((null (cdr |$interpreterFrameRing|))
        nil)
      (t
-       (spadlet tmp1 (reverse |$interpreterFrameRing|))
-       (spadlet l (car tmp1))
-       (spadlet b (nreverse (cdr tmp1)))
-       (spadlet |$interpreterFrameRing| (nconc2 (cons l nil) b))
+       (setq tmp1 (reverse |$interpreterFrameRing|))
+       (setq l (car tmp1))
+       (setq b (nreverse (cdr tmp1)))
+       (setq |$interpreterFrameRing| (nconc2 (cons l nil) b))
        (|updateFromCurrentInterpreterFrame|))))))) 
 
 @
@@ -4126,7 +4124,7 @@ addNewInterpreterFrame(name) ==
            (|throwKeyedMsg| 'S2IZ0019 ; existing frame with same name
             (cons name nil)))))))
       (|initHistList|)
-      (spadlet |$interpreterFrameRing|
+      (setq |$interpreterFrameRing|
        (cons (|emptyInterpreterFrame| name) |$interpreterFrameRing|))
       (|updateFromCurrentInterpreterFrame|)
       ($erase (|histFileName|))))))) 
@@ -4167,25 +4165,25 @@ closeInterpreterFrame(name) ==
      (t
        (cond
         ((null name)
-          (spadlet |$interpreterFrameRing| (cdr |$interpreterFrameRing|)))
+          (setq |$interpreterFrameRing| (cdr |$interpreterFrameRing|)))
         (t 
-          (spadlet found nil)
-          (spadlet ifr nil)
+          (setq found nil)
+          (setq ifr nil)
           (do ((tmp0 |$interpreterFrameRing| (cdr tmp0)) (f nil))
               ((or (atom tmp0) (progn (setq f (car tmp0)) nil)) nil)
            (seq
             (exit
              (cond
               ((or found (nequal name (frameName f)))
-                (spadlet ifr (cons f ifr)))
+                (setq ifr (cons f ifr)))
               (t 
-                (spadlet found t))))))
+                (setq found t))))))
           (cond
            ((null found) 
               (|throwKeyedMsg| 'S2IZ0022 (cons name nil)))
            (t
               ($erase (|makeHistFileName| name))
-              (spadlet |$interpreterFrameRing| (nreverse ifr))))))
+              (setq |$interpreterFrameRing| (nreverse ifr))))))
        (|updateFromCurrentInterpreterFrame|))))))) 
 
 @
@@ -4202,9 +4200,9 @@ displayFrameNames() ==
   (return
    (seq
     (progn
-     (spadlet fs
+     (setq fs
       (prog (tmp0)
-       (spadlet tmp0 nil)
+       (setq tmp0 nil)
        (return
         (do ((tmp1 |$interpreterFrameRing| (cdr tmp1)) (f nil))
             ((or (atom tmp1)
@@ -4259,55 +4257,55 @@ importFromFrame args ==
    (seq
     (progn
      (when (and args (atom args))
-       (spadlet args (cons args nil))) 
+       (setq args (cons args nil))) 
      (cond
       ((null args)
         (|throwKeyedMsg| 'S2IZ0073 nil)) ; missing frame name
       (t
-        (spadlet temp1 args)
-        (spadlet fname (car temp1))
-        (spadlet args (cdr temp1))
+        (setq temp1 args)
+        (setq fname (car temp1))
+        (setq args (cdr temp1))
         (cond
          ((null (|member| fname (|frameNames|)))
            (|throwKeyedMsg| 'S2IZ0074 (cons fname nil))) ; not frame name
          ((boot-equal fname (frameName (car |$interpreterFrameRing|)))
            (|throwKeyedMsg| 'S2IZ0075 NIL)) ; cannot import from curr frame
          (t
-           (spadlet fenv (|frameEnvironment| fname))
+           (setq fenv (|frameEnvironment| fname))
            (cond
             ((null args)
-              (spadlet x
+              (setq x
                 (upcase (|queryUserKeyedMsg| 'S2IZ0076 (cons fname nil))))
                                              ; import everything?
               (cond
                ((memq (string2id-n x 1) '(y yes))
-                 (spadlet vars nil)
+                 (setq vars nil)
                  (do ((tmp0 (caar fenv) (cdr tmp0)) (tmp1 nil))
                      ((or (atom tmp0) 
                           (progn (setq tmp1 (car tmp0)) nil)
                           (progn 
                            (progn 
-                            (spadlet v (car tmp1))
-                            (spadlet props (cdr tmp1))
+                            (setq v (car tmp1))
+                            (setq props (cdr tmp1))
                             tmp1)
                            nil))
                        nil)
                   (seq
                    (exit
                     (cond
-                     ((boot-equal v '|--macros|)
+                     ((eq v '|--macros|)
                        (do ((tmp2 props (cdr tmp2))
                             (tmp3 nil))
                            ((or (atom tmp2) 
                                 (progn (setq tmp3 (car tmp2)) nil)
                                 (progn 
-                                 (progn (spadlet m (car tmp3)) tmp3)
+                                 (progn (setq m (car tmp3)) tmp3)
                                  nil))
                               nil)
                         (seq
                          (exit
-                          (spadlet vars (cons m vars))))))
-                     (t (spadlet vars (cons v vars)))))))
+                          (setq vars (cons m vars))))))
+                     (t (setq vars (cons v vars)))))))
                  (|importFromFrame| (cons fname vars)))
                (t
                  (|sayKeyedMsg| 'S2IZ0077 (cons fname nil)))))
@@ -4317,7 +4315,7 @@ importFromFrame args ==
               (seq
                (exit
                 (progn
-                 (spadlet plist (getalist (caar fenv) v))
+                 (setq plist (getalist (caar fenv) v))
                  (cond
                   (plist 
                    (|clearCmdParts| (cons '|propert| (cons v nil)))
@@ -4326,14 +4324,14 @@ importFromFrame args ==
                             (progn (setq tmp6 (car tmp5)) nil)
                             (progn 
                              (progn 
-                              (spadlet prop (car tmp6))
-                              (spadlet val (cdr tmp6))
+                              (setq prop (car tmp6))
+                              (setq val (cdr tmp6))
                               tmp6)
                              nil))
                           nil)
                     (seq
                      (exit (|putHist| v prop val |$InteractiveFrame|)))))
-                  ((spadlet m (|get| '|--macros--| v fenv))
+                  ((setq m (|get| '|--macros--| v fenv))
                     (|putHist| '|--macros--| v m |$InteractiveFrame|))
                   (t 
                     (|sayKeyedMsg| 'S2IZ0079 ; frame not found
@@ -4381,7 +4379,7 @@ frameSpad2Cmd args ==
  (prog (frameArgs arg a)
   (return
    (progn
-    (spadlet frameArgs '(|drop| |import| |last| |names| |new| |next|))
+    (setq frameArgs '(|drop| |import| |last| |names| |new| |next|))
     (cond
      (|$options|
       (|throwKeyedMsg| 'S2IZ0016 ; frame command does not take options
@@ -4389,37 +4387,37 @@ frameSpad2Cmd args ==
      ((null args) 
        (|helpSpad2Cmd| (cons '|frame| nil)))
      (t
-       (spadlet arg 
+       (setq arg 
          (|selectOptionLC| (car args) frameArgs '|optionError|))
-       (spadlet args (cdr args))
+       (setq args (cdr args))
        (cond
         ((and (pairp args) 
               (eq (qcdr args) nil)
-              (progn (spadlet a (qcar args)) t))
-          (spadlet args a)))
+              (progn (setq a (qcar args)) t))
+          (setq args a)))
        (when (atom args)
-          (spadlet args (|object2Identifier| args)))
+          (setq args (|object2Identifier| args)))
        (cond
-        ((boot-equal arg '|drop|)
+        ((eq arg '|drop|)
           (cond
            ((and args (pairp args))
              (|throwKeyedMsg| 'S2IZ0017 ; not a valid frame name
                (cons args nil)))
            (t (|closeInterpreterFrame| args))))
-        ((boot-equal arg '|import|)
+        ((eq arg '|import|)
           (|importFromFrame| args))
-        ((boot-equal arg '|last|)
+        ((eq arg '|last|)
           (|previousInterpreterFrame|))
-        ((boot-equal arg '|names|)
+        ((eq arg '|names|)
           (|displayFrameNames|))
-        ((boot-equal arg '|new|)
+        ((eq arg '|new|)
           (cond 
            ((and args (pairp args))
              (|throwKeyedMsg| 'S2IZ0017 ; not a valid frame name
                (cons args nil)))
            (t
              (|addNewInterpreterFrame| args))))
-        ((boot-equal arg '|next|)
+        ((eq arg '|next|)
           (|nextInterpreterFrame|))
         (t nil)))))))) 
 
@@ -4557,41 +4555,41 @@ In HyperDoc, choose the {\bf Commands} item from the
 \end{verbatim}
 
 <<defun newHelpSpad2Cmd>>=
-(defun |newHelpSpad2Cmd| (|args|)
- (prog (|sarg| |arg| |narg| |helpFile| |filestream| |line|)
+(defun |newHelpSpad2Cmd| (args)
+ (prog (sarg arg |narg| |helpFile| |filestream| |line|)
   (return
    (seq
     (progn
-     (cond ((null |args|) (spadlet |args| (cons '? nil))))
+     (cond ((null args) (setq args (cons '? nil))))
      (cond
-      ((> (|#| |args|) 1) (|sayKeyedMsg| 's2iz0026 nil) t)
+      ((> (|#| args) 1) (|sayKeyedMsg| 's2iz0026 nil) t)
       (t
-       (spadlet |sarg| (pname (car |args|)))
+       (setq sarg (pname (car args)))
        (cond
-        ((boot-equal |sarg| "?") (spadlet |args| (cons '|help| nil)))
-        ((boot-equal |sarg| "%") (spadlet |args| (cons '|history| nil)))
-        ((boot-equal |sarg| "%%") (spadlet |args| (cons '|history| nil)))
+        ((string= sarg "?") (setq args (cons '|help| nil)))
+        ((string= sarg "%") (setq args (cons '|history| nil)))
+        ((string= sarg "%%") (setq args (cons '|history| nil)))
         (t nil))
-       (spadlet |arg| (|selectOptionLC| (car |args|) $syscommands nil))
-       (cond ((null |arg|) (spadlet |arg| (car |args|))))
-       (cond ((boot-equal |arg| '|compiler|) (spadlet |arg| '|compile|)))
-       (spadlet |narg| (pname |arg|))
+       (setq arg (|selectOptionLC| (car args) $syscommands nil))
+       (cond ((null arg) (setq arg (car args))))
+       (cond ((eq arg '|compiler|) (setq arg '|compile|)))
+       (setq |narg| (pname arg))
        (cond
         ((null 
-          (spadlet |helpFile| 
+          (setq |helpFile| 
            (make-input-filename 
             (cons |narg| (cons 'helpspad (cons '* nil))))))
           nil)
         (|$useFullScreenHelp|
          (obey (strconc "$AXIOM/lib/SPADEDIT " (|namestring| |helpFile|))) t)
         (t
-         (spadlet |filestream| (make-instream |helpFile|))
+         (setq |filestream| (make-instream |helpFile|))
          (do ()
              (nil nil)
           (seq
            (exit
             (progn
-             (spadlet |line| (|read-line| |filestream| nil))
+             (setq |line| (|read-line| |filestream| nil))
              (cond
               ((null |line|) (shut |filestream|) (return t))
               (t (say |line|)))))))
@@ -4884,12 +4882,12 @@ initHist() ==
      (|$useInternalHistoryTable| 
        (|initHistList|))
      (t
-       (spadlet oldFile (|oldHistFileName|))
-       (spadlet newFile (|histFileName|))
+       (setq oldFile (|oldHistFileName|))
+       (setq newFile (|histFileName|))
        (|histFileErase| oldFile)
        (when (make-input-filename newFile)
         ($replace oldFile newFile))
-       (spadlet |$HiFiAccess| t)
+       (setq |$HiFiAccess| t)
        (|initHistList|)))))) 
  
 @
@@ -4912,17 +4910,17 @@ initHistList() ==
   (return 
    (seq 
     (progn 
-     (spadlet |$HistListLen| 20) 
-     (spadlet |$HistList| (list nil)) 
-     (spadlet li |$HistList|) 
+     (setq |$HistListLen| 20) 
+     (setq |$HistList| (list nil)) 
+     (setq li |$HistList|) 
      (do ((|i| 1 (qsadd1 |i|))) 
          ((qsgreaterp |i| |$HistListLen|) nil) 
       (seq 
        (exit 
-        (spadlet li (cons nil li)))))
+        (setq li (cons nil li)))))
      (rplacd |$HistList| li) 
-     (spadlet |$HistListAct| 0) 
-     (spadlet |$HistRecord| nil))))))
+     (setq |$HistListAct| 0) 
+     (setq |$HistRecord| nil))))))
  
 @
 \subsection{defun history}
@@ -4986,12 +4984,12 @@ historySpad2Cmd() ==
   (return 
    (seq 
     (progn 
-     (spadlet histOptions 
+     (setq histOptions 
        '(|on| |off| |yes| |no| |change| |reset| |restore| |write| 
          |save| |show| |file| |memory|)) 
-     (spadlet opts 
+     (setq opts 
       (prog (tmp1) 
-        (spadlet tmp1 nil) 
+        (setq tmp1 nil) 
         (return 
          (do ((tmp2 |$options| (cdr tmp2)) (tmp3 nil))
              ((or (atom tmp2) 
@@ -5000,8 +4998,8 @@ historySpad2Cmd() ==
                     nil) 
                   (progn 
                    (progn 
-                    (spadlet opt (car tmp3)) 
-                    (spadlet optargs (cdr tmp3)) 
+                    (setq opt (car tmp3)) 
+                    (setq optargs (cdr tmp3)) 
                     tmp3) 
                    nil))
                 (nreverse0 tmp1))
@@ -5020,8 +5018,8 @@ historySpad2Cmd() ==
                  nil) 
               (progn 
                (progn 
-                (spadlet opt (car tmp5)) 
-                (spadlet optargs (cdr tmp5)) 
+                (setq opt (car tmp5)) 
+                (setq optargs (cdr tmp5)) 
                 tmp5) 
                nil))
            nil)
@@ -5033,17 +5031,17 @@ historySpad2Cmd() ==
               (|$HiFiAccess| 
                 (|sayKeyedMsg| 'S2IH0007 nil)) ; history already on
               ((eql |$IOindex| 1) 
-                (spadlet |$HiFiAccess| t)
+                (setq |$HiFiAccess| t)
                 (|initHistList|)
                 (|sayKeyedMsg| 'S2IH0008 nil)) ; history now on
               (t 
-                (spadlet x ; really want to turn history on?
+                (setq x ; really want to turn history on?
                   (upcase (|queryUserKeyedMsg| 'S2IH0009 nil)))
                 (cond 
                  ((memq (string2id-n x 1) '(Y YES)) 
                    (|histFileErase| (|histFileName|)) 
-                   (spadlet |$HiFiAccess| t)
-                   (spadlet |$options| nil) 
+                   (setq |$HiFiAccess| t)
+                   (setq |$options| nil) 
                    (|clearSpad2Cmd| '(|all|))
                    (|sayKeyedMsg| 'S2IH0008 nil) ; history now on
                    (|initHistList|)) 
@@ -5054,24 +5052,24 @@ historySpad2Cmd() ==
              ((null |$HiFiAccess|) 
                (|sayKeyedMsg| 'S2IH0011 nil)) ; history already off
              (t 
-               (spadlet |$HiFiAccess| nil) 
+               (setq |$HiFiAccess| nil) 
                (|disableHist|) 
                (|sayKeyedMsg| 'S2IH0012 nil)))) ; history now off
-          ((boot-equal opt '|file|)
+          ((eq opt '|file|)
              (|setHistoryCore| nil)) 
-          ((boot-equal opt '|memory|)
+          ((eq opt '|memory|)
              (|setHistoryCore| t)) 
-          ((boot-equal opt '|reset|) 
+          ((eq opt '|reset|) 
              (|resetInCoreHist|)) 
-          ((boot-equal opt '|save|) 
+          ((eq opt '|save|) 
              (|saveHistory| optargs)) 
-          ((boot-equal opt '|show|) 
+          ((eq opt '|show|) 
              (|showHistory| optargs)) 
-          ((boot-equal opt '|change|)
+          ((eq opt '|change|)
              (|changeHistListLen| (CAR optargs))) 
-          ((boot-equal opt '|restore|)
+          ((eq opt '|restore|)
              (|restoreHistory| optargs)) 
-          ((boot-equal opt '|write|)
+          ((eq opt '|write|)
              (|writeInputLines| optargs 1)))))) 
      '|done|)))))
 
@@ -5132,30 +5130,30 @@ setHistoryCore inCore ==
         (|sayKeyedMsg| 'S2IH0030 nil) ; memory history already in use
         (|sayKeyedMsg| 'S2IH0029 nil))) ; file history already in use
    ((null |$HiFiAccess|) 
-     (spadlet |$useInternalHistoryTable| inCore) 
+     (setq |$useInternalHistoryTable| inCore) 
      (if inCore 
         (|sayKeyedMsg| 'S2IH0032 nil) ; use memory history
         (|sayKeyedMsg| 'S2IH0031 nil))) ; use file history
    (inCore 
-     (spadlet |$internalHistoryTable| nil) 
+     (setq |$internalHistoryTable| nil) 
      (cond 
       ((nequal |$IOindex| 0) 
-        (spadlet l (length (rkeyids (|histFileName|)))) 
+        (setq l (length (rkeyids (|histFileName|)))) 
         (do ((|i| 1 (qsadd1 |i|)))
             ((qsgreaterp |i| l) nil)
          (seq 
           (exit 
            (progn 
-            (spadlet vec (unwind-protect (|readHiFi| |i|) (|disableHist|)))
-            (spadlet |$internalHistoryTable| 
+            (setq vec (unwind-protect (|readHiFi| |i|) (|disableHist|)))
+            (setq |$internalHistoryTable| 
               (cons (cons |i| vec) |$internalHistoryTable|))))))
          (|histFileErase| (|histFileName|)))) 
-     (spadlet |$useInternalHistoryTable| t) 
+     (setq |$useInternalHistoryTable| t) 
      (|sayKeyedMsg| 'S2IH0032 nil)) ; use memory history
    (t 
-     (spadlet |$HiFiAccess| nil)
+     (setq |$HiFiAccess| nil)
      (|histFileErase| (|histFileName|))
-     (spadlet str 
+     (setq str 
       (rdefiostream 
        (cons 
          '(mode . output) 
@@ -5170,8 +5168,8 @@ setHistoryCore inCore ==
                 nil) 
               (progn 
                (progn 
-                (spadlet n (car tmp1))
-                (spadlet rec (cdr tmp1))
+                (setq n (car tmp1))
+                (setq rec (cdr tmp1))
                 tmp1) 
                nil)) 
               nil)
@@ -5179,9 +5177,9 @@ setHistoryCore inCore ==
         (exit 
          (spadrwrite (|object2Identifier| n) rec str))))
      (rshut str)
-     (spadlet |$HiFiAccess| t)
-     (spadlet |$internalHistoryTable| nil)
-     (spadlet |$useInternalHistoryTable| nil)
+     (setq |$HiFiAccess| t)
+     (setq |$internalHistoryTable| nil)
+     (setq |$useInternalHistoryTable| nil)
      (|sayKeyedMsg| 'S2IH0031 nil))))) ; use file history
 
 @
@@ -5233,51 +5231,51 @@ writeInputLines(fn,initial) ==
      ((null fn) 
        (|throwKeyedMsg| 'S2IH0038 nil)) ; missing file name
      (t 
-       (spadlet maxn 72)
-       (spadlet breakChars (cons '| | (cons '+ nil)))
+       (setq maxn 72)
+       (setq breakChars (cons '| | (cons '+ nil)))
        (do ((tmp0 (spaddifference |$IOindex| 1))
             (|i| initial (+ |i| 1)))
            ((> |i| tmp0) nil)
         (seq 
          (exit 
           (progn 
-           (spadlet vecl (car (|readHiFi| |i|)))
+           (setq vecl (car (|readHiFi| |i|)))
            (cond
-            ((stringp vecl) (spadlet vecl (cons vecl nil))))
+            ((stringp vecl) (setq vecl (cons vecl nil))))
            (do ((tmp1 vecl (cdr tmp1)) (vec nil))
                ((or (atom tmp1) (progn (setq vec (car tmp1)) nil)) nil)
             (seq 
              (exit 
               (progn 
-               (spadlet n (size vec))
+               (setq n (size vec))
                (do () 
                    ((null (> n maxn)) nil) 
                 (seq 
                  (exit 
                   (progn 
-                   (spadlet done nil)
+                   (setq done nil)
                    (do ((|j| 1 (qsadd1 |j|)))
                        ((or (qsgreaterp |j| maxn) (null (null done))) nil)
                     (seq 
                      (exit 
                       (progn 
-                       (spadlet k (spaddifference (plus 1 maxn) |j|))
+                       (setq k (spaddifference (plus 1 maxn) |j|))
                        (cond 
                         ((memq (ELT vec k) breakChars)
                           (progn 
-                           (spadlet svec (strconc 
+                           (setq svec (strconc 
                              (substring vec 0 (plus k 1)) underbar))
-                           (spadlet lineList (cons svec lineList))
-                           (spadlet done t)
-                           (spadlet vec (substring vec (plus k 1) nil))
-                           (spadlet n (size vec)))))))))
+                           (setq lineList (cons svec lineList))
+                           (setq done t)
+                           (setq vec (substring vec (plus k 1) nil))
+                           (setq n (size vec)))))))))
                    (cond 
-                    ((null done) (spadlet n 0))
+                    ((null done) (setq n 0))
                     (t nil))))))
-               (spadlet lineList (cons vec lineList))))))))))
-       (spadlet file (|histInputFileName| fn))
+               (setq lineList (cons vec lineList))))))))))
+       (setq file (|histInputFileName| fn))
        (|histFileErase| file)
-       (spadlet inp 
+       (setq inp 
         (defiostream 
          (cons 
           '(mode . output) 
@@ -5313,13 +5311,13 @@ resetInCoreHist() ==
 (defun |resetInCoreHist| () 
  (seq 
   (progn 
-   (spadlet |$HistListAct| 0) 
+   (setq |$HistListAct| 0) 
    (do ((|i| 1 (qsadd1 |i|)))
        ((qsgreaterp |i| |$HistListLen|) nil)
     (seq
      (exit
       (progn
-       (spadlet |$HistList| (cdr |$HistList|))
+       (setq |$HistList| (cdr |$HistList|))
        (rplaca |$HistList| nil)))))))) 
 
 @
@@ -5348,16 +5346,16 @@ changeHistListLen(n) ==
      ((null (integerp n)) 
        (|sayKeyedMsg| 'S2IH0015 (cons n nil))) ; only positive integers
      (t 
-       (spadlet dif (spaddifference n |$HistListLen|))
-       (spadlet |$HistListLen| n) 
-       (spadlet l (cdr |$HistList|)) 
+       (setq dif (spaddifference n |$HistListLen|))
+       (setq |$HistListLen| n) 
+       (setq l (cdr |$HistList|)) 
        (cond 
         ((> dif 0) 
           (do ((|i| 1 (qsadd1 |i|)))
               ((qsgreaterp |i| dif) nil)
            (seq
             (exit
-             (spadlet l (cons nil l)))))))
+             (setq l (cons nil l)))))))
        (cond
         ((minusp dif)
           (do ((tmp0 (spaddifference dif)) 
@@ -5365,9 +5363,9 @@ changeHistListLen(n) ==
               ((qsgreaterp |i| tmp0) nil)
            (seq
             (exit
-             (spadlet l (cdr l)))))
+             (setq l (cdr l)))))
           (cond
-           ((> |$HistListAct| n) (spadlet |$HistListAct| n))
+           ((> |$HistListAct| n) (setq |$HistListAct| n))
            (t nil))))
        (rplacd |$HistList| l) 
        '|done|)))))) 
@@ -5398,11 +5396,11 @@ updateHist() ==
      (|updateInCoreHist|)
      (when |$HiFiAccess| 
         (unwind-protect (|writeHiFi|) (|disableHist|))
-        (spadlet |$HistRecord| nil))
-     (spadlet |$IOindex| (plus |$IOindex| 1))
+        (setq |$HistRecord| nil))
+     (setq |$IOindex| (plus |$IOindex| 1))
      (|updateCurrentInterpreterFrame|)
-     (spadlet |$mkTestInputStack| nil)
-     (spadlet |$currentLine| nil)
+     (setq |$mkTestInputStack| nil)
+     (setq |$currentLine| nil)
      (|stopTimingProcess| '|history|)))) 
 
 @
@@ -5417,11 +5415,11 @@ updateInCoreHist() ==
 <<defun updateInCoreHist>>=
 (defun |updateInCoreHist| ()
  (progn
-  (spadlet |$HistList| (cdr |$HistList|))
+  (setq |$HistList| (cdr |$HistList|))
   (rplaca |$HistList| nil) 
   (COND 
    ((> |$HistListLen| |$HistListAct|) 
-     (spadlet |$HistListAct| (plus |$HistListAct| 1)))
+     (setq |$HistListAct| (plus |$HistListAct| 1)))
    (t nil)))) 
 
 @
@@ -5437,7 +5435,7 @@ putHist(x,prop,val,e) ==
 <<defun putHist>>=
 (defun |putHist| (x prop val e)
  (progn
-  (when (null (boot-equal x '%))
+  (when (null (eq x '%))
     (|recordOldValue| x prop (|get| x prop e)))
   (when |$HiFiAccess|
     (|recordNewValue| x prop val))
@@ -5476,13 +5474,13 @@ recordNewValue0(x,prop,val) ==
  (prog (p1 p2 p)
   (return 
    (cond 
-    ((spadlet p1 (ASSQ x |$HistRecord|))
+    ((setq p1 (ASSQ x |$HistRecord|))
       (cond 
-       ((spadlet p2 (assq prop (cdr p1))) (rplacd p2 val))
+       ((setq p2 (assq prop (cdr p1))) (rplacd p2 val))
        (t (rplacd p1 (cons (cons prop val) (cdr p1))))))
     (t
-      (spadlet p (cons x (list (cons prop val))))
-      (spadlet |$HistRecord| (cons p |$HistRecord|))))))) 
+      (setq p (cons x (list (cons prop val))))
+      (setq |$HistRecord| (cons p |$HistRecord|))))))) 
 
 @
 \subsection{defun recordOldValue}
@@ -5515,12 +5513,12 @@ recordOldValue0(x,prop,val) ==
  (prog (p1 p)
   (return
    (seq
-    (when (spadlet p1 (assq x (car |$HistList|)))
+    (when (setq p1 (assq x (car |$HistList|)))
       (exit
         (when (null (assq prop (cdr p1)))
           (exit
             (rplacd p1 (cons (cons prop val) (cdr p1)))))))
-    (spadlet p (cons x (list (cons prop val))))
+    (setq p (cons x (list (cons prop val))))
     (rplaca |$HistList| (cons p (car |$HistList|))))))) 
 
 @
@@ -5548,28 +5546,28 @@ undoInCore(n) ==
   (return
    (seq
     (progn
-     (spadlet li |$HistList|) 
+     (setq li |$HistList|) 
      (do ((i n (+ i 1)))
          ((> i |$HistListLen|) nil)
       (seq
        (exit
-        (spadlet li (cdr li)))))
+        (setq li (cdr li)))))
      (|undoChanges| li)
-     (spadlet n (spaddifference (spaddifference |$IOindex| n) 1))
+     (setq n (spaddifference (spaddifference |$IOindex| n) 1))
      (and
        (> n 0)
        (cond 
         (|$HiFiAccess|
-          (spadlet vec 
+          (setq vec 
            (cdr (unwind-protect (|readHiFi| n) (|disableHist|))))
-          (spadlet val 
+          (setq val 
            (and 
-            (spadlet p (assq '% vec))
-            (spadlet p1 (assq '|value| (cdr p)))
+            (setq p (assq '% vec))
+            (setq p1 (assq '|value| (cdr p)))
             (cdr p1))))
         (t 
           (|sayKeyedMsg| 'S2IH0019 (cons n nil))))) ; no history file
-     (spadlet |$InteractiveFrame| 
+     (setq |$InteractiveFrame| 
        (|putHist| '% '|value| val |$InteractiveFrame|))
      (|updateHist|)))))) 
 
@@ -5597,7 +5595,7 @@ undoChanges(li) ==
       (seq
        (exit
         (progn
-         (spadlet x (car p1))
+         (setq x (car p1))
          (do ((tmp1 (cdr p1) (cdr tmp1)) (p2 nil))
              ((or (atom tmp1) (progn (setq p2 (car tmp1)) nil)) nil)
           (seq
@@ -5638,8 +5636,8 @@ undoFromFile(n) ==
               (progn (setq tmp1 (car tmp0)) nil) 
               (progn
                 (progn
-                 (spadlet x (car tmp1)) 
-                 (spadlet varl (cdr tmp1))
+                 (setq x (car tmp1)) 
+                 (setq varl (cdr tmp1))
                  tmp1)
                  nil))
                nil)
@@ -5650,11 +5648,11 @@ undoFromFile(n) ==
          (seq
           (exit
            (progn
-            (spadlet prop (car p))
-            (spadlet val (cdr p))
+            (setq prop (car p))
+            (setq val (cdr p))
             (when val 
               (progn
-                (when (null (boot-equal x '%))
+                (when (null (eq x '%))
                   (|recordOldValue| x prop val))
                 (when |$HiFiAccess| 
                   (|recordNewValue| x prop val))
@@ -5664,27 +5662,27 @@ undoFromFile(n) ==
       (seq
        (exit
         (progn
-         (spadlet vec 
+         (setq vec 
            (unwind-protect (cdr (|readHiFi| |i|)) (|disableHist|)))
          (do ((tmp3 vec (cdr tmp3)) (p1 nil))
              ((or (atom tmp3) (progn (setq p1 (car tmp3)) nil)) nil)
           (seq
            (exit
             (progn
-             (spadlet x (car p1))
+             (setq x (car p1))
              (do ((tmp4 (cdr p1) (cdr tmp4)) (p2 nil))
                  ((or (atom tmp4) (progn (setq p2 (car tmp4)) nil)) nil)
               (seq
                (exit
-                (spadlet |$InteractiveFrame| 
+                (setq |$InteractiveFrame| 
                  (|putHist| x (car p2) (CDR p2) |$InteractiveFrame|)
        ))))))))))))
-     (spadlet val
+     (setq val
       (and 
-       (spadlet p (assq '% vec))
-       (spadlet p1 (assq '|value| (cdr p)))
+       (setq p (assq '% vec))
+       (setq p1 (assq '|value| (cdr p)))
        (cdr p1)))
-     (spadlet |$InteractiveFrame| 
+     (setq |$InteractiveFrame| 
        (|putHist| '% '|value| val |$InteractiveFrame|))
      (|updateHist|)))))) 
 
@@ -5721,7 +5719,7 @@ saveHistory(fn) ==
    (return
     (seq
      (progn
-      (spadlet |$seen| (make-hashtable 'eq))
+      (setq |$seen| (make-hashtable 'eq))
       (cond 
        ((null |$HiFiAccess|) 
          (|sayKeyedMsg| 'S2IH0016 nil)) ; the history file is not on
@@ -5731,12 +5729,12 @@ saveHistory(fn) ==
        ((null fn) 
          (|throwKeyedMsg| 'S2IH0037 nil)) ; need to specify a history filename
        (t 
-         (spadlet savefile (|makeHistFileName| fn))
-         (spadlet inputfile (|histInputFileName| fn))
+         (setq savefile (|makeHistFileName| fn))
+         (setq inputfile (|histInputFileName| fn))
          (|writeInputLines| fn 1)
          (|histFileErase| savefile)
          (when |$useInternalHistoryTable| 
-           (spadlet saveStr 
+           (setq saveStr 
              (rdefiostream 
               (cons '(mode . output) 
                 (cons (cons 'file savefile) nil))))
@@ -5746,17 +5744,17 @@ saveHistory(fn) ==
                     (progn (setq tmp1 (car tmp0)) nil)
                     (progn
                      (progn
-                      (spadlet n (car tmp1)) 
-                      (spadlet rec (cdr tmp1)) 
+                      (setq n (car tmp1)) 
+                      (setq rec (cdr tmp1)) 
                       tmp1) 
                      nil)) 
                     nil)
             (seq
              (exit
               (progn
-               (spadlet val 
+               (setq val 
                  (spadrwrite0 (|object2Identifier| n) rec saveStr))
-               (when (boot-equal val '|writifyFailed|)
+               (when (eq val '|writifyFailed|)
                 (|sayKeyedMsg| 'S2IH0035 ; can't save the value of step
                  (cons n (cons inputfile nil))))))))
            (rshut saveStr))
@@ -5821,57 +5819,57 @@ restoreHistory(fn) ==
      (progn
       (cond 
         ((null fn)
-          (spadlet fnq |$oldHistoryFileName|))
+          (setq fnq |$oldHistoryFileName|))
         ((and (pairp fn) 
               (eq (qcdr fn) nil)
               (progn
-               (spadlet fnq (qcar fn))
+               (setq fnq (qcar fn))
                t)
               (identp fnq))
-          (spadlet fnq fnq))
+          (setq fnq fnq))
         (t (|throwKeyedMsg| 'S2IH0023 (cons fnq nil)))) ; invalid filename
-      (spadlet restfile (|makeHistFileName| fnq))
+      (setq restfile (|makeHistFileName| fnq))
       (cond 
        ((null (make-input-filename restfile))
          (|sayKeyedMsg| 'S2IH0024  ; file does not exist
             (cons (|namestring| restfile) nil)))
        (t 
-         (spadlet |$options| nil)
+         (setq |$options| nil)
          (|clearSpad2Cmd| '(|all|))
-         (spadlet curfile (|histFileName|))
+         (setq curfile (|histFileName|))
          (|histFileErase| curfile)
          ($fcopy restfile curfile)
-         (spadlet l (length (rkeyids curfile)))
-         (spadlet |$HiFiAccess| t)
-         (spadlet oldInternal |$useInternalHistoryTable|)
-         (spadlet |$useInternalHistoryTable| nil)
+         (setq l (length (rkeyids curfile)))
+         (setq |$HiFiAccess| t)
+         (setq oldInternal |$useInternalHistoryTable|)
+         (setq |$useInternalHistoryTable| nil)
          (when oldInternal
-           (spadlet |$internalHistoryTable| nil))
+           (setq |$internalHistoryTable| nil))
          (do ((|i| 1 (qsadd1 |i|)))
              ((qsgreaterp |i| l) nil)
           (seq
            (exit
             (progn
-             (spadlet vec (unwind-protect (|readHiFi| |i|) (|disableHist|)))
+             (setq vec (unwind-protect (|readHiFi| |i|) (|disableHist|)))
              (when oldInternal
-               (spadlet |$internalHistoryTable| 
+               (setq |$internalHistoryTable| 
                 (cons (cons |i| vec) |$internalHistoryTable|)))
-             (spadlet line (car vec))
+             (setq line (car vec))
              (do ((tmp0 (cdr vec) (cdr tmp0)) (p1 nil))
                  ((or (atom tmp0) (progn (setq p1 (car tmp0)) nil)) nil)
               (seq
                (exit
                 (progn
-                 (spadlet x (car p1))
+                 (setq x (car p1))
                  (do ((tmp1 (cdr p1) (cdr tmp1)) (p2 nil))
                      ((or (atom tmp1) (progn (setq p2 (car tmp1)) nil)) nil)
                   (seq
                    (exit
-                    (spadlet |$InteractiveFrame| 
+                    (setq |$InteractiveFrame| 
                       (|putHist| x 
                        (car p2) (cdr p2) |$InteractiveFrame|)))))))))
              (|updateInCoreHist|)))))
-         (spadlet |$e| |$InteractiveFrame|)
+         (setq |$e| |$InteractiveFrame|)
          (seq
           (do ((tmp2 (caar |$InteractiveFrame|) (cdr tmp2)) (tmp3 nil))
               ((or (atom tmp2) 
@@ -5880,7 +5878,7 @@ restoreHistory(fn) ==
                      nil) 
                    (progn
                     (progn
-                      (spadlet a (car tmp3))
+                      (setq a (car tmp3))
                       tmp3) 
                       nil))
                    nil)
@@ -5892,8 +5890,8 @@ restoreHistory(fn) ==
                 (|rempropI| a '|localModemap|)
                 (|rempropI| a '|localVars|)
                 (|rempropI| a '|mapBody|)))))))
-          (spadlet |$IOindex| (plus l 1))
-          (spadlet |$useInternalHistoryTable| oldInternal)
+          (setq |$IOindex| (plus l 1))
+          (setq |$useInternalHistoryTable| oldInternal)
           (|sayKeyedMsg| 'S2IH0025 ; workspace restored
             (cons (|namestring| restfile) nil))
           (|clearCmdSortedCaches|)
@@ -5949,33 +5947,32 @@ showHistory(arg) ==
    (return
     (seq
      (progn
-      (spadlet |$evalTimePrint| 0)
-      (spadlet |$printTimeSum| 0)
+      (setq |$evalTimePrint| 0)
+      (setq |$printTimeSum| 0)
       (cond
        ((null |$HiFiAccess|)
          (|sayKeyedMsg| 'S2IH0026 (cons '|show| nil))) ; history not on
        (t
-         (spadlet showInputOrBoth '|input|)
-         (spadlet n 20)
-         (spadlet nset nil)
+         (setq showInputOrBoth '|input|)
+         (setq n 20)
+         (setq nset nil)
          (when arg 
-          (spadlet arg1 (car arg))
+          (setq arg1 (car arg))
           (when  (integerp arg1)
-           (spadlet n arg1)
-           (spadlet nset t)
+           (setq n arg1)
+           (setq nset t)
            (cond
-            ((kdr arg) (spadlet arg1 (cadr arg)))
-            (t (spadlet arg1 nil))))
+            ((kdr arg) (setq arg1 (cadr arg)))
+            (t (setq arg1 nil))))
           (when arg1 
            (progn
-            (spadlet arg2 (|selectOptionLC| arg1 '(|input| |both|) nil))
+            (setq arg2 (|selectOptionLC| arg1 '(|input| |both|) nil))
             (seq
              (cond 
               (arg2
-                 (when (and (boot-equal 
-                              (spadlet showInputOrBoth arg2) '|both|)
+                 (when (and (eq (setq showInputOrBoth arg2) '|both|)
                             (null nset))
-                   (exit (spadlet n 5))))
+                   (exit (setq n 5))))
               (t
                 (|sayMSG| 
                   (|concat| 
@@ -5983,11 +5980,11 @@ showHistory(arg) ==
                    (|bright| arg1)
                    "is an invalid argument."))))))))
          (when (>= n |$IOindex|)
-           (spadlet n (spaddifference |$IOindex| 1)))
-         (spadlet mini (spaddifference |$IOindex| n))
-         (spadlet maxi (spaddifference |$IOindex| 1))
+           (setq n (spaddifference |$IOindex| 1)))
+         (setq mini (spaddifference |$IOindex| n))
+         (setq maxi (spaddifference |$IOindex| 1))
          (cond 
-           ((boot-equal showInputOrBoth '|both|)
+           ((eq showInputOrBoth '|both|)
              (unwind-protect 
                (|showInOut| mini maxi)
                (|setIOindex| (plus maxi 1))))
@@ -6002,7 +5999,7 @@ setIOindex(n) ==
 \end{verbatim}
 <<defun setIOindex>>=
 (defun |setIOindex| (n)
-  (spadlet |$IOindex| n)) 
+  (setq |$IOindex| n)) 
 
 @
 \subsection{defun showInput}
@@ -6029,12 +6026,12 @@ showInput(mini,maxi) ==
      (seq
       (exit
        (progn
-        (spadlet vec (unwind-protect (|readHiFi| |ind|) (|disableHist|)))
+        (setq vec (unwind-protect (|readHiFi| |ind|) (|disableHist|)))
         (cond
          ((> 10 |ind|) (tab 2))
          ((> 100 |ind|) (tab 1))
          (t nil))
-        (spadlet l (car vec))
+        (setq l (car vec))
         (cond
           ((stringp l)
             (|sayMSG| 
@@ -6078,13 +6075,13 @@ showInOut(mini,maxi) ==
      (seq
       (exit
        (progn
-        (spadlet vec (unwind-protect (|readHiFi| ind) (|disableHist|)))
+        (setq vec (unwind-protect (|readHiFi| ind) (|disableHist|)))
         (|sayMSG| (cons (car vec) nil))
         (cond
-         ((spadlet Alist (assq '% (cdr vec)))
+         ((setq Alist (assq '% (cdr vec)))
           (progn
-           (spadlet triple (cdr (assq '|value| (cdr Alist))))
-           (spadlet |$IOindex| ind)
+           (setq triple (cdr (assq '|value| (cdr Alist))))
+           (setq |$IOindex| ind)
            (|spadPrint| 
              (|objValUnwrap| triple) (|objMode| triple))))))))))))) 
 
@@ -6113,10 +6110,10 @@ fetchOutput(n) ==
   (return
    (cond
     ((and (boot-equal n (spaddifference 1))
-          (spadlet val (|getI| '% '|value|)))
+          (setq val (|getI| '% '|value|)))
        val)
     (|$HiFiAccess|
-     (spadlet n
+     (setq n
       (cond
        ((minusp n) (plus |$IOindex| n))
        (t n)))
@@ -6126,11 +6123,11 @@ fetchOutput(n) ==
       ((> 1 n)
         (|throwKeyedMsg| 'S2IH0002 (cons n nil))) ; only nonzero steps
       (t
-        (spadlet vec (unwind-protect (|readHiFi| n) (|disableHist|)))
+        (setq vec (unwind-protect (|readHiFi| n) (|disableHist|)))
         (cond
-         ((spadlet Alist (assq '% (cdr vec)))
+         ((setq Alist (assq '% (cdr vec)))
            (cond
-             ((spadlet val (cdr (assq '|value| (cdr Alist))))
+             ((setq val (cdr (assq '|value| (cdr Alist))))
                val)
              (t
                (|throwKeyedMsg| 'S2IH0003 (cons n nil))))) ; no step value
@@ -6160,20 +6157,20 @@ readHiFi(n) ==
    (progn
     (cond
      (|$useInternalHistoryTable|
-      (spadlet pair (|assoc| n |$internalHistoryTable|))
+      (setq pair (|assoc| n |$internalHistoryTable|))
       (cond
        ((atom pair) 
          (|keyedSystemError| 'S2IH0034 nil)) ; missing element
        (t 
-         (spadlet vec (qcdr pair)))))
+         (setq vec (qcdr pair)))))
      (t
-       (spadlet HiFi
+       (setq HiFi
         (rdefiostream
          (cons
           '(mode . input)
            (cons
             (cons 'file (|histFileName|)) nil))))
-       (spadlet vec (spadrread (|object2Identifier| n) HiFi))
+       (setq vec (spadrread (|object2Identifier| n) HiFi))
        (rshut HiFi)))
     vec)))) 
 
@@ -6197,13 +6194,13 @@ writeHiFi() ==
   (return
    (cond
     (|$useInternalHistoryTable|
-     (spadlet |$internalHistoryTable|
+     (setq |$internalHistoryTable|
       (cons
        (cons |$IOindex|
         (cons |$currentLine| |$HistRecord|))
         |$internalHistoryTable|)))
     (t
-      (spadlet HiFi
+      (setq HiFi
         (rdefiostream
          (cons
            '(mode . output)
@@ -6252,16 +6249,16 @@ writeHistModesAndValues() ==
                 nil)
               (progn
                 (progn
-                  (spadlet a (car tmp1))
+                  (setq a (car tmp1))
                   tmp1)
               nil))
           nil)
       (seq
        (exit
         (cond
-         ((spadlet x (|get| a '|value| |$InteractiveFrame|))
+         ((setq x (|get| a '|value| |$InteractiveFrame|))
            (|putHist| a '|value| x |$InteractiveFrame|))
-         ((spadlet x (|get| a '|mode| |$InteractiveFrame|))
+         ((setq x (|get| a '|mode| |$InteractiveFrame|))
            (|putHist| a '|mode| x |$InteractiveFrame|))))))
      nil))))) 
 
@@ -6284,9 +6281,9 @@ SPADRWRITE0(vec, item, stream) ==
  (prog (val)
   (return
    (progn
-    (spadlet val (|safeWritify| item))
+    (setq val (|safeWritify| item))
     (cond
-     ((boot-equal val '|writifyFailed|) val)
+     ((eq val '|writifyFailed|) val)
      (t (|rwrite| vec val stream) item)))))) 
 
 @
@@ -6303,9 +6300,9 @@ SPADRWRITE(vec, item, stream) ==
  (prog (val)
   (return
    (progn
-    (spadlet val (spadrwrite0 vec item stream))
+    (setq val (spadrwrite0 vec item stream))
     (cond
-     ((boot-equal val '|writifyFailed|)
+     ((eq val '|writifyFailed|)
         (|throwKeyedMsg| 'S2IH0036 nil)) ; cannot save value to file
      (t item))))))
 
@@ -6354,9 +6351,9 @@ writifyComplain s ==
 <<defun writifyComplain>>=
 (defun |writifyComplain| (s)
  (cond 
-   ((boot-equal |$writifyComplained| t) nil)
+   ((eq |$writifyComplained| t) nil)
    (t
-    (spadlet |$writifyComplained| t)
+    (setq |$writifyComplained| t)
     (|sayKeyedMsg| 'S2IH0027 (cons s nil))))) ; cannot save value
 
 @
@@ -6460,18 +6457,18 @@ writify ob ==
    (seq
     (when (null ob)
      (exit nil))
-    (when (spadlet e (hget |$seen| ob))
+    (when (setq e (hget |$seen| ob))
      (exit e))
     (when (pairp ob)
      (exit
       (seq
-       (spadlet qcar (qcar ob))
-       (spadlet qcdr (qcdr ob))
-       (when (spadlet name (|spadClosure?| ob))
+       (setq qcar (qcar ob))
+       (setq qcdr (qcdr ob))
+       (when (setq name (|spadClosure?| ob))
         (exit
          (seq
-          (spadlet d (|writify,writifyInner| (qcdr ob)))
-          (spadlet nob 
+          (setq d (|writify,writifyInner| (qcdr ob)))
+          (setq nob 
            (cons 'writified!!
             (cons 'spadclosure 
              (cons d (cons name nil)))))
@@ -6483,25 +6480,25 @@ writify ob ==
          (and (pairp ob)
               (eq (qcar ob) 'lambda-closure)
               (progn
-               (spadlet tmp1 (qcdr ob))
+               (setq tmp1 (qcdr ob))
                (and (pairp tmp1)
                     (progn 
-                     (spadlet tmp2 (qcdr tmp1))
+                     (setq tmp2 (qcdr tmp1))
                      (and 
                       (pairp tmp2)
                       (progn 
-                       (spadlet tmp3 (qcdr tmp2))
+                       (setq tmp3 (qcdr tmp2))
                        (and (pairp tmp3)
                             (progn
-                             (spadlet x (qcar tmp3))
+                             (setq x (qcar tmp3))
                              t)))))))) x)
         (exit
          (throw '|writifyTag| '|writifyFailed|)))
-       (spadlet nob (cons qcar qcdr))
+       (setq nob (cons qcar qcdr))
        (hput |$seen| ob nob)
        (hput |$seen| nob nob)
-       (spadlet qcar (|writify,writifyInner| qcar))
-       (spadlet qcdr (|writify,writifyInner| qcdr))
+       (setq qcar (|writify,writifyInner| qcar))
+       (setq qcdr (|writify,writifyInner| qcdr))
        (qrplaca nob qcar)
        (qrplacd nob qcdr)
        (exit nob))))
@@ -6511,16 +6508,16 @@ writify ob ==
        (when (|isDomainOrPackage| ob)
         (exit
          (seq
-          (spadlet d (|mkEvalable| (|devaluate| ob)))
-          (spadlet nob 
+          (setq d (|mkEvalable| (|devaluate| ob)))
+          (setq nob 
            (cons 'writified!! 
             (cons 'devaluated 
              (cons (|writify,writifyInner| d) nil))))
           (hput |$seen| ob nob)
           (hput |$seen| nob nob)
           (exit nob))))
-       (spadlet n (qvmaxindex ob))
-       (spadlet nob (make-vec (plus n 1)))
+       (setq n (qvmaxindex ob))
+       (setq nob (make-vec (plus n 1)))
        (hput |$seen| ob nob)
        (hput |$seen| nob nob)
        (do ((|i| 0 (qsadd1 |i|)))
@@ -6529,7 +6526,7 @@ writify ob ==
          (exit
           (qsetvelt nob |i| (|writify,writifyInner| (QVELT ob |i|))))))
        (exit nob))))
-    (when (boot-equal ob 'writified!!)
+    (when (eq ob 'writified!!)
      (exit
       (cons 'writified!! (cons 'self nil))))
     (when (|constructor?| ob)
@@ -6540,10 +6537,10 @@ writify ob ==
     (when (hashtablep ob)
      (exit
       (seq
-       (spadlet nob (cons 'writified!! nil))
+       (setq nob (cons 'writified!! nil))
        (hput |$seen| ob nob)
        (hput |$seen| nob nob)
-       (spadlet keys (hkeys ob))
+       (setq keys (hkeys ob))
        (qrplacd nob
         (cons 
           'hashtable
@@ -6553,7 +6550,7 @@ writify ob ==
               (|writify,writifyInner| keys)
               (cons
                 (prog (tmp0)
-                  (spadlet tmp0 nil)
+                  (setq tmp0 nil)
                   (return
                    (do ((tmp1 keys (cdr tmp1)) (k nil))
                        ((or (atom tmp1)
@@ -6572,7 +6569,7 @@ writify ob ==
     (when (placep ob)
      (exit
       (seq
-       (spadlet nob (cons 'writified!! (cons 'place nil)))
+       (setq nob (cons 'writified!! (cons 'place nil)))
        (hput |$seen| ob nob)
        (hput |$seen| nob nob)
        (exit nob))))
@@ -6611,8 +6608,8 @@ writify ob ==
      ((null (|ScanOrPairVec| (|function| |unwritable?|) ob))
        ob)
      (t
-      (spadlet |$seen| (make-hashtable 'eq))
-      (spadlet |$writifyComplained| nil)
+      (setq |$seen| (make-hashtable 'eq))
+      (setq |$writifyComplained| nil)
       (|writify,writifyInner| ob)))))) 
 
 @
@@ -6630,11 +6627,11 @@ spadClosure? ob ==
  (prog (fun name vec)
   (return
    (progn
-    (spadlet fun (qcar ob))
+    (setq fun (qcar ob))
     (cond 
-     ((null (spadlet name (bpiname fun))) nil)
+     ((null (setq name (bpiname fun))) nil)
      (t
-       (spadlet vec (qcdr ob))
+       (setq vec (qcdr ob))
        (cond
         ((null (vecp vec)) nil)
         (t name)))))))) 
@@ -6727,7 +6724,7 @@ dewritify ob ==
 \end{verbatim}
 <<defun dewritify,is?>>=
 (defun |dewritify,is?| (a)
- (boot-equal a 'writified!!))
+ (eq a 'writified!!))
 
 @
 <<defun dewritify,dewritifyInner>>=
@@ -6737,19 +6734,19 @@ dewritify ob ==
    (seq
     (when (null ob) 
       (exit nil))
-    (when (spadlet e (hget |$seen| ob)) 
+    (when (setq e (hget |$seen| ob)) 
       (exit e))
-    (when (and (pairp ob) (boot-equal (car ob) 'writified!!))
+    (when (and (pairp ob) (eq (car ob) 'writified!!))
      (exit
       (seq
-       (spadlet type (elt ob 1))
-       (when (boot-equal type 'self) 
+       (setq type (elt ob 1))
+       (when (eq type 'self) 
         (exit 'writified!!))
-       (when (boot-equal type 'bpi)
+       (when (eq type 'bpi)
         (exit
          (seq
-          (spadlet oname (elt ob 2))
-          (spadlet f 
+          (setq oname (elt ob 2))
+          (setq f 
            (seq 
             (when (intp oname) (exit (eval (gensymmer oname))))
             (exit (symbol-function oname))))
@@ -6759,10 +6756,10 @@ dewritify ob ==
            (exit (|error| "A required BPI has been redefined.")))
           (hput |$seen| ob f)
           (exit f))))
-       (when (boot-equal type 'hashtable)
+       (when (eq type 'hashtable)
         (exit
          (seq
-          (spadlet nob (make-hashtable (elt ob 2)))
+          (setq nob (make-hashtable (elt ob 2)))
           (hput |$seen| ob nob)
           (hput |$seen| nob nob)
           (do ((tmp0 (elt ob 3) (cdr tmp0))
@@ -6783,50 +6780,50 @@ dewritify ob ==
              (hput nob (|dewritify,dewritifyInner| k) 
               (|dewritify,dewritifyInner| e)))))
           (exit nob))))
-       (when (boot-equal type 'devaluated)
+       (when (eq type 'devaluated)
         (exit
          (seq
-          (spadlet nob (eval (|dewritify,dewritifyInner| (elt ob 2))))
+          (setq nob (eval (|dewritify,dewritifyInner| (elt ob 2))))
           (hput |$seen| ob nob)
           (hput |$seen| nob nob)
           (exit nob))))
-       (when (boot-equal type 'spadclosure)
+       (when (eq type 'spadclosure)
         (exit
          (seq
-          (spadlet vec (|dewritify,dewritifyInner| (elt ob 2)))
-          (spadlet name (ELT ob 3))
+          (setq vec (|dewritify,dewritifyInner| (elt ob 2)))
+          (setq name (ELT ob 3))
           (when (null (fboundp name))
            (exit
             (|error| 
              (strconc "undefined function: " (symbol-name name)))))
-          (spadlet nob (cons (symbol-function name) vec))
+          (setq nob (cons (symbol-function name) vec))
           (hput |$seen| ob nob)
           (hput |$seen| nob nob)
           (exit nob))))
-       (when (boot-equal type 'place) 
+       (when (eq type 'place) 
         (exit
          (seq
-          (spadlet nob (vmread (make-instream nil)))
+          (setq nob (vmread (make-instream nil)))
           (hput |$seen| ob nob)
           (hput |$seen| nob nob)
           (exit nob))))
-       (when (boot-equal type 'readtable)
+       (when (eq type 'readtable)
         (exit (|error| "Cannot de-writify a read table.")))
-       (when (boot-equal type 'nullstream)
+       (when (eq type 'nullstream)
         (exit |$NullStream|))
-       (when (boot-equal type 'nonnullstream) 
+       (when (eq type 'nonnullstream) 
         (exit |$NonNullStream|))
-       (when (boot-equal type 'float) 
+       (when (eq type 'float) 
         (exit
          (seq
           (progn
-           (spadlet tmp1 (cddr ob))
-           (spadlet fval (car tmp1))
-           (spadlet signif (cadr tmp1))
-           (spadlet expon (caddr tmp1))
-           (spadlet sign (cadddr tmp1))
+           (setq tmp1 (cddr ob))
+           (setq fval (car tmp1))
+           (setq signif (cadr tmp1))
+           (setq expon (caddr tmp1))
+           (setq sign (cadddr tmp1))
            tmp1)
-          (spadlet fval (scale-float (float signif fval) expon))
+          (setq fval (scale-float (float signif fval) expon))
           (when (minusp sign)
            (exit (spaddifference fval)))
           (exit fval))))
@@ -6834,9 +6831,9 @@ dewritify ob ==
     (when (pairp ob)
      (exit
       (seq
-       (spadlet qcar (qcar ob))
-       (spadlet qcdr (qcdr ob))
-       (spadlet nob (cons qcar qcdr))
+       (setq qcar (qcar ob))
+       (setq qcdr (qcdr ob))
+       (setq nob (cons qcar qcdr))
        (hput |$seen| ob nob)
        (hput |$seen| nob nob)
        (qrplaca nob (|dewritify,dewritifyInner| qcar))
@@ -6845,8 +6842,8 @@ dewritify ob ==
     (when (vecp ob)
      (exit
       (seq
-       (spadlet n (qvmaxindex ob))
-       (spadlet nob (make-vec (plus n 1)))
+       (setq n (qvmaxindex ob))
+       (setq nob (make-vec (plus n 1)))
        (hput |$seen| ob nob)
        (hput |$seen| nob nob)
        (do ((|i| 0 (qsadd1 |i|)))
@@ -6868,7 +6865,7 @@ dewritify ob ==
      ((null (|ScanOrPairVec| (|function| |dewritify,is?|) ob))
        ob)
      (t
-       (spadlet |$seen| (make-hashtable 'EQ))
+       (setq |$seen| (make-hashtable 'EQ))
        (|dewritify,dewritifyInner| ob)))))) 
 
 @
@@ -6924,7 +6921,7 @@ ScanOrPairVec(f, ob) ==
   (declare (special |$seen|)) 
    (return
     (progn
-     (spadlet |$seen| (make-hashtable 'eq))
+     (setq |$seen| (make-hashtable 'eq))
      (catch '|ScanOrPairVecAnswer| (|ScanOrPairVec,ScanOrInner| f ob))))))
 
 @
@@ -6946,13 +6943,13 @@ gensymInt g ==
      ((null (gensymp g)) 
        (|error| "Need a GENSYM"))
      (t
-       (spadlet p (pname g))
-       (spadlet n 0)
+       (setq p (pname g))
+       (setq n 0)
        (do ((tmp0 (spaddifference (|#| p) 1)) (|i| 2 (qsadd1 |i|)))
            ((qsgreaterp |i| tmp0) nil)
         (seq
          (exit
-          (spadlet n (plus (times 10 n) (|charDigitVal| (elt p |i|)))))))
+          (setq n (plus (times 10 n) (|charDigitVal| (elt p |i|)))))))
        n))))))
 
 @
@@ -6972,14 +6969,14 @@ charDigitVal c ==
   (return
    (seq
     (progn
-     (spadlet digits "0123456789")
-     (spadlet n (spaddifference 1)) 
+     (setq digits "0123456789")
+     (setq n (spaddifference 1)) 
      (do ((tmp0 (spaddifference (|#| digits) 1)) (|i| 0 (qsadd1 |i|)))
          ((or (qsgreaterp |i| tmp0) (null (minusp n))) nil)
       (seq
        (exit
         (cond 
-         ((boot-equal c (elt digits |i|)) (spadlet n |i|))
+         ((boot-equal c (elt digits |i|)) (setq n |i|))
          (t nil)))))
      (cond
       ((minusp n) (|error| "Character is not a digit"))
@@ -7570,6 +7567,2625 @@ For example, to change the {\tt )quit} command to being unprotected
 \par\noindent{\bf Also See:}
 \fnref{quit}
 
+\section{Overview}
+This section contains tree of information used to initialize the {\bf )set} 
+command in the interpreter. The current list is:
+\begin{verbatim}
+
+Variable     Description                           Current Value
+-----------------------------------------------------------------
+compiler   Library compiler options                   ... 
+breakmode  execute break processing on error          break 
+expose     control interpreter constructor exposure   ... 
+functions  some interpreter function options          ... 
+fortran    view and set options for FORTRAN output    ... 
+kernel     library functions built into the kernel for 
+           efficiency                                 ...
+hyperdoc   options in using HyperDoc                  ... 
+help       view and set some help options             ... 
+history    save workspace values in a history file    on 
+messages   show messages for various system features  ... 
+naglink    options for NAGLink                        ... 
+output     view and set some output options           ... 
+quit       protected or unprotected quit              unprotected 
+streams    set some options for working with streams  ... 
+system     set some system development variables      ... 
+userlevel  operation access level of system user      development 
+
+Variables with current values of ... have further sub-options. 
+For example, issue )set  system to see what the options are 
+for system. 
+For more information, issue )help set .
+
+\end{verbatim}
+\subsection{The list structure}
+The structure of each list item consists of 7 items.  Consider this 
+example:
+\begin{verbatim}
+  (userlevel
+   "operation access level of system user"
+   interpreter
+   LITERALS
+   $UserLevel
+   (interpreter compiler development)
+   development)
+\end{verbatim}
+The list looks like (the names in bold are accessor names that can be
+found in {\bf property.lisp.pamphlet\cite{1}}. Look for "setName".):
+\begin{list}{}
+\item {\bf 1} {\sl Name} the keyword the user will see. In this example
+the user would say "{\bf )set output userlevel}".
+\item {\bf 2} {\sl Label} the message the user will see. In this example
+the user would see "operation access level of system user".
+\item {\bf 3} {\sl Level} the level where the command will be 
+accepted. There are three levels: interpreter, compiler, development.
+These commands are restricted to keep the user from causing damage.
+\item {\bf 4} {\sl Type} a symbol, one of {\bf FUNCTION}, {\bf INTEGER},
+{\bf STRING}, {\bf LITERALS}, {\bf FILENAME} or {\bf TREE}. See the function
+{\bf initializeSetVariables} in the file
+{\bf setvars.boot.pamphlet\cite{2}}.
+\item {\bf 5} {\sl Var} 
+\begin{list}{}
+\item FUNCTION is the function to call
+\item INTEGER is the variable holding the current user setting.
+\item STRING is the variable holding the current user setting.
+\item LITERALS variable which holds the current user setting.
+\item FILENAME is the variable that holds the current user setting.
+\item TREE
+\end{list}
+\item {\bf 6} {\sl Leaf} 
+\begin{list}{}
+\item FUNCTION is the list of all possible values
+\item INTEGER is the range of possible values
+\item STRING is a list of all possible values
+\item LITERALS is a list of all of the possible values
+\item FILENAME is the function to check the filename
+\item TREE
+\end{list}
+\item {\bf 7} {\sl Def} is the default value 
+\begin{list}{}
+\item FUNCTION is the default setting
+\item INTEGER is the default setting
+\item STRING is the default setting
+\item LITERALS is the default setting
+\item FILENAME is the default value
+\item TREE
+\end{list}
+\end{list}
+\section{breakmode}
+\begin{verbatim}
+-------------------- The breakmode Option ---------------------
+
+ Description: execute break processing on error
+
+ The breakmode option may be followed by any one of the 
+ following:
+
+    nobreak
+ -> break 
+    query
+    resume
+    fastlinks
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<breakmode>>=
+  (|breakmode|
+   "execute break processing on error"
+   |interpreter|
+   LITERALS
+   |$BreakMode|
+   (|nobreak| |break| |query| |resume| |fastlinks|)
+   |nobreak|)         ; needed to avoid possible startup looping
+@
+\section{compiler}
+\begin{verbatim}
+                  Current Values of  compiler  Variables                   
+
+Variable     Description                           Current Value
+-----------------------------------------------------------------
+output       library in which to place compiled code     
+input        controls libraries from which to load compiled code  
+args         arguments for compiling AXIOM code         
+             -O -Fasy -Fao -Flsp -laxiom -Mno-AXL_W_WillObsolete 
+             -DAxiom -Y $AXIOM/algebra 
+
+\end{verbatim}
+<<compiler>>=
+   (|compiler|
+    "Library compiler options"
+    |interpreter|
+    TREE
+    |novar|
+    (
+<<compileroutput>>
+<<compilerinput>>
+<<compilerargs>>
+    ))
+@
+\subsection{output}
+\begin{verbatim}
+---------------------- The output Option ----------------------
+
+ Description: library in which to place compiled code
+
+\end{verbatim}
+<<compileroutput>>=
+      (|output|
+       "library in which to place compiled code"
+       |interpreter|
+       FUNCTION
+       |setOutputLibrary|
+       NIL
+       |htSetOutputLibrary|
+	)
+@
+\subsection{input}
+\begin{verbatim}
+---------------------- The input Option -----------------------
+
+ Description: controls libraries from which to load compiled code
+
+ )set compiler input add library is used to tell AXIOM to add 
+  library to the front of the path which determines where 
+  compiled code is loaded from.
+ )set compiler input drop library is used to tell AXIOM to remove 
+  library from this path.
+\end{verbatim}
+<<compilerinput>>=
+      (|input|
+       "controls libraries from which to load compiled code"
+       |interpreter|
+       FUNCTION
+       |setInputLibrary|
+       NIL
+       |htSetInputLibrary|)
+@
+\subsection{args}
+\begin{verbatim}
+----------------------- The args Option -----------------------
+
+ Description: arguments for compiling AXIOM code
+
+ )set compiler args  is used to tell AXIOM how to invoke the 
+  library compiler when compiling code for AXIOM.
+  The args option is followed by a string enclosed in double 
+  quotes.
+
+ The current setting is
+ "-O -Fasy -Fao -Flsp -laxiom -Mno-AXL_W_WillObsolete 
+  -DAxiom -Y $AXIOM/algebra" 
+\end{verbatim}
+<<compilerargs>>=
+      (|args|
+       "arguments for compiling AXIOM code"
+       |interpreter|
+       FUNCTION
+       |setAsharpArgs|
+       (("enter compiler options "
+          STRING
+          |$asharpCmdlineFlags|
+          |chkDirectory|
+          "-O -Fasy -Fao -Flsp -laxiom -Mno-AXL__W__WillObsolete -DAxiom -Y $AXIOM/algebra"))
+       NIL)
+@
+\section{expose}
+\begin{verbatim}
+---------------------- The expose Option ----------------------
+
+ Description: control interpreter constructor exposure
+
+   The following groups are explicitly exposed in the current 
+   frame (called initial ):
+                                   basic                                   
+                                categories                                 
+                                  naglink                                  
+                                   anna                                    
+ 
+   The following constructors are explicitly exposed in the 
+   current frame:
+               there are no explicitly exposed constructors                
+ 
+   The following constructors are explicitly hidden in the 
+   current frame:
+                there are no explicitly hidden constructors                
+ 
+   When )set expose is followed by no arguments, the information
+   you now see is displayed. When followed by the initialize 
+   argument, the exposure group data in the file interp.exposed 
+   is read and is then available. The arguments add and drop are 
+   used to add or drop exposure groups or explicit constructors 
+   from the local frame exposure data. Issue
+                  )set expose add    or    )set expose drop 
+   for more information.
+\end{verbatim}
+<<expose>>=
+  (|expose|
+   "control interpreter constructor exposure"
+   |interpreter|
+   FUNCTION
+   |setExpose|
+   NIL
+   |htSetExpose|)
+@
+\section{functions}
+\begin{verbatim}
+             Current Values of  functions  Variables                  
+
+Variable     Description                           Current Value
+-----------------------------------------------------------------
+cache        number of function results to cache        0 
+compile      compile, don't just define function bodies off 
+recurrence   specially compile recurrence relations     on 
+
+\end{verbatim}
+<<functions>>=
+  (|functions|
+   "some interpreter function options"
+   |interpreter|
+   TREE
+   |novar|
+   (
+<<functionscache>>
+<<functionscompile>>
+<<functionsrecurrence>>
+  ))
+@
+\subsection{cache}
+\begin{verbatim}
+---------------------- The cache Option -----------------------
+
+ Description: number of function results to cache
+
+ )set functions cache is used to tell AXIOM how many  values 
+  computed by interpreter functions should be saved.  This can 
+  save quite a bit of time in recursive functions, though one 
+  must consider that the cached values will take up (perhaps 
+  valuable) room in the workspace.
+
+ The value given  after cache must either be the word all or 
+ a positive integer. This may be followed by any number of 
+ function names whose cache sizes you wish to so set.  If no 
+ functions are given, the default cache  size is set.
+
+ Examples:   )set fun cache all
+             )set fun cache 10 f g Legendre
+
+ In general, functions will cache no returned values.
+\end{verbatim}
+<<functionscache>>=
+     (|cache|
+      "number of function results to cache"
+      |interpreter|
+      FUNCTION
+      |setFunctionsCache|
+      NIL
+      |htSetCache|)
+@
+\subsection{compile}
+Per suggestion by Bill Page this has been defaulted to [[on]].
+\begin{verbatim}
+--------------------- The compile Option ----------------------
+
+ Description: compile, don't just define function bodies
+
+ The compile option may be followed by any one of the following:
+
+ -> on
+    off 
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<functionscompile>>=
+     (|compile|
+      "compile, don't just define function bodies"
+      |interpreter|
+      LITERALS
+      |$compileDontDefineFunctions|
+      (|on| |off|)
+      |on|)
+@
+\subsection{recurrence}
+\begin{verbatim}
+-------------------- The recurrence Option --------------------
+
+ Description: specially compile recurrence relations
+
+ The recurrence option may be followed by any one of the 
+ following:
+
+ -> on 
+    off
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<functionsrecurrence>>=
+     (|recurrence|
+      "specially compile recurrence relations"
+      |interpreter|
+      LITERALS
+      |$compileRecurrence|
+      (|on| |off|)
+      |on|)
+@
+\section{fortran}
+\begin{verbatim}
+              Current Values of  fortran  Variables                   
+
+Variable     Description                           Current Value
+-----------------------------------------------------------------
+ints2floats  where sensible, coerce integers to reals   on 
+fortindent   the number of characters indented          6 
+fortlength   the number of characters on a line         72 
+typedecs     print type and dimension lines             on 
+defaulttype  default generic type for FORTRAN object    REAL 
+precision    precision of generated FORTRAN objects     double 
+intrinsic    whether to use INTRINSIC FORTRAN functions off 
+explength    character limit for FORTRAN expressions    1320 
+segment      split long FORTRAN expressions             on 
+optlevel     FORTRAN optimisation level                 0 
+startindex   starting index for FORTRAN arrays          1 
+calling      options for external FORTRAN calls         ... 
+
+Variables with current values of ... have further sub-options. 
+For example, issue )set calling to see what the options are for 
+calling.
+For more information, issue )help set .
+\end{verbatim}
+<<fortran>>=
+  (|fortran|
+   "view and set options for FORTRAN output"
+   |interpreter|
+   TREE
+   |novar|
+    (
+<<fortranints2floats>>
+<<fortranfortindent>>
+<<fortranfortlength>>
+<<fortrantypedecs>>
+<<fortrandefaulttype>>
+<<fortranprecision>>
+<<fortranintrinsic>>
+<<fortranexplength>>
+<<fortransegment>>
+<<fortranoptlevel>>
+<<fortranstartindex>>
+<<fortrancalling>>
+  ))
+@
+\subsection{ints2floats}
+\begin{verbatim}
+------------------- The ints2floats Option --------------------
+
+ Description: where sensible, coerce integers to reals
+
+ The ints2floats option may be followed by any one of the 
+ following:
+
+ -> on 
+    off
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<fortranints2floats>>=
+     (|ints2floats|
+      "where sensible, coerce integers to reals"
+      |interpreter|
+      LITERALS
+      |$fortInts2Floats|
+      (|on| |off|)
+      |on|)
+@
+\subsection{fortindent}
+\begin{verbatim}
+-------------------- The fortindent Option --------------------
+
+ Description: the number of characters indented
+
+ The fortindent option may be followed by an integer in the range 
+ 0 to inclusive. The current setting is 6 
+
+\end{verbatim}
+<<fortranfortindent>>=
+     (|fortindent|
+      "the number of characters indented"
+      |interpreter|
+      INTEGER
+      |$fortIndent|
+      (0 NIL)
+      6)
+@
+\subsection{fortlength}
+\begin{verbatim}
+-------------------- The fortlength Option --------------------
+
+ Description: the number of characters on a line
+
+ The fortlength option may be followed by an integer in the range 
+ 1 to inclusive. The current setting is 72 
+
+\end{verbatim}
+<<fortranfortlength>>=
+     (|fortlength|
+      "the number of characters on a line"
+      |interpreter|
+      INTEGER
+      |$fortLength|
+      (1 NIL)
+      72)
+@
+\subsection{typedecs}
+\begin{verbatim}
+--------------------- The typedecs Option ---------------------
+
+ Description: print type and dimension lines
+
+ The typedecs option may be followed by any one of the 
+ following:
+
+ -> on 
+    off
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<fortrantypedecs>>=
+     (|typedecs|
+      "print type and dimension lines"
+      |interpreter|
+      LITERALS
+      |$printFortranDecs|
+      (|on| |off|)
+      |on|)
+@
+\subsection{defaulttype}
+\begin{verbatim}
+------------------- The defaulttype Option --------------------
+
+ Description: default generic type for FORTRAN object
+
+ The defaulttype option may be followed by any one of the 
+ following:
+
+ -> REAL 
+    INTEGER
+    COMPLEX
+    LOGICAL
+    CHARACTER
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<fortrandefaulttype>>=
+     (|defaulttype|
+      "default generic type for FORTRAN object"
+      |interpreter|
+      LITERALS
+      |$defaultFortranType|
+      (REAL INTEGER COMPLEX LOGICAL CHARACTER)
+      REAL)
+@
+\subsection{precision}
+\begin{verbatim}
+-------------------- The precision Option ---------------------
+
+ Description: precision of generated FORTRAN objects
+
+ The precision option may be followed by any one of the 
+ following:
+
+    single
+ -> double 
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<fortranprecision>>=
+      (|precision|
+      "precision of generated FORTRAN objects"
+       |interpreter|
+       LITERALS
+       |$fortranPrecision|
+       (|single| |double|)
+       |double|)
+@
+\subsection{intrinsic}
+\begin{verbatim}
+-------------------- The intrinsic Option ---------------------
+
+ Description: whether to use INTRINSIC FORTRAN functions
+
+ The intrinsic option may be followed by any one of the 
+ following:
+
+    on
+ -> off 
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<fortranintrinsic>>=
+      (|intrinsic|
+       "whether to use INTRINSIC FORTRAN functions"
+       |interpreter|
+       LITERALS
+       |$useIntrinsicFunctions|
+       (|on| |off|)
+       |off|)
+@
+\subsection{explength}
+\begin{verbatim}
+-------------------- The explength Option ---------------------
+
+ Description: character limit for FORTRAN expressions
+
+ The explength option may be followed by an integer in the range 
+ 0 to inclusive. The current setting is 1320 
+
+\end{verbatim}
+<<fortranexplength>>=
+      (|explength|
+       "character limit for FORTRAN expressions"
+       |interpreter|
+       INTEGER
+       |$maximumFortranExpressionLength|
+       (0 NIL)
+       1320)
+@
+\subsection{segment}
+\begin{verbatim}
+--------------------- The segment Option ----------------------
+
+ Description: split long FORTRAN expressions
+
+ The segment option may be followed by any one of the following:
+
+ -> on 
+    off
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<fortransegment>>=
+      (|segment|
+       "split long FORTRAN expressions"
+       |interpreter|
+       LITERALS
+       |$fortranSegment|
+       (|on| |off|)
+       |on|)
+@
+\subsection{optlevel}
+\begin{verbatim}
+--------------------- The optlevel Option ---------------------
+
+ Description: FORTRAN optimisation level
+
+ The optlevel option may be followed by an integer in the range 
+ 0 to 2 inclusive. The current setting is 0 
+
+\end{verbatim}
+<<fortranoptlevel>>=
+      (|optlevel|
+       "FORTRAN optimisation level"
+       |interpreter|
+       INTEGER
+       |$fortranOptimizationLevel|
+       (0 2)
+       0)
+@
+\subsection{startindex}
+\begin{verbatim}
+-------------------- The startindex Option --------------------
+
+ Description: starting index for FORTRAN arrays
+
+ The startindex option may be followed by an integer in the range 
+ 0 to 1 inclusive. The current setting is 1 
+
+\end{verbatim}
+<<fortranstartindex>>=
+      (|startindex|
+       "starting index for FORTRAN arrays"
+       |interpreter|
+       INTEGER
+       |$fortranArrayStartingIndex|
+       (0 1)
+       1)
+@
+\subsection{calling}
+\begin{verbatim}
+              Current Values of  calling  Variables                   
+
+Variable     Description                           Current Value
+-----------------------------------------------------------------
+tempfile     set location of temporary data files       /tmp/ 
+directory    set location of generated FORTRAN files    ./ 
+linker       linker arguments (e.g. libraries to search) -lxlf 
+
+\end{verbatim}
+<<fortrancalling>>=
+      (|calling|
+      "options for external FORTRAN calls"
+      |interpreter|
+      TREE
+      |novar|
+      (
+<<callingtempfile>>
+<<callingdirectory>>
+<<callinglinker>>
+       )
+      )
+@
+\subsubsection{tempfile}
+\begin{verbatim}
+--------------------- The tempfile Option ---------------------
+
+ Description: set location of temporary data files
+
+ )set fortran calling tempfile  is used to tell AXIOM where
+ to place intermediate FORTRAN data files . This must be the 
+ name of a valid existing directory to which you have permission 
+ to write (including the final slash).
+
+ Syntax:
+   )set fortran calling tempfile DIRECTORYNAME
+
+ The current setting is /tmp/ 
+\end{verbatim}
+<<callingtempfile>>=
+        (|tempfile|
+         "set location of temporary data files"
+         |interpreter|
+         FUNCTION
+         |setFortTmpDir|
+         (("enter directory name for which you have write-permission"
+           DIRECTORY
+           |$fortranTmpDir|
+           |chkDirectory|
+           "/tmp/"))
+         NIL)
+@
+\subsubsection{directory}
+\begin{verbatim}
+-------------------- The directory Option ---------------------
+
+ Description: set location of generated FORTRAN files
+
+ )set fortran calling directory  is used to tell AXIOM where
+ to place generated FORTRAN files. This must be the name 
+ of a valid existing directory to which you have permission 
+ to write (including the final slash).
+
+ Syntax:
+   )set fortran calling directory DIRECTORYNAME
+
+ The current setting is ./ 
+\end{verbatim}
+<<callingdirectory>>=
+        (|directory|
+         "set location of generated FORTRAN files"
+         |interpreter|
+         FUNCTION
+         |setFortDir|
+         (("enter directory name for which you have write-permission"
+           DIRECTORY
+           |$fortranDirectory|
+           |chkDirectory|
+           "./"))
+         NIL)
+@
+\subsubsection{linker}
+\begin{verbatim}
+---------------------- The linker Option ----------------------
+
+ Description: linker arguments (e.g. libraries to search)
+
+ )set fortran calling linkerargs is used to pass arguments to 
+ the linker when using  mkFort  to create functions which call 
+ Fortran code. For example, it might give a list of libraries 
+ to be searched, and their locations.
+ The string is passed verbatim, so must be the correct syntax for
+ the particular linker being used.
+
+ Example: )set fortran calling linker "-lxlf"
+
+ The current setting is -lxlf 
+\end{verbatim}
+<<callinglinker>>=
+        (|linker|
+         "linker arguments (e.g. libraries to search)"
+         |interpreter|
+         FUNCTION
+         |setLinkerArgs|
+         (("enter linker arguments "
+           STRING
+           |$fortranLibraries|
+           |chkDirectory|
+           "-lxlf"))
+         NIL
+         )
+@
+\section{kernel}
+\begin{verbatim}
+              Current Values of  kernel  Variables                    
+
+Variable     Description                           Current Value
+-----------------------------------------------------------------
+warn         warn when re-definition is attempted       off 
+protect      prevent re-definition of kernel functions  off 
+
+\end{verbatim}
+<<kernel>>=
+  (|kernel|
+   "library functions built into the kernel for efficiency"
+   |interpreter|
+   TREE
+   |novar|
+   (
+<<kernelwarn>>
+<<kernelprotect>>
+   )
+  )
+@
+\subsection{kernelwarn}
+\begin{verbatim}
+----------------------- The warn Option -----------------------
+
+ Description: warn when re-definition is attempted
+
+Some AXIOM library functions are compiled into the kernel for 
+efficiency reasons. To prevent them being re-defined when loaded 
+from a library they are specially protected. If a user wishes to 
+know when an attempt is made to re-define such a function, he or 
+she should issue the command:
+        )set kernel warn on
+To restore the default behaviour, he or she should issue the 
+command:
+        )set kernel warn off
+\end{verbatim}
+<<kernelwarn>>=
+     (|warn|
+      "warn when re-definition is attempted"
+      |interpreter|
+      FUNCTION
+      |protectedSymbolsWarning|
+      NIL
+      |htSetKernelWarn|)
+@
+\subsection{kernelprotect}
+\begin{verbatim}
+--------------------- The protect Option ----------------------
+
+ Description: prevent re-definition of kernel functions
+
+Some AXIOM library functions are compiled into the kernel for 
+efficiency reasons. To prevent them being re-defined when loaded
+from a library they are specially protected.  If a user wishes 
+to re-define these functions, he or she should issue the command:
+        )set kernel protect off
+To restore the default behaviour, he or she should issue the 
+command:
+        )set kernel protect on
+\end{verbatim}
+<<kernelprotect>>=
+     (|protect|
+      "prevent re-definition of kernel functions"
+      |interpreter|
+      FUNCTION
+      |protectSymbols|
+      NIL
+      |htSetKernelProtect|)
+@
+\section{hyperdoc}
+\begin{verbatim}
+             Current Values of  hyperdoc  Variables                   
+
+Variable     Description                           Current Value
+-----------------------------------------------------------------
+fullscreen   use full screen for this facility          off 
+mathwidth    screen width for history output            120 
+
+\end{verbatim}
+<<hyperdoc>>=
+  (|hyperdoc|
+   "options in using HyperDoc"
+   |interpreter|
+   TREE
+   |novar|
+   (
+<<hyperdocfullscreen>>
+<<hyperdocmathwidth>>
+   ))
+@
+\subsection{fullscreen}
+\begin{verbatim}
+-------------------- The fullscreen Option --------------------
+
+ Description: use full screen for this facility
+
+ The fullscreen option may be followed by any one of the 
+ following:
+
+    on
+ -> off 
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<hyperdocfullscreen>>=
+     (|fullscreen|
+      "use full screen for this facility"
+      |interpreter|
+      LITERALS
+      |$fullScreenSysVars|
+      (|on| |off|)
+      |off|)
+@
+\subsection{mathwidth}
+\begin{verbatim}
+-------------------- The mathwidth Option ---------------------
+
+ Description: screen width for history output
+
+ The mathwidth option may be followed by an integer in the range 
+ 0 to inclusive. The current setting is 120 
+
+\end{verbatim}
+<<hyperdocmathwidth>>=
+     (|mathwidth|
+      "screen width for history output"
+      |interpreter|
+      INTEGER
+      |$historyDisplayWidth|
+      (0 NIL)
+      120)
+@
+\section{help}
+\begin{verbatim}
+               Current Values of  help  Variables                     
+
+Variable     Description                           Current Value
+-----------------------------------------------------------------
+fullscreen   use fullscreen facility, if possible       off 
+
+\end{verbatim}
+<<help>>=
+  (|help|
+   "view and set some help options"
+   |interpreter|
+   TREE
+   |novar|
+   (
+<<helpfullscreen>>
+   ))
+@
+\subsection{fullscreen}
+\begin{verbatim}
+-------------------- The fullscreen Option --------------------
+
+ Description: use fullscreen facility, if possible
+
+ The fullscreen option may be followed by any one of the 
+ following:
+
+    on
+ -> off 
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<helpfullscreen>>=
+    (|fullscreen|
+     "use fullscreen facility, if possible"
+     |interpreter|
+     LITERALS
+     |$useFullScreenHelp|
+     (|on| |off|)
+     |off|)
+@
+\section{history}
+\begin{verbatim}
+--------------------- The history Option ----------------------
+
+ Description: save workspace values in a history file
+
+ The history option may be followed by any one of the 
+ following:
+
+ -> on 
+    off
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<history>>=
+  (|history|
+   "save workspace values in a history file"
+   |interpreter|
+   LITERALS
+   |$HiFiAccess|
+   (|on| |off|)
+   |on|)
+@
+\section{messages}
+\begin{verbatim}
+             Current Values of  messages  Variables                   
+
+Variable     Description                           Current Value
+-----------------------------------------------------------------
+autoload     print file auto-load messages              off 
+bottomup     display bottom up modemap selection        off 
+coercion     display datatype coercion messages         off 
+dropmap      display old map defn when replaced         off 
+expose       warning for unexposed functions            off 
+file         print msgs also to SPADMSG LISTING         off 
+frame        display messages about frames              off 
+highlighting use highlighting in system messages        off 
+instant      present instantiation summary              off 
+insteach     present instantiation info                 off 
+interponly   say when function code is interpreted      on 
+number       display message number with message        off 
+prompt       set type of input prompt to display        step 
+selection    display function selection msgs            off 
+set          show )set setting after assignment         off 
+startup      display messages on start-up               off 
+summary      print statistics after computation         off 
+testing      print system testing header                off 
+time         print timings after computation            off 
+type         print type after computation               on 
+void         print Void value when it occurs            off 
+any          print the internal type of objects of domain Any on 
+naglink      show NAGLink messages                      on 
+
+\end{verbatim}
+<<messages>>=
+  (|messages|
+   "show messages for various system features"
+   |interpreter|
+   TREE
+   |novar|
+   (
+<<messagesany>>
+<<messagesautoload>>
+<<messagesbottomup>>
+<<messagescoercion>>
+<<messagesdropmap>>
+<<messagesexpose>>
+<<messagesfile>>
+<<messagesframe>>
+<<messageshighlighting>>
+<<messagesinstant>>
+<<messagesinsteach>>
+<<messagesinterponly>>
+<<messagesnaglink>>
+<<messagesnumber>>
+<<messagesprompt>>
+<<messagesselection>>
+<<messagesset>>
+<<messagesstartup>>
+<<messagessummary>>
+<<messagestesting>>
+<<messagestime>>
+<<messagestype>>
+<<messagesvoid>>
+   ))
+@
+\subsection{any}
+\begin{verbatim}
+----------------------- The any Option ------------------------
+
+ Description: print the internal type of objects of domain Any
+
+ The any option may be followed by any one of the following:
+
+ -> on 
+    off
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<messagesany>>=
+     (|any|
+      "print the internal type of objects of domain Any"
+      |interpreter|
+      LITERALS
+      |$printAnyIfTrue|
+      (|on| |off|)
+      |on|)
+@
+\subsection{autoload}
+\begin{verbatim}
+--------------------- The autoload Option ---------------------
+
+ Description: print file auto-load messages
+
+\end{verbatim}
+<<messagesautoload>>=
+     (|autoload|
+      "print file auto-load messages"
+      |interpreter|
+      FUNCTION
+      |printLoadMessages|
+      (|on| |off|)
+      |on|)
+@
+\subsection{bottomup}
+\begin{verbatim}
+--------------------- The bottomup Option ---------------------
+
+ Description: display bottom up modemap selection
+
+ The bottomup option may be followed by any one of the 
+ following:
+
+    on
+ -> off 
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<messagesbottomup>>=
+     (|bottomup|
+      "display bottom up modemap selection"
+      |development|
+      LITERALS
+      |$reportBottomUpFlag|
+      (|on| |off|)
+      |off|)
+@
+\subsection{coercion}
+\begin{verbatim}
+--------------------- The coercion Option ---------------------
+
+ Description: display datatype coercion messages
+
+ The coercion option may be followed by any one of the 
+ following:
+
+    on
+ -> off 
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<messagescoercion>>=
+     (|coercion|
+      "display datatype coercion messages"
+      |development|
+      LITERALS
+      |$reportCoerceIfTrue|
+      (|on| |off|)
+      |off|)
+@
+\subsection{dropmap}
+\begin{verbatim}
+--------------------- The dropmap Option ----------------------
+
+ Description: display old map defn when replaced
+
+ The dropmap option may be followed by any one of the 
+ following:
+
+    on
+ -> off 
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<messagesdropmap>>=
+     (|dropmap|
+      "display old map defn when replaced"
+      |interpreter|
+      LITERALS
+      |$displayDroppedMap|
+      (|on| |off|)
+      |off|)
+@
+\subsection{expose}
+\begin{verbatim}
+---------------------- The expose Option ----------------------
+
+ Description: warning for unexposed functions
+
+ The expose option may be followed by any one of the 
+ following:
+
+    on
+ -> off 
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<messagesexpose>>=
+     (|expose|
+      "warning for unexposed functions"
+      |interpreter|
+      LITERALS
+      |$giveExposureWarning|
+      (|on| |off|)
+      |off|)
+@
+\subsection{file}
+\begin{verbatim}
+----------------------- The file Option -----------------------
+
+ Description: print msgs also to SPADMSG LISTING
+
+ The file option may be followed by any one of the 
+ following:
+
+    on
+ -> off 
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<messagesfile>>=
+     (|file|
+      "print msgs also to SPADMSG LISTING"
+      |development|
+      LITERALS
+      |$printMsgsToFile|
+      (|on| |off|)
+      |off|)
+@
+\subsection{frame}
+\begin{verbatim}
+---------------------- The frame Option -----------------------
+
+ Description: display messages about frames
+
+ The frame option may be followed by any one of the following:
+
+    on
+ -> off 
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<messagesframe>>=
+     (|frame|
+      "display messages about frames"
+      |interpreter|
+      LITERALS
+      |$frameMessages|
+      (|on| |off|)
+      |off|)
+@
+\subsection{highlighting}
+\begin{verbatim}
+------------------- The highlighting Option -------------------
+
+ Description: use highlighting in system messages
+
+ The highlighting option may be followed by any one of the 
+ following:
+
+    on
+ -> off 
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<messageshighlighting>>=
+     (|highlighting|
+      "use highlighting in system messages"
+      |interpreter|
+      LITERALS
+      |$highlightAllowed|
+      (|on| |off|)
+      |off|)
+@
+\subsection{instant}
+\begin{verbatim}
+--------------------- The instant Option ----------------------
+
+ Description: present instantiation summary
+
+ The instant option may be followed by any one of the 
+ following:
+
+    on
+ -> off 
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<messagesinstant>>=
+     (|instant|
+      "present instantiation summary"
+      |development|
+      LITERALS
+      |$reportInstantiations|
+      (|on| |off|)
+      |off|)
+@
+\subsection{insteach}
+\begin{verbatim}
+--------------------- The insteach Option ---------------------
+
+ Description: present instantiation info
+
+ The insteach option may be followed by any one of the 
+ following:
+
+    on
+ -> off 
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<messagesinsteach>>=
+     (|insteach|
+      "present instantiation info"
+      |development|
+      LITERALS
+      |$reportEachInstantiation|
+      (|on| |off|)
+      |off|)
+@
+\subsection{interponly}
+\begin{verbatim}
+-------------------- The interponly Option --------------------
+
+ Description: say when function code is interpreted
+
+ The interponly option may be followed by any one of the 
+ following:
+
+ -> on 
+    off
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<messagesinterponly>>=
+     (|interponly|
+      "say when function code is interpreted"
+      |interpreter|
+      LITERALS
+      |$reportInterpOnly|
+      (|on| |off|)
+      |on|)
+@
+\subsection{naglink}
+\begin{verbatim}
+--------------------- The naglink Option ----------------------
+
+ Description: show NAGLink messages
+
+ The naglink option may be followed by any one of the 
+ following:
+
+ -> on 
+    off
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<messagesnaglink>>=
+     (|naglink|
+      "show NAGLink messages"
+      |interpreter|
+      LITERALS
+      |$nagMessages|
+      (|on| |off|)
+      |on|)
+@
+\subsection{number}
+\begin{verbatim}
+---------------------- The number Option ----------------------
+
+ Description: display message number with message
+
+ The number option may be followed by any one of the 
+ following:
+
+    on
+ -> off 
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<messagesnumber>>=
+     (|number|
+      "display message number with message"
+      |interpreter|
+      LITERALS
+      |$displayMsgNumber|
+      (|on| |off|)
+      |off|)
+@
+\subsection{prompt}
+\begin{verbatim}
+---------------------- The prompt Option ----------------------
+
+ Description: set type of input prompt to display
+
+ The prompt option may be followed by any one of the following:
+
+    none
+    frame
+    plain
+ -> step 
+    verbose
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<messagesprompt>>=
+     (|prompt|
+      "set type of input prompt to display"
+      |interpreter|
+      LITERALS
+      |$inputPromptType|
+      (|none| |frame| |plain| |step| |verbose|)
+      |step|)
+@
+\subsection{selection}
+\begin{verbatim}
+-------------------- The selection Option ---------------------
+
+ Description: display function selection msgs
+
+ The selection option may be followed by any one of the 
+ following:
+
+    on
+ -> off 
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<messagesselection>>=
+     (|selection|
+      "display function selection msgs"
+      |interpreter|
+      LITERALS
+      |$reportBottomUpFlag|
+      (|on| |off|)
+      |off|)
+@
+\subsection{set}
+\begin{verbatim}
+----------------------- The set Option ------------------------
+
+ Description: show )set setting after assignment
+
+ The set option may be followed by any one of the following:
+
+    on
+ -> off 
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<messagesset>>=
+     (|set|
+      "show )set setting after assignment"
+      |interpreter|
+      LITERALS
+      |$displaySetValue|
+      (|on| |off|)
+      |off|)
+@
+\subsection{startup}
+\begin{verbatim}
+--------------------- The startup Option ----------------------
+
+ Description: display messages on start-up
+
+ The startup option may be followed by any one of the 
+ following:
+
+    on
+ -> off 
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<messagesstartup>>=
+     (|startup|
+      "display messages on start-up"
+      |interpreter|
+      LITERALS
+      |$displayStartMsgs|
+      (|on| |off|)
+      |on|)
+@
+\subsection{summary}
+\begin{verbatim}
+--------------------- The summary Option ----------------------
+
+ Description: print statistics after computation
+
+ The summary option may be followed by any one of the 
+ following:
+
+    on
+ -> off 
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<messagessummary>>=
+     (|summary|
+      "print statistics after computation"
+      |interpreter|
+      LITERALS
+      |$printStatisticsSummaryIfTrue|
+      (|on| |off|)
+      |off|)
+@
+\subsection{testing}
+\begin{verbatim}
+--------------------- The testing Option ----------------------
+
+ Description: print system testing header
+
+ The testing option may be followed by any one of the 
+ following:
+
+    on
+ -> off 
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<messagestesting>>=
+     (|testing|
+      "print system testing header"
+      |development|
+      LITERALS
+      |$testingSystem|
+      (|on| |off|)
+      |off|)
+@
+\subsection{time}
+\begin{verbatim}
+----------------------- The time Option -----------------------
+
+ Description: print timings after computation
+
+ The time option may be followed by any one of the following:
+
+    on
+ -> off 
+    long
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<messagestime>>=
+     (|time|
+      "print timings after computation"
+      |interpreter|
+      LITERALS
+      |$printTimeIfTrue|
+      (|on| |off| |long|)
+      |off|)
+@
+\subsection{type}
+\begin{verbatim}
+----------------------- The type Option -----------------------
+
+ Description: print type after computation
+
+ The type option may be followed by any one of the following:
+
+ -> on 
+    off
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<messagestype>>=
+     (|type|
+      "print type after computation"
+      |interpreter|
+      LITERALS
+      |$printTypeIfTrue|
+      (|on| |off|)
+      |on|)
+@
+\subsection{void}
+\begin{verbatim}
+----------------------- The void Option -----------------------
+
+ Description: print Void value when it occurs
+
+ The void option may be followed by any one of the following:
+
+    on
+ -> off 
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<messagesvoid>>=
+     (|void|
+      "print Void value when it occurs"
+      |interpreter|
+      LITERALS
+      |$printVoidIfTrue|
+      (|on| |off|)
+      |off|)
+@
+\section{naglink}
+\begin{verbatim}
+              Current Values of  naglink  Variables                   
+
+Variable     Description                           Current Value
+-----------------------------------------------------------------
+host         internet address of host for NAGLink       localhost 
+persistence  number of (fortran) functions to remember  1 
+messages     show NAGLink messages                      on 
+double       enforce DOUBLE PRECISION ASPs              on 
+
+\end{verbatim}
+<<naglink>>=
+  (|naglink|
+   "options for NAGLink"
+   |interpreter|
+   TREE
+   |novar|
+   (
+<<naglinkhost>>
+<<naglinkpersistence>>
+<<naglinkmessages>>
+<<naglinkdouble>>
+   ))
+@
+\subsection{host}
+\begin{verbatim}
+----------------------- The host Option -----------------------
+
+ Description: internet address of host for NAGLink
+
+ )set naglink host is used to tell  AXIOM which  host to contact
+ for a NAGLink request. An Internet address should be supplied. 
+ The host specified must be running the NAGLink daemon.
+
+ The current setting is localhost 
+\end{verbatim}
+<<naglinkhost>>=
+     (|host|
+      "internet address of host for NAGLink"
+      |interpreter|
+      FUNCTION
+      |setNagHost|
+      (("enter host name"
+        DIRECTORY
+        |$nagHost|
+        |chkDirectory|
+        "localhost"))
+      NIL)
+@
+\subsection{persistence}
+\begin{verbatim}
+------------------- The persistence Option --------------------
+
+ Description: number of (fortran) functions to remember
+
+ )set naglink persistence is used to tell  the  nagd  daemon how
+  many ASP source and object files to keep around in case you 
+  reuse them. This helps to avoid needless recompilations. The 
+  number specified should be a non-negative integer.
+
+ The current setting is 1 
+\end{verbatim}
+<<naglinkpersistence>>=
+     (|persistence|
+      "number of (fortran) functions to remember"
+      |interpreter|
+      FUNCTION
+      |setFortPers|
+      (("Requested remote storage (for asps):"
+       INTEGER
+       |$fortPersistence|
+       (0 NIL)
+       10))
+      NIL)
+@
+\subsection{messages}
+\begin{verbatim}
+--------------------- The messages Option ---------------------
+
+ Description: show NAGLink messages
+
+ The messages option may be followed by any one of the 
+ following:
+
+ -> on 
+    off
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<naglinkmessages>>=
+     (|messages|
+      "show NAGLink messages"
+      |interpreter|
+      LITERALS
+      |$nagMessages|
+      (|on| |off|)
+       |on|)
+@
+\subsection{double}
+\begin{verbatim}
+---------------------- The double Option ----------------------
+
+ Description: enforce DOUBLE PRECISION ASPs
+
+ The double option may be followed by any one of the following:
+
+ -> on 
+    off
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<naglinkdouble>>=
+     (|double|
+      "enforce DOUBLE PRECISION ASPs"
+      |interpreter|
+      LITERALS
+      |$nagEnforceDouble|
+      (|on| |off|)
+      |on|)
+@
+\section{output}
+The result of the {\bf )set output} command is:
+\begin{verbatim}
+Variable     Description                           Current Value
+-----------------------------------------------------------------
+abbreviate  abbreviate type names                    off 
+algebra     display output in algebraic form         On:CONSOLE 
+characters  choose special output character set      plain 
+fortran     create output in FORTRAN format          Off:CONSOLE 
+fraction    how fractions are formatted              vertical 
+length      line length of output displays           77 
+mathml	    create output in MathML style	     Off:CONSOLE 
+openmath    create output in OpenMath style          Off:CONSOLE
+script      display output in SCRIPT formula format  Off:CONSOLE 
+scripts     show subscripts,... linearly             off 
+showeditor  view output of )show in editor           off 
+tex         create output in TeX style               Off:CONSOLE 
+\end{verbatim}
+Since the output option has a bunch of sub-options each suboption 
+is defined within the output structure.
+<<output>>=
+  (|output|
+   "view and set some output options"
+   |interpreter|
+   TREE
+   |novar|
+    (
+<<outputabbreviate>>
+<<outputalgebra>>
+<<outputcharacters>>
+<<outputfortran>>
+<<outputfraction>>
+<<outputlength>>
+<<outputmathml>>
+<<outputopenmath>>
+<<outputscript>>
+<<outputscripts>>
+<<outputshoweditor>>
+<<outputtex>>
+ ))
+@
+\subsection{abbreviate}
+\begin{verbatim}
+-------------------- The abbreviate Option --------------------
+
+ Description: abbreviate type names
+
+ The abbreviate option may be followed by any one of the 
+ following:
+
+    on
+ -> off 
+
+ The current setting is indicated.
+\end{verbatim}
+<<outputabbreviate>>=
+     (|abbreviate|
+      "abbreviate type names"
+      |interpreter|
+      LITERALS
+      |$abbreviateTypes|
+      (|on| |off|)
+      |off|)
+@
+\subsection{algebra}
+\begin{verbatim}
+--------------------- The algebra Option ----------------------
+
+ Description: display output in algebraic form
+
+ )set output algebra is used to tell AXIOM to turn algebra-style
+  output printing on and off, and where to place the output.  By
+  default, the destination for the output is the screen but 
+  printing is turned off.
+
+Syntax:   )set output algebra <arg>
+    where arg can be one of
+  on          turn algebra printing on (default state)
+  off         turn algebra printing off
+  console     send algebra output to screen (default state)
+  fp<.fe>     send algebra output to file with file prefix fp
+              and file extension .fe. If not given, 
+              .fe defaults to .spout.
+
+If you wish to send the output to a file, you may need to issue
+this command twice: once with on and once with the file name. 
+For example, to send algebra output to the file polymer.spout,
+issue the two commands
+
+  )set output algebra on
+  )set output algebra polymer
+
+The output is placed in the directory from which you invoked 
+AXIOM or the one you set with the )cd system command.
+The current setting is:  On:CONSOLE 
+\end{verbatim}
+<<outputalgebra>>=
+     (|algebra|
+      "display output in algebraic form"
+      |interpreter|
+      FUNCTION
+      |setOutputAlgebra|
+      (("display output in algebraic form"
+        LITERALS
+        |$algebraFormat|
+        (|off| |on|)
+        |on|)
+       (break $algebraFormat)
+       ("where algebra printing goes (enter {\em console} or a pathname)?"
+        FILENAME
+        |$algebraOutputFile|
+        |chkOutputFileName|
+        "console"))
+      NIL)
+@
+\subsection{characters}
+\begin{verbatim}
+-------------------- The characters Option --------------------
+
+ Description: choose special output character set
+
+
+ The characters option may be followed by any one of the 
+ following:
+
+    default
+ -> plain 
+
+ The current setting is indicated.  This 
+ option  determines the special characters used for algebraic 
+ output. This is what the current choice of special characters 
+ looks like:
+   ulc is shown as +          urc is shown as +       
+   llc is shown as +          lrc is shown as +       
+   vbar is shown as |         hbar is shown as -      
+   quad is shown as ?         lbrk is shown as [      
+   rbrk is shown as ]         lbrc is shown as {      
+   rbrc is shown as }         ttee is shown as +      
+   btee is shown as +         rtee is shown as +      
+   ltee is shown as +         ctee is shown as +      
+   bslash is shown as \    
+\end{verbatim}
+<<outputcharacters>>=
+     (|characters|
+      "choose special output character set"
+      |interpreter|
+      FUNCTION
+      |setOutputCharacters|
+      NIL
+      |htSetOutputCharacters|)
+@
+\subsection{fortran}
+\begin{verbatim}
+--------------------- The fortran Option ----------------------
+
+ Description: create output in FORTRAN format
+
+ )set output fortran is used to tell AXIOM to turn FORTRAN-style
+  output printing on and off, and where to place the output.  By
+  default, the destination for the output is the screen but 
+  printing is turned off.
+
+Also See: )set fortran
+
+Syntax:   )set output fortran <arg>
+    where arg can be one of
+  on          turn FORTRAN printing on
+  off         turn FORTRAN printing off (default state)
+  console     send FORTRAN output to screen (default state)
+  fp<.fe>     send FORTRAN output to file with file prefix 
+              fp and file extension .fe. If not given, 
+              .fe defaults to .sfort.
+
+If you wish to send the output to a file, you must issue 
+this command twice: once with on and once with the file name.
+For example, to send FORTRAN output to the file polymer.sfort,
+ issue the two commands
+
+  )set output fortran on
+  )set output fortran polymer
+
+The output is placed in the directory from which you invoked
+AXIOM or the one you set with the )cd system command.
+The current setting is:  Off:CONSOLE 
+\end{verbatim}
+<<outputfortran>>=
+     (|fortran|
+      "create output in FORTRAN format"
+      |interpreter|
+      FUNCTION
+      |setOutputFortran|
+      (("create output in FORTRAN format"
+        LITERALS
+        |$fortranFormat|
+        (|off| |on|)
+        |off|)
+       (|break| |$fortranFormat|)
+       ("where FORTRAN output goes (enter {\em console} or a a pathname)"
+        FILENAME
+        |$fortranOutputFile|
+        |chkOutputFileName|
+        "console"))
+      NIL)
+@
+\subsection{fraction}
+\begin{verbatim}
+--------------------- The fraction Option ---------------------
+
+ Description: how fractions are formatted
+
+ The fraction option may be followed by any one of the following:
+
+ -> vertical 
+    horizontal
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<outputfraction>>=
+     (|fraction|
+      "how fractions are formatted"
+      |interpreter|
+      LITERALS
+      |$fractionDisplayType|
+      (|vertical| |horizontal|)
+      |vertical|)
+@
+\subsection{length}
+\begin{verbatim}
+---------------------- The length Option ----------------------
+
+ Description: line length of output displays
+
+ The length option may be followed by an integer in the range 
+ 10 to 245 inclusive. The current setting is 77 
+
+\end{verbatim}
+<<outputlength>>=
+     (|length|
+      "line length of output displays"
+      |interpreter|
+      INTEGER
+      $LINELENGTH
+      (10 245)
+      77)
+@
+\subsection{mathml}
+\begin{verbatim}
+----------------------- The mathml Option ------------------------
+
+ Description: create output in MathML style
+
+ )set output mathml is used to tell AXIOM to turn MathML-style output
+printing on and off, and where to place the output.  By default,
+the destination for the output is the screen but printing is 
+turned off.
+
+Syntax:   )set output mathml <arg>
+    where arg can be one of
+  on          turn MathML printing on
+  off         turn MathML printing off (default state)
+  console     send MathML output to screen (default state)
+  fp<.fe>     send MathML output to file with file prefix fp
+              and file extension .fe. If not given, 
+              .fe defaults to .smml.
+
+If you wish to send the output to a file, you must issue 
+this command twice: once with on and once with the file name. 
+For example, to send MathML output to the file polymer.smml, 
+issue the two commands
+
+  )set output mathml on
+  )set output mathml polymer
+
+The output is placed in the directory from which you invoked 
+AXIOM or the one you set with the )cd system command.
+The current setting is:  Off:CONSOLE 
+\end{verbatim}
+<<outputmathml>>=
+     (|mathml|
+      "create output in MathML style"
+      |interpreter|
+      FUNCTION
+      |setOutputMathml|
+      (("create output in MathML format"
+        LITERALS
+        |$mathmlFormat|
+        (|off| |on|)
+        |off|)
+       (|break| |$mathmlFormat|)
+       ("where MathML output goes (enter {\em console} or a pathname)"
+        FILENAME
+        |$mathmlOutputFile|
+        |chkOutputFileName|
+        "console"))
+      NIL)
+
+@
+\subsection{openmath}
+\begin{verbatim}
+----------------------- The openmath Option ------------------------
+
+ Description: create output in OpenMath style
+
+ )set output tex is used to tell AXIOM to turn OpenMath output
+printing on and off, and where to place the output.  By default,
+the destination for the output is the screen but printing is 
+turned off.
+
+Syntax:   )set output tex <arg>
+    where arg can be one of
+  on          turn OpenMath printing on
+  off         turn OpenMath printing off (default state)
+  console     send OpenMath output to screen (default state)
+  fp<.fe>     send OpenMath output to file with file prefix fp
+              and file extension .fe. If not given, 
+              .fe defaults to .sopen.
+
+If you wish to send the output to a file, you must issue 
+this command twice: once with on and once with the file name. 
+For example, to send OpenMath output to the file polymer.sopen, 
+issue the two commands
+
+  )set output openmath on
+  )set output openmath polymer
+
+The output is placed in the directory from which you invoked 
+AXIOM or the one you set with the )cd system command.
+The current setting is:  Off:CONSOLE 
+\end{verbatim}
+<<outputopenmath>>=
+     (|openmath|
+      "create output in OpenMath style"
+      |interpreter|
+      FUNCTION
+      |setOutputOpenMath|
+      (("create output in OpenMath format"
+        LITERALS
+        |$openMathFormat|
+        (|off| |on|)
+        |off|)
+       (|break| |$openMathFormat|)
+       ("where TeX output goes (enter {\em console} or a pathname)"
+        FILENAME
+        |$openMathOutputFile|
+        |chkOutputFileName|
+        "console"))
+      NIL)
+@
+\subsection{script}
+\begin{verbatim}
+---------------------- The script Option ----------------------
+
+ Description: display output in SCRIPT formula format
+
+ )set output script is used to tell AXIOM to turn IBM Script
+ formula-style output printing on and off, and where to place
+ the output.  By default, the destination for the output is the 
+ screen but printing is turned off.
+
+Syntax:   )set output script <arg>
+    where arg can be one of
+  on      turn IBM Script formula printing on
+  off     turn IBM Script formula printing off 
+          (default state)
+  console send IBM Script formula output to screen 
+          (default state)
+  fp<.fe> send IBM Script formula output to file with file 
+          prefix fp and file extension .fe. If not given, 
+          .fe defaults to .sform.
+
+If you wish to send the output to a file, you must issue 
+this command twice: once with on and once with the file 
+name. For example, to send IBM Script formula output to 
+the file polymer.sform, issue the two commands
+
+  )set output script on
+  )set output script polymer
+
+The output is placed in the directory from which you 
+invoked AXIOM or the one you set with the )cd system command.
+The current setting is:  Off:CONSOLE 
+\end{verbatim}
+<<outputscript>>=
+     (|script|
+      "display output in SCRIPT formula format"
+      |interpreter|
+      FUNCTION
+      |setOutputFormula|
+      (("display output in SCRIPT format"
+        LITERALS
+        |$formulaFormat|
+        (|off| |on|)
+        |off|)
+       (|break| |$formulaFormat|)
+       ("where script output goes (enter {\em console} or a a pathname)"
+        FILENAME
+        |$formulaOutputFile|
+        |chkOutputFileName|
+        "console"))
+      NIL)
+@
+\subsection{scripts}
+\begin{verbatim}
+--------------------- The scripts Option ----------------------
+
+ Description: show subscripts,... linearly
+
+ The scripts option may be followed by any one of the following:
+
+    yes
+    no
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<outputscripts>>=
+     (|scripts|
+      "show subscripts,... linearly"
+      |interpreter|
+      LITERALS
+      |$linearFormatScripts|
+      (|on| |off|)
+      |off|)
+@
+\subsection{showeditor}
+\begin{verbatim}
+-------------------- The showeditor Option --------------------
+
+ Description: view output of )show in editor
+
+ The showeditor option may be followed by any one of the 
+ following:
+
+    on
+ -> off 
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<outputshoweditor>>=
+     (|showeditor|
+      "view output of )show in editor"
+      |interpreter|
+      LITERALS
+      |$useEditorForShowOutput|
+      (|on| |off|)
+      |off|)
+@
+\subsection{tex}
+\begin{verbatim}
+----------------------- The tex Option ------------------------
+
+ Description: create output in TeX style
+
+ )set output tex is used to tell AXIOM to turn TeX-style output
+printing on and off, and where to place the output.  By default,
+the destination for the output is the screen but printing is 
+turned off.
+
+Syntax:   )set output tex <arg>
+    where arg can be one of
+  on          turn TeX printing on
+  off         turn TeX printing off (default state)
+  console     send TeX output to screen (default state)
+  fp<.fe>     send TeX output to file with file prefix fp
+              and file extension .fe. If not given, 
+              .fe defaults to .stex.
+
+If you wish to send the output to a file, you must issue 
+this command twice: once with on and once with the file name. 
+For example, to send TeX output to the file polymer.stex, 
+issue the two commands
+
+  )set output tex on
+  )set output tex polymer
+
+The output is placed in the directory from which you invoked 
+AXIOM or the one you set with the )cd system command.
+The current setting is:  Off:CONSOLE 
+\end{verbatim}
+<<outputtex>>=
+     (|tex|
+      "create output in TeX style"
+      |interpreter|
+      FUNCTION
+      |setOutputTex|
+      (("create output in TeX format"
+        LITERALS
+        |$texFormat|
+        (|off| |on|)
+        |off|)
+       (|break| |$texFormat|)
+       ("where TeX output goes (enter {\em console} or a pathname)"
+        FILENAME
+        |$texOutputFile|
+        |chkOutputFileName|
+        "console"))
+      NIL)
+@
+\section{quit}
+\begin{verbatim}
+----------------------- The quit Option -----------------------
+
+ Description: protected or unprotected quit
+
+ The quit option may be followed by any one of the following:
+
+    protected
+ -> unprotected 
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<quit>>=
+  (|quit|
+   "protected or unprotected quit"
+   |interpreter|
+   LITERALS
+   |$quitCommandType|
+   (|protected| |unprotected|)
+   |protected|)
+@
+\section{streams}
+\begin{verbatim}
+              Current Values of  streams  Variables                   
+
+Variable     Description                           Current Value
+-----------------------------------------------------------------
+calculate    specify number of elements to calculate    10 
+showall      display all stream elements computed       off 
+
+\end{verbatim}
+<<streams>>=
+  (|streams|
+   "set some options for working with streams"
+   |interpreter|
+   TREE
+   |novar|
+   (
+<<streamscalculate>>
+<<streamsshowall>>
+  ))
+@
+\subsection{calculate}
+\begin{verbatim}
+-------------------- The calculate Option ---------------------
+
+ Description: specify number of elements to calculate
+
+   )set streams calculate is used to tell AXIOM how many elements
+    of a stream to calculate when a computation uses the stream. 
+    The value given after calculate must either be the word all 
+    or a positive integer.
+
+      The current setting is 10 .
+\end{verbatim}
+<<streamscalculate>>=
+     (|calculate|
+      "specify number of elements to calculate"
+      |interpreter|
+      FUNCTION
+      |setStreamsCalculate|
+      (("number of initial stream elements you want calculated"
+       INTEGER
+       |$streamCount|
+       (0 NIL)
+       10))
+      NIL)
+@
+\subsection{showall}
+\begin{verbatim}
+--------------------- The showall Option ----------------------
+
+ Description: display all stream elements computed
+
+ The showall option may be followed by any one of the following:
+
+    on
+ -> off 
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<streamsshowall>>=
+    (|showall|
+     "display all stream elements computed"
+     |interpreter|
+     LITERALS
+     |$streamsShowAll|
+     (|on| |off|)
+     |off|)
+@
+\section{system}
+\begin{verbatim}
+              Current Values of  system  Variables                    
+
+Variable     Description                           Current Value
+-----------------------------------------------------------------
+functioncode show gen. LISP for functions when compiled off 
+optimization show optimized LISP code                   off 
+prettyprint  prettyprint BOOT func's as they compile    off 
+
+\end{verbatim}
+<<system>>=
+  (|system|
+   "set some system development variables"
+   |development|
+   TREE
+   |novar|
+   (
+<<systemfunctioncode>>
+<<systemoptimization>>
+<<systemprettyprint>>
+   ))
+@
+\subsection{functioncode}
+\begin{verbatim}
+------------------- The functioncode Option -------------------
+
+ Description: show gen. LISP for functions when compiled
+
+ The functioncode option may be followed by any one of the 
+ following:
+
+    on
+ -> off 
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<systemfunctioncode>>=
+     (|functioncode|
+      "show gen. LISP for functions when compiled"
+      |development|
+      LITERALS
+      |$reportCompilation|
+      (|on| |off|)
+      |off|)
+@
+\subsection{optimization}
+\begin{verbatim}
+------------------- The optimization Option -------------------
+
+ Description: show optimized LISP code
+
+ The optimization option may be followed by any one of the 
+ following:
+
+    on
+ -> off 
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<systemoptimization>>=
+     (|optimization|
+      "show optimized LISP code"
+      |development|
+      LITERALS
+      |$reportOptimization|
+      (|on| |off|)
+      |off|)
+@
+\subsection{prettyprint}
+\begin{verbatim}
+------------------- The prettyprint Option --------------------
+
+ Description: prettyprint BOOT func's as they compile
+
+ The prettyprint option may be followed by any one of the 
+ following:
+
+    on
+ -> off 
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<systemprettyprint>>=
+     (|prettyprint|
+      "prettyprint BOOT func's as they compile"
+      |development|
+      LITERALS
+      $PRETTYPRINT
+      (|on| |off|)
+      |on|)
+@
+\section{userlevel}
+\begin{verbatim}
+-------------------- The userlevel Option ---------------------
+
+ Description: operation access level of system user
+
+ The userlevel option may be followed by any one of the 
+ following:
+
+    interpreter
+    compiler
+ -> development 
+
+ The current setting is indicated.
+
+\end{verbatim}
+<<userlevel>>=
+  (|userlevel|
+   "operation access level of system user"
+   |interpreter|
+   LITERALS
+   |$UserLevel|
+   (|interpreter| |compiler| |development|)
+   |development|)
+
+<<initvars>>=
+(defvar |$setOptions| '(
+<<breakmode>>
+<<compiler>>
+<<expose>>
+<<functions>>
+<<fortran>>
+<<kernel>>
+<<hyperdoc>>
+<<help>>
+<<history>>
+<<messages>>
+<<naglink>>
+<<output>>
+<<quit>>
+<<streams>>
+<<system>>
+<<userlevel>>
+ ))
+
+@
+<<initvars>>=
+(defvar |$setOptionNames| (mapcar #'car |$setOptions|))
+
+@
+
+\section{Set code}
+
+\subsection{defun set}
+<<defun set>>=
+(defun |set| (l)
+ (|set1| l |$setOptions|)) 
+
+@
+\subsection{defun set1}
+This function will be called with the top level arguments to )set.
+For instance, given the command
+\begin{verbatim}
+   )set break break
+\end{verbatim}
+this function gets 
+\begin{verbatim}
+   (set1 (|break| |break|) ....)
+\end{verbatim}
+and given the command
+\begin{verbatim}
+   )set mes auto off
+\end{verbatim}
+this function gets 
+\begin{verbatim}
+   (set1 (|mes| |auto| |off|) ....)
+\end{verbatim}
+which, because ``message'' is a TREE, generates the recursive call:
+\begin{verbatim}
+   (set1 (|auto| |off|) <the message subtree>)
+\end{verbatim}
+The ``autoload'' subtree is a FUNCTION (printLoadMessages), 
+which gets called with \verb|%describe%|
+<<defun set1>>=
+(defun |set1| (l settree)
+ (let (|$setOptionNames| arg setdata st setfunarg num upperlimit arg2)
+  (declare (special |$setOptionNames|))
+  (cond
+   ((null l) (|displaySetVariableSettings| settree '||))
+   (t
+    (setq |$setOptionNames|
+      (do ((t1 settree (cdr t1)) t0 (|x| nil))
+          ((or (atom t1) (progn (setq |x| (car t1)) nil)) (nreverse0 t0))
+       (seq
+        (exit 
+         (setq t0 (cons (elt |x| 0) t0))))))
+    (setq arg 
+     (|selectOption| (downcase (car l)) |$setOptionNames| '|optionError|))
+    (setq setdata (cons arg (lassoc arg settree)))
+    (cond
+     ((null (|satisfiesUserLevel| (elt setdata 2)))
+      (|sayKeyedMsg| 's2iz0007 (list |$UserLevel| "set option" nil)))
+     ((eql 1 (|#| l)) (|displaySetOptionInformation| arg setdata))
+     (t
+      (setq st (elt setdata 3))
+      (cond
+       ((eq st 'function)
+        (setq setfunarg
+         (if (eq (elt l 1) 'default) 
+          '|%initialize%|
+          (kdr l)))
+        (if (|functionp| (elt setdata 4))
+          (funcall (elt setdata 4) setfunarg)
+          (|sayMSG| "   Function not implemented."))
+        (when |$displaySetValue|
+         (|displaySetOptionInformation| arg setdata))
+        NIL)
+       ((eq st 'string)
+        (setq arg2 (elt l 1))
+        (cond
+         ((eq arg2 'default) (set (elt setdata 4) (elt setdata 6)))
+         (arg2 (set (elt setdata 4) arg2))
+         (t nil))
+        (when (or |$displaySetValue| (null arg2))
+         (|displaySetOptionInformation| arg setdata))
+        NIL)
+       ((eq st 'integer)
+        (setq arg2
+         (progn
+          (setq num (elt l 1))
+          (cond
+           ((and (fixp num)
+                 (>= num (elt (elt setdata 5) 0))
+                 (or (null (setq upperlimit (elt (elt setdata 5) 1)))
+                     (<= num upperlimit)))
+            num)
+           (t
+            (|selectOption| 
+             (elt l 1)
+             (cons '|default| (elt setdata 5)) nil)))))
+        (cond
+         ((eq arg2 'default) (set (elt setdata 4) (elt setdata 6)))
+         (arg2 (set (elt setdata 4) arg2))
+         (t nil))
+        (cond
+         ((or |$displaySetValue| (null arg2))
+          (|displaySetOptionInformation| arg setdata)))
+        (cond
+         ((null arg2)
+          (|sayMessage| 
+           `(" Your value" ,@(|bright| (|object2String| (elt l 1)))
+             "is not among the valid choices.")))
+         (t nil)))
+       ((eq st 'literals)
+        (cond
+         ((setq arg2
+          (|selectOption| (elt l 1) 
+           (cons '|default| (elt setdata 5)) nil))
+          (cond
+           ((eq arg2 'default)
+            (set (elt setdata 4) 
+              (|translateYesNo2TrueFalse| (elt setdata 6))))
+           (t
+            (cond ((eq arg2 '|nobreak|) (use-fast-links t)))
+            (cond 
+             ((eq arg2 '|fastlinks|)
+              (use-fast-links nil)
+              (setq arg2 '|break|)))
+            (set (elt setdata 4) (|translateYesNo2TrueFalse| arg2))))))
+        (when (or |$displaySetValue| (null arg2))
+          (|displaySetOptionInformation| arg setdata))
+        (cond
+         ((null arg2)
+          (|sayMessage|
+           (cons " Your value"
+            (append (|bright| (|object2String| (elt l 1)))
+             (cons "is not among the valid choices." nil)))))
+         (t nil)))
+       ((eq st 'tree) (|set1| (kdr l) (elt setdata 5)) nil)
+       (t 
+        (|sayMessage|
+         `("Cannot handle set tree node type" ,@(|bright| st) |yet|))
+        nil))))))))
+
+@
+
+\subsection{defun displaySetOptionInformation}
+<<defun displaySetOptionInformation>>=
+(defun |displaySetOptionInformation| (arg setdata)
+ (let (st current)
+  (setq st (elt setdata 3))
+  (cond
+   ((eq st 'tree)
+    (|displaySetVariableSettings| (elt setdata 5) (elt setdata 0)))
+   (t 
+    (|centerAndHighlight|
+     (strconc "The " (|object2String| arg) " Option")
+      $linelength (|specialChar| '|hbar|))
+    (|sayBrightly|
+     `(|%l| ,@(|bright| "Description:") ,(elt setdata 1)))
+    (cond
+     ((eq st 'function)
+      (terpri)
+      (cond 
+       ((|functionp| (elt setdata 4))
+         (funcall (elt setdata 4) '|%describe%|))
+       (t (|sayMSG| "   Function not implemented."))))
+     ((eq st 'integer)
+      (|sayMessage| 
+        `(" The" ,@(|bright| arg) "option" 
+          " may be followed by an integer in the range" 
+          ,@(|bright| (ELT (ELT setdata 5) 0)) "to" 
+          |%l| ,@(|bright| (ELT (ELT setdata 5) 1)) "inclusive." 
+          " The current setting is" ,@(|bright| (|eval| (elt setdata 4))))))
+     ((eq st 'string)
+      (|sayMessage| 
+        `(" The" ,@(|bright| arg) "option" 
+          " is followed by a string enclosed in double quote marks." 
+          '|%l| " The current setting is" 
+          ,@(|bright| (list '|"| (|eval| (elt setdata 4)) '|"|)))))
+     ((eq st 'literals)
+       (|sayMessage|
+        `(" The" ,@(|bright| arg) "option"
+              " may be followed by any one of the following:"))
+       (setq current 
+        (|translateTrueFalse2YesNo| (|eval| (elt setdata 4))))
+       (do ((t0 (elt setdata 5) (cdr t0)) (|name| nil))
+           ((or (atom t0) (progn (setq |name| (car t0)) nil)) nil)
+        (seq
+         (exit
+          (cond
+           ((boot-equal |name| current)
+            (|sayBrightly| 
+             `( " ->" ,@(|bright| (|object2String| |name|)))))
+           (t
+            (|sayBrightly| (list "    " (|object2String| |name|))))))))
+       (|sayMessage| " The current setting is indicated.")))))))
+
+@
+
+\subsection{defun translateYesNo2TrueFalse}
+<<defun translateYesNo2TrueFalse>>=
+(defun |translateYesNo2TrueFalse| (x)
+ (cond
+  ((|member| x '(|yes| |on|)) t)
+  ((|member| x '(|no| |off|)) nil)
+  (t x))) 
+
+@
+
+\subsection{defun translateTrueFalse2YesNo}
+<<defun translateTrueFalse2YesNo>>=
+(defun |translateTrueFalse2YesNo| (x)
+ (cond
+  ((eq x t) '|on|)
+  ((null x) '|off|)
+  (t x))) 
+
+@
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \cmdhead{show}
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -8208,19 +10824,19 @@ This reports the traced functions
   (return
    (seq
     (progn 
-     (spadlet |$traceNoisely| nil)
+     (setq |$traceNoisely| nil)
      (cond
       ((|hasOption| |$options| '|nonquietly|)
-        (spadlet |$traceNoisely| t)))
+        (setq |$traceNoisely| t)))
      (cond
       ((|hasOption| |$options| '|off|)
        (cond
-        ((or (spadlet |ops| (|hasOption| |$options| '|ops|))
-             (spadlet |lops| (|hasOption| |$options| '|local|)))
+        ((or (setq |ops| (|hasOption| |$options| '|ops|))
+             (setq |lops| (|hasOption| |$options| '|local|)))
           (cond
            ((null arg) (|throwKeyedMsg| 's2it0019 nil))
            (t
-             (spadlet constructor
+             (setq constructor
               (|unabbrev|
                (cond
                 ((atom arg) arg)
@@ -8233,10 +10849,10 @@ This reports the traced functions
               ((null (|isFunctor| constructor))
                 (|throwKeyedMsg| 's2it0020 nil))
               (t
-                (cond (|ops| (spadlet |ops| (|getTraceOption| |ops|)) nil))
+                (cond (|ops| (setq |ops| (|getTraceOption| |ops|)) nil))
                 (cond 
                  (|lops|
-                  (spadlet |lops| (cdr (|getTraceOption| |lops|)))
+                  (setq |lops| (cdr (|getTraceOption| |lops|)))
                   (|untraceDomainLocalOps| constructor |lops|))
                  (t nil)))))))
         ((and (qslessp 1 (|#| |$options|))
@@ -8248,8 +10864,8 @@ This reports the traced functions
          ((qslessp 1 (|#| |$options|))
           (|throwKeyedMsg| 's2it0001 (cons ")trace ... )stats" nil)))
          (t
-           (spadlet temp1 (car |$options|))
-           (spadlet opt (cdr temp1))
+           (setq temp1 (car |$options|))
+           (setq opt (cdr temp1))
            (cond
             ((null opt)
               (|centerAndHighlight| "Traced function execution times" 78 '-)
@@ -8263,11 +10879,11 @@ This reports the traced functions
               (|resetTimers|)
               (|resetCounters|)
               (|throwKeyedMsg| 's2it0002 nil))))))
-      ((spadlet a (|hasOption| |$options| '|restore|))
+      ((setq a (|hasOption| |$options| '|restore|))
         (cond
-         ((null (spadlet |oldL| |$lastUntraced|)) nil)
+         ((null (setq |oldL| |$lastUntraced|)) nil)
          (t
-           (spadlet |newOptions| (|delete| a |$options|))
+           (setq |newOptions| (|delete| a |$options|))
            (cond
             ((null arg) (|trace1| |oldL|))
             (t
@@ -8278,22 +10894,22 @@ This reports the traced functions
                 (cond
                  ((and (pairp x)
                        (progn
-                        (spadlet |domain| (qcar x))
-                        (spadlet |opList| (qcdr x))
+                        (setq |domain| (qcar x))
+                        (setq |opList| (qcdr x))
                         t)
                        (vecp |domain|))
                    (|sayKeyedMsg| 's2it0003 (cons (|devaluate| |domain|) nil)))
                  (t
-                   (spadlet |$options|
+                   (setq |$options|
                     (append |newOptions| (lassoc x |$optionAlist|)))
                    (|trace1| (list x))))))))))))
       ((null arg) nil)
       ((and (pairp arg) (eq (qcdr arg) nil) (eq (qcar arg) '?)) (|?t|))
       (t
-       (spadlet |traceList|
+       (setq |traceList|
         (or
          (prog (t1)
-          (spadlet t1 nil)
+          (setq t1 nil)
           (return
            (do ((t2 arg (cdr t2)) (x nil))
                ((or (atom t2) 
@@ -8307,22 +10923,22 @@ This reports the traced functions
            ((or (atom t3) (progn (setq x (car t3)) nil)) nil)
          (seq
           (exit 
-           (spadlet |$optionAlist| (addassoc x |$options| |$optionAlist|)))))
-       (spadlet |optionList| (|getTraceOptions| |$options|))
-       (spadlet |argument|
+           (setq |$optionAlist| (addassoc x |$options| |$optionAlist|)))))
+       (setq |optionList| (|getTraceOptions| |$options|))
+       (setq |argument|
         (cond
-         ((spadlet |domainList| (lassoc '|of| |optionList|))
+         ((setq |domainList| (lassoc '|of| |optionList|))
            (cond
             ((lassoc '|ops| |optionList|)
               (|throwKeyedMsg| 's2it0004 nil))
             (t
-              (spadlet |opList|
+              (setq |opList|
                (cond
                 (|traceList| (list (cons '|ops| |traceList|)))
                 (t nil)))
-              (spadlet |varList|
+              (setq |varList|
                (cond
-                ((spadlet |y| (lassoc '|vars| |optionList|))
+                ((setq |y| (lassoc '|vars| |optionList|))
                   (list (cons '|vars| |y|)))
                 (t nil)))
               (append |domainList| (append |opList| |varList|)))))
@@ -8330,7 +10946,7 @@ This reports the traced functions
          (t |traceList|)))
        (|/TRACE,0|
         (prog (t4)
-         (spadlet t4 nil)
+         (setq t4 nil)
          (return
           (do ((t5 |argument| (cdr t5)) (|funName| nil))
               ((or (atom t5) 
@@ -8341,7 +10957,7 @@ This reports the traced functions
              (setq t4 (cons |funName| t4))))))))
        (|saveMapSig|
         (prog (t6)
-         (spadlet t6 nil)
+         (setq t6 nil)
          (return
           (do ((t7 |argument| (cdr t7)) (|funName| nil))
               ((or (atom t7)
@@ -8374,10 +10990,10 @@ This reports the traced functions
   (return
    (seq
     (progn
-     (spadlet |$traceErrorStack| nil)
-     (spadlet |optionList|
+     (setq |$traceErrorStack| nil)
+     (setq |optionList|
       (prog (t0) 
-       (spadlet t0 nil)
+       (setq t0 nil)
        (return
         (do ((t1 |options| (cdr t1)) (x nil))
             ((or (atom t1) (progn (setq x (car t1)) nil)) (nreverse0 t0))
@@ -8388,9 +11004,9 @@ This reports the traced functions
       (|$traceErrorStack|
        (cond
         ((null (cdr |$traceErrorStack|))
-          (spadlet temp1 (car |$traceErrorStack|))
-          (spadlet key (car temp1))
-          (spadlet |parms| (cadr temp1))
+          (setq temp1 (car |$traceErrorStack|))
+          (setq key (car temp1))
+          (setq |parms| (cadr temp1))
           (|throwKeyedMsg| key (cons "" |parms|)))
         (t
           (|throwListOfKeyedMsgs| 's2it0017
@@ -8419,9 +11035,9 @@ This reports the traced functions
      (seq
       (exit
        (cond
-        ((spadlet |map| (|rassoc| |name| |$mapSubNameAlist|))
+        ((setq |map| (|rassoc| |name| |$mapSubNameAlist|))
          (exit
-          (spadlet |$tracedMapSignatures|
+          (setq |$tracedMapSignatures|
            (addassoc |name| (|getMapSig| |map| |name|)
                      |$tracedMapSignatures|)))))))))))) 
 
@@ -8442,7 +11058,7 @@ This reports the traced functions
   (return
    (seq
     (cond
-     ((spadlet |lmms| (|get| |mapName| '|localModemap| |$InteractiveFrame|))
+     ((setq |lmms| (|get| |mapName| '|localModemap| |$InteractiveFrame|))
       (exit
        (seq
         (do ((t0 |lmms| (cdr t0)) (|mm| nil) (t1 nil |sig|))
@@ -8452,7 +11068,7 @@ This reports the traced functions
            (cond 
             ((boot-equal (cadr |mm|) |subName|)
               (exit 
-               (spadlet |sig| (cdar |mm|))))))))
+               (setq |sig| (cdar |mm|))))))))
         (exit |sig|))))))))) 
 
 @
@@ -8521,7 +11137,7 @@ This reports the traced functions
        (exit 
         (|stackTraceOptionError|
          (cons 's2it0013 (cons (cons x nil) nil)))))))
-    (if (spadlet |g| (|domainToGenvar| x)) (exit |g|))
+    (if (setq |g| (|domainToGenvar| x)) (exit |g|))
     (exit
      (|stackTraceOptionError| (cons 's2it0013 (cons (cons x nil) nil)))))))) 
 
@@ -8533,20 +11149,20 @@ This reports the traced functions
   (return
    (seq
     (progn
-     (spadlet key (car arg))
-     (spadlet |l| (cdr arg))
-     (spadlet key
+     (setq key (car arg))
+     (setq |l| (cdr arg))
+     (setq key
        (|selectOptionLC| key |$traceOptionList| '|traceOptionError|))
-     (spadlet arg (cons key |l|))
+     (setq arg (cons key |l|))
      (cond
       ((memq key '(|nonquietly| |timer| |nt|)) arg)
-      ((boot-equal key '|break|)
+      ((eq key '|break|)
        (cond
         ((null |l|) (cons '|break| (cons '|before| nil)))
         (t
-          (spadlet |opts|
+          (setq |opts|
            (prog (t0)
-            (spadlet t0 nil)
+            (setq t0 nil)
             (return
              (do ((t1 |l| (cdr t1)) (|y| nil))
                  ((or (atom t1)
@@ -8559,7 +11175,7 @@ This reports the traced functions
                   (|selectOptionLC| |y| '(|before| |after|) nil) t0))))))))
           (cond
            ((prog (t2)
-             (spadlet t2 t)
+             (setq t2 t)
              (return 
               (do ((t3 nil (null t2)) (t4 |opts| (cdr t4)) (|y| nil))
                   ((or t3 (atom t4) (progn (setq |y| (car t4)) nil)) t2)
@@ -8569,33 +11185,33 @@ This reports the traced functions
               (cons '|break| |opts|))
            (t
             (|stackTraceOptionError| (cons 's2it0008 (cons nil nil))))))))
-      ((boot-equal key '|restore|)
+      ((eq key '|restore|)
        (cond
         ((null |l|) arg)
         (t 
          (|stackTraceOptionError| 
           (cons 's2it0009 
            (cons (cons (strconc ")" (|object2String| key)) nil) nil))))))
-      ((boot-equal key '|only|) (cons '|only| (|transOnlyOption| |l|)))
-      ((boot-equal key '|within|)
+      ((eq key '|only|) (cons '|only| (|transOnlyOption| |l|)))
+      ((eq key '|within|)
         (cond
          ((and (pairp |l|) 
                (eq (qcdr |l|) nil)
-               (progn (spadlet a (qcar |l|)) t)
+               (progn (setq a (qcar |l|)) t)
                (identp a))
            arg)
          (t 
            (|stackTraceOptionError| 
             (cons 's2it0010 (cons (cons ")within" nil) nil))))))
       ((memq key '(|cond| |before| |after|))
-        (spadlet key 
+        (setq key 
          (cond 
-          ((boot-equal key '|cond|) '|when|)
+          ((eq key '|cond|) '|when|)
           (t key)))
         (cond
          ((and (pairp |l|) 
                (eq (qcdr |l|) nil)
-               (progn (spadlet a (qcar |l|)) t))
+               (progn (setq a (qcar |l|)) t))
             (cons key |l|))
          (t 
           (|stackTraceOptionError|
@@ -8603,31 +11219,31 @@ This reports the traced functions
             (cons
              (cons (strconc ")"
               (|object2String| key)) nil) nil))))))
-      ((boot-equal key '|depth|)
+      ((eq key '|depth|)
         (cond 
          ((and (pairp |l|) 
                (eq (qcdr |l|) nil)
-               (progn (spadlet |n| (qcar |l|)) t)
+               (progn (setq |n| (qcar |l|)) t)
                (fixp |n|))
            arg)
          (t 
           (|stackTraceOptionError| 
            (cons 's2it0012 (cons (cons ")depth" nil) nil))))))
-      ((boot-equal key '|count|)
+      ((eq key '|count|)
         (cond 
          ((or (null |l|) 
               (and (pairp |l|) 
                    (eq (qcdr |l|) nil)
-                   (progn (spadlet |n| (qcar |l|)) t)
+                   (progn (setq |n| (qcar |l|)) t)
                    (fixp |n|)))
             arg)
          (t 
           (|stackTraceOptionError|
             (cons 's2it0012 (cons (cons ")count" nil) nil))))))
-      ((boot-equal key '|of|)
+      ((eq key '|of|)
         (cons '|of|
          (prog (t5)
-          (spadlet t5 nil)
+          (setq t5 nil)
           (return
            (do ((t6 |l| (cdr t6)) (|y| nil))
                ((or (atom t6) (progn (setq |y| (car t6)) nil)) (nreverse0 t5))
@@ -8645,7 +11261,7 @@ This reports the traced functions
             (cons 's2it0015
              (cons
               (cons (strconc ")" (|object2String| key)) nil) nil))))))
-      ((boot-equal key '|varbreak|)
+      ((eq key '|varbreak|)
         (cond
          ((or (null |l|) 
               (and (pairp |l|) (eq (qcdr |l|) nil) (eq (qcar |l|) '|all|)))
@@ -8656,7 +11272,7 @@ This reports the traced functions
             (cons 's2it0016
              (cons
               (cons (strconc ")" (|object2String| key)) nil) nil))))))
-      ((boot-equal key '|mathprint|)
+      ((eq key '|mathprint|)
         (cond
          ((null |l|) arg)
          (t
@@ -8850,11 +11466,11 @@ This reports the traced functions
   (return
    (cond
     ((and (pairp arg) 
-          (progn (spadlet |n| (qcar arg)) (spadlet |y| (qcdr arg)) t))
+          (progn (setq |n| (qcar arg)) (setq |y| (qcdr arg)) t))
       (cond
        ((fixp |n|)
          (cons |n| (|transOnlyOption| |y|)))
-       ((memq (spadlet |n| (upcase |n|)) '(V A C))
+       ((memq (setq |n| (upcase |n|)) '(V A C))
          (cons |n| (|transOnlyOption| |y|)))
        (t 
          (|stackTraceOptionError|
@@ -8884,12 +11500,12 @@ This reports the traced functions
   (return
    (seq
     (prog (t0)
-     (spadlet t0 nil)
+     (setq t0 nil)
      (return
       (do ((t1 |options| (cdr t1)) (|optEntry| nil))
           ((or (atom t1)
                (progn (setq |optEntry| (car t1)) nil)
-               (progn (progn (spadlet opt (CAR |optEntry|)) |optEntry|) nil))
+               (progn (progn (setq opt (CAR |optEntry|)) |optEntry|) nil))
         (nreverse0 t0))
        (seq
         (exit
@@ -8914,12 +11530,12 @@ This reports the traced functions
   (declare (special |$doNotAddEmptyModeIfTrue|))
   (return
    (progn
-    (spadlet |$doNotAddEmptyModeIfTrue| t)
+    (setq |$doNotAddEmptyModeIfTrue| t)
     (cond
-     ((and (spadlet |y| (|unabbrevAndLoad| arg))
-           (boot-equal (getdatabase (|opOf| |y|) 'constructorkind) '|domain|))
+     ((and (setq |y| (|unabbrevAndLoad| arg))
+           (eq (getdatabase (|opOf| |y|) 'constructorkind) '|domain|))
        (progn
-        (spadlet |g| (|genDomainTraceName| |y|))
+        (setq |g| (|genDomainTraceName| |y|))
         (set |g| (|evalDomain| |y|)) |g|))))))) 
 
 @
@@ -8938,10 +11554,10 @@ This reports the traced functions
  (prog (u g)
   (return
    (cond
-    ((spadlet u (lassoc y |$domainTraceNameAssoc|)) u)
+    ((setq u (lassoc y |$domainTraceNameAssoc|)) u)
     (t
-     (spadlet g (genvar))
-     (spadlet |$domainTraceNameAssoc|
+     (setq g (genvar))
+     (setq |$domainTraceNameAssoc|
       (cons (cons y g) |$domainTraceNameAssoc|))
      g))))) 
 
@@ -8966,10 +11582,10 @@ This reports the traced functions
   (return
    (seq
     (progn
-     (spadlet |$lastUntraced| (cond ((null arg) (copy /tracenames)) (t arg)))
-     (spadlet |untraceList|
+     (setq |$lastUntraced| (cond ((null arg) (copy /tracenames)) (t arg)))
+     (setq |untraceList|
       (prog (t0)
-       (spadlet t0 nil)
+       (setq t0 nil)
        (return
         (do ((t1 arg (cdr t1)) (x nil))
             ((or (atom t1) (progn (setq x (car t1)) nil)) (nreverse0 t0))
@@ -8978,7 +11594,7 @@ This reports the traced functions
            (setq t0 (cons (|transTraceItem| x) t0))))))))
      (|/UNTRACE,0|
       (prog (t2)
-       (spadlet t2 nil)
+       (setq t2 nil)
        (return
         (do ((t3 |untraceList|l (cdr t3)) (|funName| nil))
             ((or (atom t3) 
@@ -9019,27 +11635,27 @@ This reports the traced functions
   (declare (special |$doNotAddEmptyModeIfTrue|))
   (return
    (progn
-    (spadlet |$doNotAddEmptyModeIfTrue| t)
+    (setq |$doNotAddEmptyModeIfTrue| t)
     (cond
      ((atom x)
        (cond
-        ((and (spadlet |value| (|get| x '|value| |$InteractiveFrame|))
+        ((and (setq |value| (|get| x '|value| |$InteractiveFrame|))
               (|member| (|objMode| |value|)
                 '((|Mode|) (|Domain|) (|SubDomain| (|Domain|)))))
-          (spadlet x (|objVal| |value|))
+          (setq x (|objVal| |value|))
           (cond 
-           ((spadlet |y| (|domainToGenvar| x)) |y|)
+           ((setq |y| (|domainToGenvar| x)) |y|)
            (t x)))
         ((upper-case-p (elt (stringimage x) 0))
-          (spadlet |y| (|unabbrev| x))
+          (setq |y| (|unabbrev| x))
           (cond
            ((|constructor?| |y|) |y|)
            ((and (pairp |y|) (|constructor?| (car |y|))) (car |y|))
-           ((spadlet |y| (|domainToGenvar| x)) |y|)
+           ((setq |y| (|domainToGenvar| x)) |y|)
            (t x)))
         (t x)))
      ((vecp (car x)) (|transTraceItem| (|devaluate| (car x))))
-     ((spadlet |y| (|domainToGenvar| x)) |y|)
+     ((setq |y| (|domainToGenvar| x)) |y|)
      (t (|throwKeyedMsg| 's2it0018 (cons x nil)))))))) 
 
 @
@@ -9081,26 +11697,26 @@ This reports the traced functions
   (return
    (seq
     (cond
-     ((memq (spadlet |name| |subName|) |$mathTraceList|)
+     ((memq (setq |name| |subName|) |$mathTraceList|)
        (cond
         ((spadsysnamep (pname |name|))
           (|coerceSpadArgs2E| (reverse (cdr (reverse args)))))
         (t
          (prog (t0)
-          (spadlet t0 nil)
+          (setq t0 nil)
           (return
            (do ((t1 '(|arg1| |arg2| |arg3| |arg4| |arg5| |arg6| |arg7| |arg8| 
                       |arg9| |arg10| |arg11| |arg12| |arg13| |arg14| |arg15| 
                       |arg16| |arg17| |arg18| |arg19|) (cdr t1))
                 (|name| nil)
                 (t2 args (cdr t2))
-                (|arg| nil)
+                (arg nil)
                 (t3 (cdr (lassoc |subName| |$tracedMapSignatures|)) (cdr t3))
                 (type nil))
                ((or (atom t1)
                     (progn (setq |name| (car t1)) nil)
                     (atom t2)
-                    (progn (setq |arg| (car t2)) nil)
+                    (progn (setq arg (car t2)) nil)
                     (atom t3)
                     (progn (setq type (car t3)) nil)) 
                   (nreverse0 t0))
@@ -9112,7 +11728,7 @@ This reports the traced functions
                   (cons |name| 
                    (cons (|objValUnwrap|
                      (|coerceInteractive|
-                      (|objNewWrap| |arg| type) |$OutputForm|))
+                      (|objNewWrap| arg type) |$OutputForm|))
                         nil)))
                      t0))))))))))
      ((spadsysnamep (pname |name|)) (reverse (cdr (reverse args))))
@@ -9137,22 +11753,22 @@ This reports the traced functions
   (return
    (seq
     (progn 
-     (spadlet |$streamCount| 0)
+     (setq |$streamCount| 0)
      (prog (t0)
-      (spadlet t0 nil)
+      (setq t0 nil)
       (return
        (do ((t1 '(|arg1| |arg2| |arg3| |arg4| |arg5| |arg6| |arg7| |arg8| 
                   |arg9| |arg10| |arg11| |arg12| |arg13| |arg14| |arg15| 
                   |arg16| |arg17| |arg18| |arg19|) (cdr t1))
-            (|name| nil)
+            (name nil)
             (t2 args (cdr t2))
-            (|arg| nil)
+            (arg nil)
             (t3 (cdr |$tracedSpadModemap|) (cdr t3))
             (type nil))
            ((or (atom t1)
-                (progn (setq |name| (car t1)) nil)
+                (progn (setq name (car t1)) nil)
                 (atom t2)
-                (progn (setq |arg| (car t2)) nil)
+                (progn (setq arg (car t2)) nil)
                 (atom t3)
                 (progn (setq type (car t3)) nil))
              (nreverse0 t0))
@@ -9161,10 +11777,10 @@ This reports the traced functions
            (setq t0
             (cons
              (cons '=
-              (cons |name|
+              (cons name
                (cons (|objValUnwrap|
                  (|coerceInteractive| 
-                  (|objNewWrap| |arg| type)
+                  (|objNewWrap| arg type)
                   |$OutputForm|)) nil)))
               t0)))))))))))) 
 
@@ -9186,10 +11802,10 @@ This reports the traced functions
    (seq
     (cond
      ((atom |mm|) 
-       (cond ((spadlet s (lassoc |mm| |sublist|)) s) (t |mm|)))
+       (cond ((setq s (lassoc |mm| |sublist|)) s) (t |mm|)))
      (t
       (prog (t0)
-       (spadlet t0 nil)
+       (setq t0 nil)
        (return
         (do ((t1 |mm| (cdr t1)) (|m| nil))
             ((or (atom t1) (progn (setq |m| (car t1)) nil)) (nreverse0 t0))
@@ -9212,13 +11828,13 @@ This reports the traced functions
 
 <<defun coerceTraceFunValue2E>>=
 (defun |coerceTraceFunValue2E| (|traceName| |subName| |value|)
- (prog (|name| |u|)
+ (prog (name |u|)
   (return
    (cond
-    ((memq (spadlet |name| |subName|) |$mathTraceList|)
+    ((memq (setq name |subName|) |$mathTraceList|)
       (cond
        ((spadsysnamep (pname |traceName|)) (|coerceSpadFunValue2E| |value|))
-       ((spadlet |u| (lassoc |subName| |$tracedMapSignatures|))
+       ((setq |u| (lassoc |subName| |$tracedMapSignatures|))
          (|objValUnwrap|
           (|coerceInteractive|
            (|objNewWrap| |value| (CAR |u|))
@@ -9243,7 +11859,7 @@ This reports the traced functions
   (declare (special |$streamCount|))
   (return
    (progn
-    (spadlet |$streamCount| 0)
+    (setq |$streamCount| 0)
     (|objValUnwrap|
      (|coerceInteractive|
       (|objNewWrap| |value| (CAR |$tracedSpadModemap|))
@@ -9262,7 +11878,7 @@ This reports the traced functions
   (return
    (seq
     (prog (t0)
-     (spadlet t0 t)
+     (setq t0 t)
      (return
       (do ((t1 nil (null t0)) (t2 arg (cdr t2)) (x nil))
           ((or t1 (atom t2) (progn (setq x (car t2)) nil)) t0)
@@ -9283,7 +11899,7 @@ This reports the traced functions
   (return
    (seq
     (prog (t0)
-     (spadlet t0 t)
+     (setq t0 t)
      (return
       (do ((t1 nil (null t0)) (t2 arg (cdr t2)) (x nil))
           ((or t1 (atom t2) (progn (setq x (car t2)) nil)) t0)
@@ -9310,20 +11926,20 @@ This reports the traced functions
   (return
    (seq
     (progn
-     (spadlet |subs| nil)
+     (setq |subs| nil)
      (seq
       (do ((t0 arg (cdr t0)) (|mapName| nil))
           ((or (atom t0) (progn (setq |mapName| (CAR t0)) nil)) nil)
        (seq
         (exit
          (cond
-          ((spadlet |lmm|
+          ((setq |lmm|
             (|get| |mapName| '|localModemap| |$InteractiveFrame|))
            (exit
-            (spadlet |subs|
+            (setq |subs|
              (append
               (prog (t1)
-               (spadlet t1 nil)
+               (setq t1 nil)
                (return
                 (do ((t2 |lmm| (cdr t2)) (|mm| nil))
                     ((or (atom t2)
@@ -9355,7 +11971,7 @@ This reports the traced functions
   (return
    (seq
     (progn
-     (spadlet |subs| nil)
+     (setq |subs| nil)
      (seq
       (do ((t0 (assocleft (caar |$InteractiveFrame|)) (cdr t0))
            (|mapName| nil))
@@ -9363,7 +11979,7 @@ This reports the traced functions
        (seq
         (exit
          (cond
-          ((spadlet |lmm|
+          ((setq |lmm|
              (|get| |mapName| '|localModemap| |$InteractiveFrame|))
             (exit
              (cond
@@ -9373,7 +11989,7 @@ This reports the traced functions
                     ((or (atom t1) (progn (setq |mm| (car t1)) nil)) nil)
                  (seq
                   (exit
-                   (spadlet |subs|
+                   (setq |subs|
                     (cons (cons |mapName| (cadr |mm|)) |subs|))))))))))))))
       (exit |subs|))))))) 
 
@@ -9391,7 +12007,7 @@ This reports the traced functions
  (prog (|y|) 
   (return 
    (cond 
-    ((spadlet |y| (lassq x |subs|)) |y|)
+    ((setq |y| (lassq x |subs|)) |y|)
     (t x))))) 
 
 @
@@ -9408,7 +12024,7 @@ This reports the traced functions
  (prog (|y|)
   (return
    (cond
-    ((spadlet |y| (|rassoc| x |subs|)) |y|)
+    ((setq |y| (|rassoc| x |subs|)) |y|)
     (t x))))) 
 
 @
@@ -9426,10 +12042,10 @@ This reports the traced functions
   (return
    (seq 
     (cond
-     ((spadlet y (|get| x '|value| |$InteractiveFrame|))
+     ((setq y (|get| x '|value| |$InteractiveFrame|))
        (exit
         (and
-         (boot-equal (caar y) 'map)
+         (eq (caar y) 'map)
          (null (|get| x '|localModemap| |$InteractiveFrame|)))))))))) 
 
 @
@@ -9447,9 +12063,9 @@ This reports the traced functions
   (return
    (seq
     (cond
-     ((spadlet x (|get| map '|localModemap| |$InteractiveFrame|))
+     ((setq x (|get| map '|localModemap| |$InteractiveFrame|))
       (exit
-       (boot-equal (caaar x) '|interpOnly|)))))))) 
+       (eq (caaar x) '|interpOnly|)))))))) 
 
 @
 
@@ -9470,18 +12086,18 @@ This reports the traced functions
   (return
    (seq
     (progn
-     (spadlet |res| nil)
+     (setq |res| nil)
      (do ((t0 arg (cdr t0)) (|traceName| nil))
          ((or (atom t0) (progn (setq |traceName| (car t0)) nil)) nil)
       (seq
        (exit
         (cond
-         ((spadlet |mml|
+         ((setq |mml|
             (|get| |traceName| '|localModemap| |$InteractiveFrame|))
-           (spadlet |res|
+           (setq |res|
             (append
              (prog (t1)
-              (spadlet t1 nil)
+              (setq t1 nil)
               (return
                (do ((t2 |mml| (cdr t2)) (|mm| nil))
                    ((or (atom t2) 
@@ -9491,7 +12107,7 @@ This reports the traced functions
                  (exit 
                   (setq t1 (cons (cadr |mm|) t1)))))))
             |res|)))
-         (t (spadlet |res| (cons |traceName| |res|)))))))
+         (t (setq |res| (cons |traceName| |res|)))))))
      |res|))))) 
 @
 
@@ -9509,10 +12125,10 @@ This reports the traced functions
   (return
    (seq
     (cond
-     ((spadlet |mapName| (|rassocSub| |subName| |$mapSubNameAlist|))
+     ((setq |mapName| (|rassocSub| |subName| |$mapSubNameAlist|))
        (exit
         (cond
-         ((spadlet |tail|
+         ((setq |tail|
             (|member| (cons |mapName| |subName|) |$mapSubNameAlist|))
            (exit
             (memq |mapName| (cdr (assocleft |tail|))))))))))))) 
@@ -9537,19 +12153,19 @@ This reports the traced functions
    (seq
     (cond
      ((null
-        (spadlet |$mapSubNameAlist| (|getPreviousMapSubNames| |traceNames|)))
+        (setq |$mapSubNameAlist| (|getPreviousMapSubNames| |traceNames|)))
        nil)
      (t
-      (do ((t0 (spadlet |subs| (assocright |$mapSubNameAlist|)) (CDR t0))
-           (|name| nil))
-          ((or (atom t0) (progn (setq |name| (car t0)) nil)) nil)
+      (do ((t0 (setq |subs| (assocright |$mapSubNameAlist|)) (CDR t0))
+           (name nil))
+          ((or (atom t0) (progn (setq name (car t0)) nil)) nil)
        (seq
         (exit
          (cond
-          ((memq |name| /tracenames)
+          ((memq name /tracenames)
            (progn
-            (|/UNTRACE,2| |name| nil)
-            (spadlet |$lastUntraced|
+            (|/UNTRACE,2| name nil)
+            (setq |$lastUntraced|
              (setdifference |$lastUntraced| |subs|)))))))))))))) 
 
 @
@@ -9567,9 +12183,9 @@ This reports the traced functions
   (return
    (seq
     (progn
-     (spadlet ops (|isFunctor| functor))
+     (setq ops (|isFunctor| functor))
      (prog (t0)
-      (spadlet t0 nil)
+      (setq t0 nil)
       (return
        (do ((t1 ops (cdr t1)) (|u| nil))
            ((or (atom t1) (progn (setq |u| (car t1)) nil)) (nreverse0 t0))
@@ -9578,7 +12194,7 @@ This reports the traced functions
           (cond
            ((and (pairp |u|)
                  (progn
-                  (spadlet tmp1 (qcar |u|))
+                  (setq tmp1 (qcar |u|))
                   (and (pairp tmp1) (equal (qcar tmp1) opname))))
              (setq t0 (cons |u| t0)))))))))))))) 
 
@@ -9692,11 +12308,11 @@ This reports the traced functions
   (return
    (seq
     (progn
-     (spadlet |n| (caddr x))
+     (setq |n| (caddr x))
      x
      (seq
       (if (atom (elt |domain| |n|)) (exit nil))
-      (spadlet |functionSlot| (car (elt |domain| |n|)))
+      (setq |functionSlot| (car (elt |domain| |n|)))
       (if (gensymp |functionSlot|) 
        (exit (seq (|reportSpadTrace| '|Already Traced| x) (exit nil))))
       (if (null (bpiname |functionSlot|))
@@ -9718,8 +12334,8 @@ This reports the traced functions
  (return
   (seq
    (progn
-    (spadlet |$fromSpadTrace| t)
-    (spadlet |$tracedModemap| nil)
+    (setq |$fromSpadTrace| t)
+    (setq |$tracedModemap| nil)
     (cond
      ((and (pairp |domain|)
            (refvecp (car |domain|))
@@ -9728,9 +12344,9 @@ This reports the traced functions
      ((null (|isDomainOrPackage| |domain|))
        (|userError| "bad argument to trace"))
      (t
-      (spadlet |listOfOperations|
+      (setq |listOfOperations|
        (prog (t0)
-        (spadlet t0 nil)
+        (setq t0 nil)
         (return
          (do ((t1 (|getOption| 'ops |options|) (cdr t1)) (x nil))
              ((or (atom t1) (progn (setq x (car t1)) nil)) (nreverse0 t0))
@@ -9738,40 +12354,40 @@ This reports the traced functions
            (exit
             (setq t0 (cons (|spadTrace,g| x) t0))))))))
       (cond
-       ((spadlet |listOfVariables| (|getOption| 'vars |options|))
-         (spadlet |options| (|removeOption| 'vars |options|))))
+       ((setq |listOfVariables| (|getOption| 'vars |options|))
+         (setq |options| (|removeOption| 'vars |options|))))
       (cond
-       ((spadlet |listOfBreakVars| (|getOption| 'varbreak |options|))
-         (spadlet |options| (|removeOption| 'varbreak |options|))))
-      (spadlet |anyifTrue| (null |listOfOperations|))
-      (spadlet |domainId| (|opOf| (elt |domain| 0)))
-      (spadlet |currentEntry| (|assoc| |domain| /tracenames))
-      (spadlet |currentAlist| (kdr |currentEntry|))
-      (spadlet |opStructureList| 
+       ((setq |listOfBreakVars| (|getOption| 'varbreak |options|))
+         (setq |options| (|removeOption| 'varbreak |options|))))
+      (setq |anyifTrue| (null |listOfOperations|))
+      (setq |domainId| (|opOf| (elt |domain| 0)))
+      (setq |currentEntry| (|assoc| |domain| /tracenames))
+      (setq |currentAlist| (kdr |currentEntry|))
+      (setq |opStructureList| 
        (|flattenOperationAlist| (|getOperationAlistFromLisplib| |domainId|)))
-      (spadlet |sigSlotNumberAlist|
+      (setq |sigSlotNumberAlist|
        (prog (t2)
-        (spadlet t2 nil)
+        (setq t2 nil)
         (return
          (do ((t3 |opStructureList| (cdr t3)) (t4 nil))
              ((or (atom t3)
                   (progn (setq t4 (CAR t3)) nil)
                   (progn
                    (progn
-                    (spadlet |op| (car t4))
-                    (spadlet |sig| (cadr t4))
-                    (spadlet |n| (caddr t4))
-                    (spadlet |kind| (car (cddddr t4))) t4)
+                    (setq |op| (car t4))
+                    (setq |sig| (cadr t4))
+                    (setq |n| (caddr t4))
+                    (setq |kind| (car (cddddr t4))) t4)
                    nil))
                 (nreverse0 t2))
           (seq
            (exit
             (cond
-             ((and (boot-equal |kind| 'ELT)
+             ((and (eq |kind| 'ELT)
                    (or |anyifTrue| (memq |op| |listOfOperations|))
                    (fixp |n|)
                    (|spadTrace,isTraceable|
-                    (spadlet |triple|
+                    (setq |triple|
                      (cons |op| (cons |sig| (cons |n| nil)))) |domain|))
                 (setq t2 (cons |triple| t2))))))))))
       (cond 
@@ -9779,26 +12395,26 @@ This reports the traced functions
         (do ((t5 |sigSlotNumberAlist| (cdr t5)) (t6 nil))
             ((or (atom t5)
                  (progn (setq t6 (car t5)) nil)
-                 (progn (progn (spadlet |n| (caddr t6)) t6) nil))
+                 (progn (progn (setq |n| (caddr t6)) t6) nil))
               nil)
          (seq
           (exit
            (progn
-            (spadlet |fn| (car (elt |domain| |n|)))
-            (spadlet |$letAssoc|
+            (setq |fn| (car (elt |domain| |n|)))
+            (setq |$letAssoc|
              (as-insert (bpiname |fn|) |listOfVariables| |$letAssoc|))))))))
       (cond
        (|listOfBreakVars|
         (do ((t7 |sigSlotNumberAlist| (cdr t7)) (t8 nil))
             ((or (atom t7)
                  (progn (setq t8 (car t7)) nil)
-                 (progn (progn (spadlet |n| (caddr t8)) t8) nil))
+                 (progn (progn (setq |n| (caddr t8)) t8) nil))
                 nil)
          (seq
           (exit
            (progn
-            (spadlet |fn| (car (elt |domain| |n|)))
-            (spadlet |$letAssoc|
+            (setq |fn| (car (elt |domain| |n|)))
+            (setq |$letAssoc|
              (as-insert (bpiname |fn|)
               (cons (cons 'break |listOfBreakVars|) nil) |$letAssoc|))))))))
       (do ((t9 |sigSlotNumberAlist| (cdr t9)) (|pair| nil))
@@ -9806,28 +12422,28 @@ This reports the traced functions
                (progn (setq |pair| (car t9)) nil)
                (progn
                 (progn
-                 (spadlet |op| (car |pair|))
-                 (spadlet |mm| (cadr |pair|))
-                 (spadlet |n| (caddr |pair|))
+                 (setq |op| (car |pair|))
+                 (setq |mm| (cadr |pair|))
+                 (setq |n| (caddr |pair|))
                  |pair|)
                  nil))
                nil)
        (seq
         (exit
          (progn 
-          (spadlet |alias| (|spadTraceAlias| |domainId| |op| |n|))
-          (spadlet |$tracedModemap|
+          (setq |alias| (|spadTraceAlias| |domainId| |op| |n|))
+          (setq |$tracedModemap|
             (|subTypes| |mm| (|constructSubst| (elt |domain| 0))))
-          (spadlet |traceName|
+          (setq |traceName|
             (bpitrace (car (elt |domain| |n|)) |alias| |options|))
           (nconc |pair|
             (cons |listOfVariables|
              (cons (car (elt |domain| |n|))
               (cons |traceName| (cons |alias| nil)))))
           (rplac (car (elt |domain| |n|)) |traceName|)))))
-      (spadlet |sigSlotNumberAlist|
+      (setq |sigSlotNumberAlist|
        (prog (t10)
-        (spadlet t10 nil)
+        (setq t10 nil)
         (return
          (do ((t11 |sigSlotNumberAlist| (cdr t11)) (x nil))
              ((or (atom t11) (progn (setq x (car t11)) nil)) (nreverse0 t10))
@@ -9966,12 +12582,12 @@ This reports the traced functions
    (seq
     (progn
      (|loadFunctor| |domainConstructor|)
-     (spadlet |listOfLocalOps| (|getOption| 'local |options|))
+     (setq |listOfLocalOps| (|getOption| 'local |options|))
      (cond
       (|listOfLocalOps|
        (|traceDomainLocalOps| |domainConstructor| |listOfLocalOps|
         (prog (t0)
-         (spadlet t0 nil)
+         (setq t0 nil)
          (return
           (do ((t1 |options| (cdr t1)) (opt nil))
               ((or (atom t1) (progn (setq opt (car t1)) nil)) (nreverse0 t0))
@@ -9989,19 +12605,19 @@ This reports the traced functions
                 (progn (setq t3 (car t2)) nil)
                 (progn 
                  (progn 
-                  (spadlet |argl| (car t3))
-                  (spadlet |domain| (cddr t3)) t3)
+                  (setq |argl| (car t3))
+                  (setq |domain| (cddr t3)) t3)
                  nil))
                 nil)
          (seq
           (exit
            (|spadTrace| |domain| |options|))))
        (setq /tracenames (cons |domainConstructor| /tracenames))
-       (spadlet |innerDomainConstructor|
+       (setq |innerDomainConstructor|
          (intern (strconc |domainConstructor| ";")))
        (cond
         ((fboundp |innerDomainConstructor|)
-          (spadlet |domainConstructor| |innerDomainConstructor|)))
+          (setq |domainConstructor| |innerDomainConstructor|)))
        (embed |domainConstructor|
         (cons 'lambda
          (cons 
@@ -10052,7 +12668,7 @@ This reports the traced functions
    (seq
     (if (and 
          (and
-          (and (pairp |df|) (progn (spadlet |dc| (qcar |df|)) t))
+          (and (pairp |df|) (progn (setq |dc| (qcar |df|)) t))
            (|isDomainOrPackage| |dc|))
          (boot-equal (kar (|devaluate| |dc|)) |domainConstructor|))
      (exit (seq (|/UNTRACE,0| (cons |dc| nil)) (exit nil))))
@@ -10068,7 +12684,7 @@ This reports the traced functions
     (progn
      (setq /tracenames
       (prog (t0)
-       (spadlet t0 nil)
+       (setq t0 nil)
        (return
         (do ((t1 /tracenames (cdr t1)) (|df| nil))
             ((or (atom t1) (progn (setq |df| (car t1)) nil)) (nreverse0 t0))
@@ -10078,7 +12694,7 @@ This reports the traced functions
                     |df| |domainConstructor|)
              (setq t0 (cons |df| t0))))))))))
      (|untraceAllDomainLocalOps| |domainConstructor|)
-     (spadlet |innerDomainConstructor|
+     (setq |innerDomainConstructor|
       (intern (strconc |domainConstructor| ";")))
      (cond
       ((fboundp |innerDomainConstructor|) (unembed |innerDomainConstructor|))
@@ -10102,20 +12718,20 @@ This reports the traced functions
   (return
    (seq
     (progn
-     (spadlet |res| nil)
+     (setq |res| nil)
      (do ((t0 |opAlist| (cdr t0)) (t1 nil))
          ((or (atom t0) 
               (progn (setq t1 (car t0)) nil)
               (progn
-               (progn (spadlet |op| (car t1)) (spadlet |mmList| (cdr t1)) t1)
+               (progn (setq |op| (car t1)) (setq |mmList| (cdr t1)) t1)
                nil)) 
              nil)
       (seq
        (exit
-        (spadlet |res|
+        (setq |res|
          (append |res|
           (prog (t2)
-           (spadlet t2 nil)
+           (setq t2 nil)
            (return
             (do ((t3 |mmList| (cdr t3)) (|mm| nil))
                 ((or (atom t3)
@@ -10137,8 +12753,8 @@ This reports the traced functions
 
 <<defun mapLetPrint>>=
 (defun |mapLetPrint| (x val currentFunction)
-  (spadlet x (|getAliasIfTracedMapParameter| x currentFunction))
-  (spadlet currentFunction (|getBpiNameIfTracedMap| currentFunction))
+  (setq x (|getAliasIfTracedMapParameter| x currentFunction))
+  (setq currentFunction (|getBpiNameIfTracedMap| currentFunction))
   (|letPrint| x val currentFunction))
 
 @
@@ -10170,10 +12786,10 @@ This reports the traced functions
    (progn
     (cond ((and |$letAssoc| 
                 (or
-                 (spadlet |y| (lassoc |currentFunction| |$letAssoc|))
-                 (spadlet |y| (lassoc '|all| |$letAssoc|))))
+                 (setq |y| (lassoc |currentFunction| |$letAssoc|))
+                 (setq |y| (lassoc '|all| |$letAssoc|))))
      (cond
-      ((and (or (boot-equal |y| '|all|)
+      ((and (or (eq |y| '|all|)
                  (memq x |y|))
             (null 
              (or (is_genvar x) (|isSharpVarWithNum| x) (gensymp x))))
@@ -10181,8 +12797,8 @@ This reports the traced functions
         (prin0 (|shortenForPrinting| |val|))
         (terpri)))
      (cond
-      ((and (spadlet |y| (|hasPair| 'break |y|))
-            (or (boot-equal |y| '|all|)
+      ((and (setq |y| (|hasPair| 'break |y|))
+            (or (eq |y| '|all|)
                 (and (memq x |y|)
                      (null (memq (elt (pname x) 0) '($ |#|)))
                      (null (gensymp x)))))
@@ -10226,26 +12842,26 @@ This reports the traced functions
   (declare (special |$BreakMode|))
   (return
    (progn
-    (spadlet |$BreakMode| nil)
+    (setq |$BreakMode| nil)
     (cond
      ((and |$letAssoc| 
-           (or (spadlet |y| (lassoc |currentFunction| |$letAssoc|))
-               (spadlet |y| (lassoc '|all| |$letAssoc|))))
+           (or (setq |y| (lassoc |currentFunction| |$letAssoc|))
+               (setq |y| (lassoc '|all| |$letAssoc|))))
       (cond
        ((and
-          (or (boot-equal |y| '|all|) (memq x |y|))
+          (or (eq |y| '|all|) (memq x |y|))
           (null (or (is_genvar x) (|isSharpVarWithNum| x) (gensymp x))))
-         (spadlet |$BreakMode| '|letPrint2|)
-         (spadlet |flag| nil)
+         (setq |$BreakMode| '|letPrint2|)
+         (setq |flag| nil)
          (catch '|letPrint2| 
           (|mathprint| (cons '= (cons x (cons |printform| nil)))) |flag|)
          (cond 
-          ((boot-equal |flag| '|letPrint2|) (|print| |printform|))
+          ((eq |flag| '|letPrint2|) (|print| |printform|))
           (t nil))))
       (cond 
        ((and 
-         (spadlet |y| (|hasPair| 'break |y|))
-         (or (boot-equal |y| '|all|)
+         (setq |y| (|hasPair| 'break |y|))
+         (or (eq |y| '|all|)
              (and 
               (memq x |y|)
               (null (memq (elt (pname x) 0) '($ |#|)))
@@ -10288,29 +12904,29 @@ This reports the traced functions
   (declare (special |$BreakMode|))
   (return
    (progn
-    (spadlet |$BreakMode| nil)
+    (setq |$BreakMode| nil)
     (cond
      ((and |$letAssoc| 
-       (or (spadlet |y| (lassoc |currentFunction| |$letAssoc|))
-           (spadlet |y| (lassoc '|all| |$letAssoc|))))
+       (or (setq |y| (lassoc |currentFunction| |$letAssoc|))
+           (setq |y| (lassoc '|all| |$letAssoc|))))
        (cond
         ((and
-           (or (boot-equal |y| '|all|) (memq x |y|))
+           (or (eq |y| '|all|) (memq x |y|))
            (null (or (is_genvar x) (|isSharpVarWithNum| x) (gensymp x))))
-          (spadlet |$BreakMode| '|letPrint2|)
-          (spadlet |flag| nil)
+          (setq |$BreakMode| '|letPrint2|)
+          (setq |flag| nil)
           (catch '|letPrint2|
            (|mathprint|
             (cons '= (cons x (cons (spadcall |xval| |printfn|) nil))))
            |flag|)
           (cond
-           ((boot-equal |flag| '|letPrint2|) (|print| |xval|))
+           ((eq |flag| '|letPrint2|) (|print| |xval|))
            (t nil))))
        (cond
         ((and
-          (spadlet |y| (|hasPair| 'break |y|))
+          (setq |y| (|hasPair| 'break |y|))
           (or
-           (boot-equal |y| '|all|)
+           (eq |y| '|all|)
            (and
             (memq x |y|)
             (null (memq (elt (pname x) 0) '($ |#|)))
@@ -10341,7 +12957,7 @@ This reports the traced functions
     (cond
      ((|isSharpVarWithNum| x)
        (cond
-        ((spadlet |aliasList|
+        ((setq |aliasList|
            (|get| |currentFunction| '|alias| |$InteractiveFrame|))
          (exit
           (elt |aliasList|
@@ -10360,16 +12976,16 @@ This reports the traced functions
 \end{verbatim}
 
 <<defun getBpiNameIfTracedMap>>=
-(defun |getBpiNameIfTracedMap| (|name|)
+(defun |getBpiNameIfTracedMap| (name)
  (prog (|lmm| |bpiName|)
   (return
    (seq
     (cond 
-     ((spadlet |lmm| (|get| |name| '|localModemap| |$InteractiveFrame|))
+     ((setq |lmm| (|get| name '|localModemap| |$InteractiveFrame|))
        (cond
-        ((memq (spadlet |bpiName| (cadar |lmm|)) /tracenames)
+        ((memq (setq |bpiName| (cadar |lmm|)) /tracenames)
            (exit |bpiName|))))
-     (t |name|)))))) 
+     (t name)))))) 
 
 @
 
@@ -10389,10 +13005,10 @@ This reports the traced functions
     ((atom arg) nil)
     ((and (pairp arg)
           (progn
-           (spadlet tmp1 (qcar arg))
+           (setq tmp1 (qcar arg))
            (and (pairp tmp1)
                 (equal (qcar tmp1) key)
-                (progn (spadlet a (qcdr tmp1)) t))))
+                (progn (setq a (qcdr tmp1)) t))))
        a)
     (t (|hasPair| key (cdr arg))))))) 
 
@@ -10436,7 +13052,7 @@ This reports the traced functions
  (prog (y)
   (return
    (seq
-    (cond ((spadlet y (|assoc| opt l)) (exit (cdr y)))))))) 
+    (cond ((setq y (|assoc| opt l)) (exit (cdr y)))))))) 
 
 @
 
@@ -10458,14 +13074,14 @@ This reports the traced functions
  (prog (|op| |sig| |n| |t| |msg| |namePart| |y| |tracePart|)
   (return 
    (progn
-    (spadlet |op| (car t0))
-    (spadlet |sig| (cadr t0))
-    (spadlet |n| (caddr t0))
-    (spadlet |t| (cdddr t0))
+    (setq |op| (car t0))
+    (setq |sig| (cadr t0))
+    (setq |n| (caddr t0))
+    (setq |t| (cdddr t0))
     (cond
      ((null |$traceNoisely|) nil)
      (t
-      (spadlet |msg|
+      (setq |msg|
        (cons |header|
         (cons '|%b|
          (cons |op|
@@ -10476,12 +13092,12 @@ This reports the traced functions
               (cons (car |sig|)
                (cons '| in slot |
                 (cons |n| nil)))))))))))
-      (spadlet |namePart| nil)
-      (spadlet |tracePart|
+      (setq |namePart| nil)
+      (setq |tracePart|
        (cond
-        ((and (pairp |t|) (progn (spadlet |y| (qcar |t|)) t) (null (null |y|)))
+        ((and (pairp |t|) (progn (setq |y| (qcar |t|)) t) (null (null |y|)))
           (cond
-           ((boot-equal |y| '|all|)
+           ((eq |y| '|all|)
              (cons '|%b| (cons '|all| (cons '|%d| (cons '|vars| nil)))))
            (t (cons '| vars: | (cons |y| nil)))))
         (t nil)))
@@ -10503,12 +13119,12 @@ This reports the traced functions
     (assocright
      (|orderList|
       (prog (t0)
-       (spadlet t0 nil)
+       (setq t0 nil)
        (return
         (do ((t1 arg (cdr t1)) (x nil))
             ((or (atom t1)
                  (progn (setq x (car t1)) nil)
-                 (progn (progn (spadlet |n| (caddr x)) x) nil))
+                 (progn (progn (setq |n| (caddr x)) x) nil))
                (nreverse0 t0))
          (seq
           (exit
@@ -10541,11 +13157,11 @@ This reports the traced functions
          (exit
           (cond
            ((and (pairp x) 
-                 (progn (spadlet |d| (qcar x)) t)
+                 (progn (setq |d| (qcar x)) t)
                  (|isDomainOrPackage| |d|))
-              (spadlet |domainList| (cons (|devaluate| |d|) |domainList|)))
+              (setq |domainList| (cons (|devaluate| |d|) |domainList|)))
            (t 
-            (spadlet |functionList| (cons x |functionList|)))))))
+            (setq |functionList| (cons x |functionList|)))))))
        (append |functionList|
         (append |domainList| (cons '|traced| nil))))))))) 
 
@@ -10565,7 +13181,7 @@ This reports the traced functions
  (prog (|d|)
   (return
    (seq
-    (if (and (and (pairp x) (progn (spadlet |d| (qcar x)) t))
+    (if (and (and (pairp x) (progn (setq |d| (qcar x)) t))
              (|isDomainOrPackage| |d|))
        (exit (|devaluate| |d|)))
      (exit x))))) 
@@ -10578,7 +13194,7 @@ This reports the traced functions
   (return
    (seq
     (prog (t0)
-     (spadlet t0 nil)
+     (setq t0 nil)
      (return
        (do ((t1 /tracenames (cdr t1)) (x nil))
            ((or (atom t1) (progn (setq x (car t1)) nil)) (nreverse0 t0))
@@ -10624,30 +13240,30 @@ This reports the traced functions
      ((null (|isDomainOrPackage| |domain|))
        (|userError| "bad argument to untrace"))
      (t
-      (spadlet |anyifTrue| (null |options|))
-      (spadlet |listOfOperations| (|getOption| '|ops:| |options|))
-      (spadlet |domainId| (|devaluate| |domain|))
+      (setq |anyifTrue| (null |options|))
+      (setq |listOfOperations| (|getOption| '|ops:| |options|))
+      (setq |domainId| (|devaluate| |domain|))
       (cond
-       ((null (spadlet |pair| (|assoc| |domain| /tracenames)))
+       ((null (setq |pair| (|assoc| |domain| /tracenames)))
          (|sayMSG| 
           (cons "   No functions in" 
            (append
             (|bright| (|prefix2String| |domainId|))
             (cons "are now traced." nil)))))
        (t 
-        (spadlet |sigSlotNumberAlist| (cdr |pair|))
+        (setq |sigSlotNumberAlist| (cdr |pair|))
         (do ((t0 |sigSlotNumberAlist| (cdr t0)) (|pair| nil))
             ((or (atom t0) 
                  (progn (setq |pair| (car t0)) nil)
                  (progn
                   (progn
-                   (spadlet |op| (car |pair|))
-                   (spadlet |sig| (cadr |pair|))
-                   (spadlet |n| (caddr |pair|))
-                   (spadlet |lv| (cadddr |pair|))
-                   (spadlet |bpiPointer| (car (cddddr |pair|)))
-                   (spadlet |traceName| (cadr (cddddr |pair|)))
-                   (spadlet |alias| (caddr (cddddr |pair|)))
+                   (setq |op| (car |pair|))
+                   (setq |sig| (cadr |pair|))
+                   (setq |n| (caddr |pair|))
+                   (setq |lv| (cadddr |pair|))
+                   (setq |bpiPointer| (car (cddddr |pair|)))
+                   (setq |traceName| (cadr (cddddr |pair|)))
+                   (setq |alias| (caddr (cddddr |pair|)))
                    |pair|)
                   nil))
                  nil)
@@ -10660,16 +13276,16 @@ This reports the traced functions
                 (rplac (car (elt |domain| |n|)) |bpiPointer|)
                 (rplac (cdddr |pair|) nil)
                 (cond
-                 ((spadlet |assocPair|
+                 ((setq |assocPair|
                      (|assoc| (bpiname |bpiPointer|) |$letAssoc|))
-                   (spadlet |$letAssoc| (remover |$letAssoc| |assocPair|))
+                   (setq |$letAssoc| (remover |$letAssoc| |assocPair|))
                    (cond 
                     ((null |$letAssoc|) (setletprintflag nil))
                     (t nil)))
                  (t nil))))))))
-        (spadlet |newSigSlotNumberAlist|
+        (setq |newSigSlotNumberAlist|
          (prog (t1) 
-          (spadlet t1 nil)
+          (setq t1 nil)
           (return
            (do ((t2 |sigSlotNumberAlist| (cdr t2)) (x nil))
                ((or (atom t2) (progn (setq x (car t2)) nil)) (nreverse0 t1))
@@ -10699,7 +13315,7 @@ This reports the traced functions
   (return
    (seq
     (if (and (and (pairp x) 
-                  (progn (spadlet |d| (qcar x)) (spadlet |t| (qcdr x)) t))
+                  (progn (setq |d| (qcar x)) (setq |t| (qcdr x)) t))
               (|isDomainOrPackage| |d|))
       (exit (cons (|devaluate| |d|) |t|)))
     (exit x))))) 
@@ -10771,9 +13387,9 @@ This reports the traced functions
   (return
    (seq
     (progn
-     (spadlet |$domains| nil)
-     (spadlet |$packages| nil)
-     (spadlet |$constructors| nil)
+     (setq |$domains| nil)
+     (setq |$packages| nil)
+     (setq |$constructors| nil)
      (cond
       ((null /tracenames) (|sayMessage| "   Nothing is traced now."))
       (t
@@ -10784,17 +13400,17 @@ This reports the traced functions
           (exit
            (cond
             ((and (pairp x) 
-                  (progn (spadlet |d| (qcar x)) t) (|isDomainOrPackage| |d|))
+                  (progn (setq |d| (qcar x)) t) (|isDomainOrPackage| |d|))
                (|addTraceItem| |d|))
             ((atom x)
                (cond
                 ((|isFunctor| x) (|addTraceItem| x))
                 ((is_genvar x) (|addTraceItem| (EVAL x)))
-                (t (spadlet |functionList| (CONS x |functionList|)))))
+                (t (setq |functionList| (CONS x |functionList|)))))
             (t (|userError| "bad argument to trace"))))))
-        (spadlet |functionList|
+        (setq |functionList|
           (prog (t1)
-           (spadlet t1 nil)
+           (setq t1 nil)
            (return
             (do ((t2 |functionList| (cdr t2)) (x nil))
                 ((or (atom t2) (progn (setq x (car t2)) nil)) t1)
@@ -10819,11 +13435,11 @@ This reports the traced functions
               (|flowSegmentedMsg| |functionList| $linelength 6))))))
        (cond 
         (|$domains|
-         (spadlet |displayList|
+         (setq |displayList|
           (|concat|
            (|prefix2String| (CAR |$domains|))
            (prog (t3)
-            (spadlet t3 nil)
+            (setq t3 nil)
             (return
              (do ((t4 (cdr |$domains|) (cdr t4)) (x nil))
                  ((or (atom t4) (progn (setq x (car t4)) nil)) t3)
@@ -10833,16 +13449,16 @@ This reports the traced functions
                  (append t3 (|concat| "," " " (|prefix2String| x)))))))))))
          (cond 
           ((atom |displayList|)
-           (spadlet |displayList| (cons |displayList| nil))))
+           (setq |displayList| (cons |displayList| nil))))
          (|sayBrightly| "   Domains traced: ")
          (|sayBrightly| (|flowSegmentedMsg| |displayList| $LINELENGTH 6))))
        (cond 
         (|$packages|
-          (spadlet |displayList|
+          (setq |displayList|
            (|concat|
             (|prefix2String| (CAR |$packages|))
             (prog (t5)
-             (spadlet t5 nil)
+             (setq t5 nil)
              (return
               (do ((t6 (cdr |$packages|) (cdr t6)) (x nil))
                   ((or (atom t6) (progn (setq x (car t6)) nil)) t5)
@@ -10851,16 +13467,16 @@ This reports the traced functions
                  (setq t5
                   (append t5 (|concat| '|, | (|prefix2String| x)))))))))))
           (cond ((atom |displayList|)
-              (spadlet |displayList| (cons |displayList| nil))))
+              (setq |displayList| (cons |displayList| nil))))
           (|sayBrightly| "   Packages traced: ")
           (|sayBrightly| (|flowSegmentedMsg| |displayList| $linelength 6))))
        (cond 
         (|$constructors|
-         (spadlet |displayList|
+         (setq |displayList|
           (|concat|
            (|abbreviate| (CAR |$constructors|))
            (prog (t7)
-            (spadlet t7 nil)
+            (setq t7 nil)
              (return 
               (do ((t8 (cdr |$constructors|) (cdr t8)) (x nil))
                   ((or (atom t8) (progn (setq x (car t8)) nil)) t7)
@@ -10869,7 +13485,7 @@ This reports the traced functions
                  (setq t7
                  (append t7 (|concat| '|, | (|abbreviate| x)))))))))))
          (cond ((atom |displayList|)
-            (spadlet |displayList| (CONS |displayList| nil))))
+            (setq |displayList| (CONS |displayList| nil))))
          (|sayBrightly| "   Parameterized constructors traced:")
          (|sayBrightly| (|flowSegmentedMsg| |displayList| $linelength 6)))
         (t nil))))))))) 
@@ -10888,11 +13504,11 @@ This reports the traced functions
 (defun |addTraceItem| (|d|)
  (cond
   ((|constructor?| |d|)
-    (spadlet |$constructors| (cons |d| |$constructors|)))
+    (setq |$constructors| (cons |d| |$constructors|)))
   ((|isDomain| |d|)
-    (spadlet |$domains| (cons (|devaluate| |d|) |$domains|)))
+    (setq |$domains| (cons (|devaluate| |d|) |$domains|)))
   ((|isDomainOrPackage| |d|)
-    (spadlet |$packages| (cons (|devaluate| |d|) |$packages|))))) 
+    (setq |$packages| (cons (|devaluate| |d|) |$packages|))))) 
 
 @
 
@@ -10929,8 +13545,8 @@ This reports the traced functions
           ((and (atom x) (null (is_genvar x)))
            (progn
             (cond
-             ((spadlet |llm| (|get| x '|localModemap| |$InteractiveFrame|))
-               (spadlet x (list (cadar |llm|)))))
+             ((setq |llm| (|get| x '|localModemap| |$InteractiveFrame|))
+               (setq x (list (cadar |llm|)))))
             (|sayMSG|
              (cons "Function"
               (append
@@ -10942,10 +13558,10 @@ This reports the traced functions
         (exit
          (cond
           ((and (pairp x) 
-                (progn (spadlet |d| (qcar x)) (spadlet |l| (qcdr x)) t)
+                (progn (setq |d| (qcar x)) (setq |l| (qcdr x)) t)
                 (|isDomainOrPackage| |d|))
            (progn
-            (spadlet |suffix| (cond ((|isDomain| |d|) "domain") (t "package")))
+            (setq |suffix| (cond ((|isDomain| |d|) "domain") (t "package")))
             (|sayBrightly|
              (cons "   Functions traced in "
               (cons |suffix|
@@ -10990,22 +13606,22 @@ This reports the traced functions
    (progn
     (cond
      ((and (gensymp |fn|) (|stupidIsSpadFunction| (eval |fn|)))
-       (spadlet |fn| (eval |fn|))
+       (setq |fn| (eval |fn|))
        (cond
-        ((compiled-function-p |fn|) (spadlet |fn| (bpiname |fn|)))
+        ((compiled-function-p |fn|) (setq |fn| (bpiname |fn|)))
         (t nil))))
     (cond
-     ((boot-equal |fn| '|Undef|) nil)
+     ((eq |fn| '|Undef|) nil)
      (t
-       (spadlet |vars|
+       (setq |vars|
          (cond
-          ((boot-equal |vars| '|all|) '|all|)
-          ((spadlet |l| (lassoc |fn| |$letAssoc|)) (|union| |vars| |l|))
+          ((eq |vars| '|all|) '|all|)
+          ((setq |l| (lassoc |fn| |$letAssoc|)) (|union| |vars| |l|))
           (t |vars|)))
-       (spadlet |$letAssoc| (cons (cons |fn| |vars|) |$letAssoc|))
+       (setq |$letAssoc| (cons (cons |fn| |vars|) |$letAssoc|))
        (cond (|$letAssoc| (setletprintflag t)))
-       (spadlet $traceletflag t)
-       (spadlet |$QuickLet| nil)
+       (setq $traceletflag t)
+       (setq |$QuickLet| nil)
        (cond
         ((and (null (memq |fn| |$traceletFunctions|))
               (null (is_genvar |fn|))
@@ -11013,9 +13629,9 @@ This reports the traced functions
               (null (|stupidIsSpadFunction| |fn|))
               (null (gensymp |fn|)))
           (progn
-           (spadlet |$traceletFunctions| (cons |fn| |$traceletFunctions|))
+           (setq |$traceletFunctions| (cons |fn| |$traceletFunctions|))
            (|compileBoot| |fn|)
-           (spadlet |$traceletFunctions|
+           (setq |$traceletFunctions|
              (|delete| |fn| |$traceletFunctions|))))))))))) 
 
 @
@@ -11053,34 +13669,34 @@ This reports the traced functions
    (progn
     (cond
      ((and (gensymp |fn|) (|stupidIsSpadFunction| (eval |fn|)))
-       (spadlet |fn| (eval |fn|))
+       (setq |fn| (eval |fn|))
        (cond
-        ((compiled-function-p |fn|) (spadlet |fn| (bpiname |fn|)))
+        ((compiled-function-p |fn|) (setq |fn| (bpiname |fn|)))
         (t nil))))
     (cond
-     ((boot-equal |fn| '|Undef|) nil)
+     ((eq |fn| '|Undef|) nil)
      (t
-      (spadlet |fnEntry| (lassoc |fn| |$letAssoc|))
-      (spadlet |vars|
+      (setq |fnEntry| (lassoc |fn| |$letAssoc|))
+      (setq |vars|
        (cond
-        ((spadlet |pair| (|assoc| 'break |fnEntry|))
+        ((setq |pair| (|assoc| 'break |fnEntry|))
           (|union| |vars| (cdr |pair|)))
         (t |vars|)))
-      (spadlet |$letAssoc|
+      (setq |$letAssoc|
        (cond
         ((null |fnEntry|)
           (cons (cons |fn| (list (cons 'break |vars|))) |$letAssoc|))
         (|pair| (rplacd |pair| |vars|) |$letAssoc|)))
       (cond (|$letAssoc| (setletprintflag t)))
-      (spadlet |$QuickLet| nil)
+      (setq |$QuickLet| nil)
       (cond
        ((and (null (memq |fn| |$traceletFunctions|))
              (null (|stupidIsSpadFunction| |fn|))
              (null (gensymp |fn|)))
         (progn
-         (spadlet |$traceletFunctions| (cons |fn| |$traceletFunctions|))
+         (setq |$traceletFunctions| (cons |fn| |$traceletFunctions|))
          (|compileBoot| |fn|)
-         (spadlet |$traceletFunctions|
+         (setq |$traceletFunctions|
           (|delete| |fn| |$traceletFunctions|))))))))))) 
 
 @
@@ -11117,7 +13733,7 @@ This reports the traced functions
  (prog (|condition|)
   (return
    (progn
-    (spadlet |condition| (|MONITOR,EVALTRAN| /breakcondition nil))
+    (setq |condition| (|MONITOR,EVALTRAN| /breakcondition nil))
     (enable-backtrace nil)
     (cond ((eval |condition|) (progn (|sayBrightly| |msg|) (interrupt)))))))) 
 
@@ -11270,34 +13886,34 @@ undo(l) ==
  (prog (tmp1 key s undoWhen n)
   (return
    (progn
-    (spadlet undoWhen '|after|)
+    (setq undoWhen '|after|)
     (when
       (and (pairp |$options|)
            (eq (qcdr |$options|) nil)
            (progn
-            (spadlet tmp1 (qcar |$options|))
+            (setq tmp1 (qcar |$options|))
             (and (pairp tmp1)
                  (eq (qcdr tmp1) nil)
-                 (progn (spadlet key (qcar tmp1)) t)))
+                 (progn (setq key (qcar tmp1)) t)))
        (cond
-        ((|stringPrefix?| (spadlet s (pname key)) "redo")
-          (spadlet |$options| nil) 
+        ((|stringPrefix?| (setq s (pname key)) "redo")
+          (setq |$options| nil) 
           (|read| '(|redo.input|)))
         ((null (|stringPrefix?| s "before"))
           (|userError| "only option to undo is \")redo\""))
         (t 
-          (spadlet undoWhen '|before|)))))
+          (setq undoWhen '|before|)))))
     (if (null l)
-      (spadlet n (spaddifference 1))
-      (spadlet n (car l)))
+      (setq n (spaddifference 1))
+      (setq n (car l)))
     (when (identp n)
-      (spadlet n (parse-integer (pname n)))
+      (setq n (parse-integer (pname n)))
       (cond
        ((null (fixp n)) 
          (|userError| "undo argument must be an integer"))
        (t 
          nil)))
-    (spadlet |$InteractiveFrame| (|undoSteps| (|undoCount| n) undoWhen))
+    (setq |$InteractiveFrame| (|undoSteps| (|undoCount| n) undoWhen))
     nil)))) 
 
 @
@@ -11323,20 +13939,20 @@ recordFrame(systemNormal) ==
     (cond 
      ((null |$undoFlag|) nil)
      (t 
-       (spadlet currentAlist (kar |$frameRecord|))
-       (spadlet delta 
+       (setq currentAlist (kar |$frameRecord|))
+       (setq delta 
          (|diffAlist| (caar |$InteractiveFrame|) |$previousBindings|))
        (cond
-        ((boot-equal systemNormal '|system|)
+        ((eq systemNormal '|system|)
           (cond 
            ((null delta)
              (return nil))
            (t
-             (spadlet delta (cons '|systemCommand| delta))))))
-       (spadlet |$frameRecord| (cons delta |$frameRecord|))
-       (spadlet |$previousBindings|
+             (setq delta (cons '|systemCommand| delta))))))
+       (setq |$frameRecord| (cons delta |$frameRecord|))
+       (setq |$previousBindings|
         (prog (tmp0)
-         (spadlet tmp0 nil)
+         (setq tmp0 nil)
          (return
           (do ((tmp1 (caar |$InteractiveFrame|) (cdr tmp1)) (x nil))
               ((or (atom tmp1) 
@@ -11349,7 +13965,7 @@ recordFrame(systemNormal) ==
                (cons 
                 (car x)
                 (prog (tmp2)
-                 (spadlet tmp2 nil)
+                 (setq tmp2 nil)
                  (return
                   (do ((tmp3 (cdr x) (cdr tmp3)) (|y| nil))
                       ((or (atom tmp3) 
@@ -11410,29 +14026,29 @@ diffAlist(new,old) ==
               (progn (setq pair (car tmp0)) nil)
               (progn 
                (progn 
-                (spadlet name (car pair))
-                (spadlet proplist (cdr pair))
+                (setq name (car pair))
+                (setq proplist (cdr pair))
                 pair) 
                nil))
              nil)
       (seq
        (exit
         (cond
-         ((spadlet oldPair (assq name old))
+         ((setq oldPair (assq name old))
           (cond
-           ((null (spadlet oldProplist (cdr oldPair)))
-             (spadlet acc
+           ((null (setq oldProplist (cdr oldPair)))
+             (setq acc
               (cons
                (cons
                  name 
                  (prog (tmp1)
-                  (spadlet tmp1 nil)
+                  (setq tmp1 nil)
                   (return
                    (do ((tmp2 proplist (cdr tmp2)) (tmp3 nil))
                        ((or (atom tmp2) 
                             (progn (setq tmp3 (car tmp2)) nil)
                             (progn 
-                             (progn (spadlet prop (car tmp3)) tmp3)
+                             (progn (setq prop (car tmp3)) tmp3)
                              nil))
                          (nreverse0 tmp1))
                     (seq
@@ -11440,40 +14056,40 @@ diffAlist(new,old) ==
                       (setq tmp1 (cons (cons prop nil) tmp1))))))))
                acc)))
            (t 
-             (spadlet deltas nil)
+             (setq deltas nil)
              (do ((tmp4 proplist (cdr tmp4)) (|propval| nil))
                  ((or (atom tmp4) 
                       (progn (setq |propval| (car tmp4)) nil)
                       (progn
                        (progn
-                        (spadlet prop (car |propval|))
-                        (spadlet val (cdr |propval|))
+                        (setq prop (car |propval|))
+                        (setq val (cdr |propval|))
                         |propval|)
                        nil))
                    nil)
               (seq
                (exit
                 (cond
-                 ((null (spadlet oldPropval (|assoc| prop oldProplist)))
-                   (spadlet deltas (cons (cons prop nil) deltas)))
+                 ((null (setq oldPropval (|assoc| prop oldProplist)))
+                   (setq deltas (cons (cons prop nil) deltas)))
                  ((eq (cdr oldPropval) val) '|skip|)
-                 (t (spadlet deltas (cons oldPropval deltas)))))))
+                 (t (setq deltas (cons oldPropval deltas)))))))
              (when deltas
-               (spadlet acc 
+               (setq acc 
                 (cons (cons name (nreverse deltas)) acc))))))
          (t
-           (spadlet acc
+           (setq acc
             (cons
              (cons
               name
               (prog (tmp5)
-               (spadlet tmp5 nil)
+               (setq tmp5 nil)
                (return
                 (do ((tmp6 proplist (cdr tmp6)) (tmp7 nil))
                     ((or (atom tmp6) 
                          (progn (setq tmp7 (CAR tmp6)) nil)
                          (progn
-                          (progn (spadlet prop (CAR tmp7)) tmp7)
+                          (progn (setq prop (CAR tmp7)) tmp7)
                           nil))
                        (nreverse0 tmp5))
                  (seq
@@ -11486,8 +14102,8 @@ diffAlist(new,old) ==
                (progn (setq oldPair (car tmp8)) nil)
                (progn
                 (progn
-                 (spadlet name (car oldPair))
-                 (spadlet r (cdr oldPair))
+                 (setq name (car oldPair))
+                 (setq r (cdr oldPair))
                  oldPair)
                 nil))
               nil)
@@ -11496,8 +14112,8 @@ diffAlist(new,old) ==
          (cond
           ((and r (null (lassq name new)))
             (exit 
-             (spadlet acc (cons oldPair acc))))))))
-      (spadlet res (nreverse acc))
+             (setq acc (cons oldPair acc))))))))
+      (setq res (nreverse acc))
       (cond 
        ((and (boundp '|$reportUndo|) |$reportUndo|)
          (|reportUndo| res)))
@@ -11544,8 +14160,8 @@ reportUndo acc ==
              (progn (setq tmp1 (car tmp0)) nil)
              (progn
               (progn
-               (spadlet name (car tmp1))
-               (spadlet proplist (cdr tmp1))
+               (setq name (car tmp1))
+               (setq proplist (cdr tmp1))
                tmp1)
               nil))
             nil)
@@ -11554,14 +14170,14 @@ reportUndo acc ==
        (progn
         (|sayBrightly|
           (strconc '|Properties of | (pname name) " ::"))
-        (spadlet curproplist (lassoc name (caar |$InteractiveFrame|)))
+        (setq curproplist (lassoc name (caar |$InteractiveFrame|)))
         (do ((tmp2 proplist (cdr tmp2)) (tmp3 nil))
             ((or (atom tmp2) 
                  (progn (setq tmp3 (car tmp2)) nil)
                  (progn 
                   (progn 
-                   (spadlet prop (car tmp3))
-                   (spadlet value (cdr tmp3))
+                   (setq prop (car tmp3))
+                   (setq value (cdr tmp3))
                    tmp3)
                   nil))
                 nil)
@@ -11587,8 +14203,8 @@ clearFrame() ==
 (defun |clearFrame| ()
  (progn 
   (|clearCmdAll|)
-  (spadlet |$frameRecord| nil) 
-  (spadlet |$previousBindings| nil))) 
+  (setq |$frameRecord| nil) 
+  (setq |$previousBindings| nil))) 
 
 @
 \subsection{defun undoCount}
@@ -11609,7 +14225,7 @@ undoCount(n) ==  --computes the number of undo's, given $IOindex
  (prog (m)
   (return
    (progn
-    (spadlet m 
+    (setq m 
      (cond 
        ((>= n 0) (spaddifference (spaddifference |$IOindex| n) 1))
        (t (spaddifference n))))
@@ -11662,33 +14278,33 @@ undoSteps(m,beforeOrAfter) ==
     (progn
      (|writeInputLines| '|redo| (spaddifference |$IOindex| m))
      (|recordFrame| '|normal|)
-     (spadlet env (copy (caar |$InteractiveFrame|)))
+     (setq env (copy (caar |$InteractiveFrame|)))
      (do ((|i| 0 (qsadd1 |i|)) (framelist |$frameRecord| (cdr framelist)))
          ((or (qsgreaterp |i| m) (atom framelist)) nil)
       (seq
        (exit
         (progn
-         (spadlet env (|undoSingleStep| (CAR framelist) env))
+         (setq env (|undoSingleStep| (CAR framelist) env))
          (cond
            ((and (pairp framelist) 
                  (progn
-                  (spadlet tmp1 (qcdr framelist))
+                  (setq tmp1 (qcdr framelist))
                   (and (pairp tmp1) 
                        (progn
-                        (spadlet tmp2 (qcar tmp1))
+                        (setq tmp2 (qcar tmp1))
                         (and (pairp tmp2)
                              (eq (qcar tmp2) '|systemCommand|)
                              (progn 
-                              (spadlet systemDelta (qcdr tmp2))
+                              (setq systemDelta (qcdr tmp2))
                               t))))))
-             (spadlet framelist (cdr framelist))
-             (spadlet env (|undoSingleStep| systemDelta env)))
-           (t (spadlet lastTailSeen framelist)))))))
+             (setq framelist (cdr framelist))
+             (setq env (|undoSingleStep| systemDelta env)))
+           (t (setq lastTailSeen framelist)))))))
      (cond
-      ((boot-equal beforeOrAfter '|before|)
-        (spadlet env (|undoSingleStep| (car (cdr lastTailSeen)) env))))
-     (spadlet |$frameRecord| (cdr |$frameRecord|))
-     (spadlet |$InteractiveFrame| (list (list env)))))))) 
+      ((eq beforeOrAfter '|before|)
+        (setq env (|undoSingleStep| (car (cdr lastTailSeen)) env))))
+     (setq |$frameRecord| (cdr |$frameRecord|))
+     (setq |$InteractiveFrame| (list (list env)))))))) 
 
 @
 \subsection{defun undoSingleStep}
@@ -11725,8 +14341,8 @@ undoSingleStep(changes,env) ==
               (progn (setq |change| (car tmp0)) nil)
               (progn 
                (progn 
-                (spadlet name (car |change|))
-                (spadlet changeList (cdr |change|))
+                (setq name (car |change|))
+                (setq changeList (cdr |change|))
                 |change|)
                nil))
              nil)
@@ -11734,25 +14350,25 @@ undoSingleStep(changes,env) ==
        (exit
         (progn
          (when (lassoc '|localModemap| changeList)
-           (spadlet changeList (|undoLocalModemapHack| changeList)))
+           (setq changeList (|undoLocalModemapHack| changeList)))
          (cond
-          ((spadlet pairlist (assq name env))
+          ((setq pairlist (assq name env))
             (cond
-             ((spadlet proplist (cdr pairlist))
+             ((setq proplist (cdr pairlist))
                (do ((tmp1 changeList (cdr tmp1)) (pair nil))
                    ((or (atom tmp1) 
                         (progn (setq pair (car tmp1)) nil)
                         (progn
                          (progn
-                          (spadlet prop (car pair))
-                          (spadlet value (cdr pair))
+                          (setq prop (car pair))
+                          (setq value (cdr pair))
                           pair)
                           nil))
                         nil)
                 (seq
                  (exit
                   (cond
-                   ((spadlet node (assq prop proplist))
+                   ((setq node (assq prop proplist))
                      (rplacd node value))
                    (t
                      (rplacd proplist
@@ -11760,7 +14376,7 @@ undoSingleStep(changes,env) ==
                      (rplaca proplist pair)))))))
              (t (rplacd pairlist changeList))))
           (t 
-            (spadlet env (cons |change| env))))))))
+            (setq env (cons |change| env))))))))
      env))))) 
 
 @
@@ -11777,15 +14393,15 @@ undoLocalModemapHack changeList ==
   (return
    (seq
     (prog (tmp0)
-     (spadlet tmp0 nil)
+     (setq tmp0 nil)
      (return
       (do ((tmp1 changeList (cdr tmp1)) (pair nil))
           ((or (atom tmp1) 
                (progn (setq pair (car tmp1)) nil)
                (progn
                 (progn
-                 (spadlet name (car pair))
-                 (spadlet value (cdr pair))
+                 (setq name (car pair))
+                 (setq value (cdr pair))
                  pair)
                 nil))
               (nreverse0 tmp0))
@@ -11793,12 +14409,12 @@ undoLocalModemapHack changeList ==
         (exit
          (cond
           ((cond
-             ((boot-equal name '|localModemap|) (cons name nil))
+             ((eq name '|localModemap|) (cons name nil))
              (t pair))
            (setq tmp0 
             (cons 
              (cond 
-              ((boot-equal name '|localModemap|) (cons name nil))
+              ((eq name '|localModemap|) (cons name nil))
               (t pair)) tmp0))))))))))))) 
 
 @
@@ -11858,13 +14474,13 @@ removeUndoLines u == --called by writeInputLines
   (return
    (seq
     (progn
-     (spadlet xtra 
+     (setq xtra 
       (cond
        ((stringp |$currentLine|) (cons |$currentLine| nil))
        (t (reverse |$currentLine|))))
-     (spadlet xtra
+     (setq xtra
       (prog (tmp0)
-       (spadlet tmp0 nil)
+       (setq tmp0 nil)
        (return
         (do ((tmp1 xtra (cdr tmp1)) (x nil))
             ((or (atom tmp1)
@@ -11875,11 +14491,11 @@ removeUndoLines u == --called by writeInputLines
            (cond
             ((null (|stringPrefix?| ")history" x))
               (setq tmp0 (cons x tmp0))))))))))
-     (spadlet u (append u xtra))
+     (setq u (append u xtra))
      (cond
       ((null
         (prog (tmp2)
-         (spadlet tmp2 nil)
+         (setq tmp2 nil)
          (return
           (do ((tmp3 nil tmp2) (tmp4 u (cdr tmp4)) (x nil))
               ((or tmp3 (atom tmp4) (progn (setq x (car tmp4)) nil)) tmp2)
@@ -11888,29 +14504,29 @@ removeUndoLines u == --called by writeInputLines
              (setq tmp2 
                (or tmp2 (|stringPrefix?| ")undo" x))))))))) u)
       (t
-        (spadlet savedIOindex |$IOindex|)
-        (spadlet |$IOindex| 1)
+        (setq savedIOindex |$IOindex|)
+        (setq |$IOindex| 1)
         (do ((y u (cdr y)))
             ((atom y) nil)
          (seq
           (exit
            (cond
-            ((boot-equal (elt (spadlet x (car y)) 0) (|char| '|)|))
+            ((eql (elt (setq x (car y)) 0) #\) )
               (cond
                ((|stringPrefix?| ")undo"
-                                 (spadlet s (|trimString| x)))
-                (spadlet s1 (|trimString| (substring s 5 nil)))
+                                 (setq s (|trimString| x)))
+                (setq s1 (|trimString| (substring s 5 nil)))
                 (cond
                   ((nequal s1 ")redo")
-                    (spadlet m (|charPosition| (|char| '|)|) s1 0))
-                    (spadlet code
+                    (setq m (|charPosition| #\) s1 0))
+                    (setq code
                      (cond
                        ((> (maxindex s1) m) (elt s1 (plus m 1)))
-                       (t (|char| '|a|))))
-                    (spadlet s2 (|trimString| (substring s1 0 m)))))
-                (spadlet n
+                       (t #\a)))
+                    (setq s2 (|trimString| (substring s1 0 m)))))
+                (setq n
                  (cond
-                  ((boot-equal s1 ")redo")
+                  ((string= s1 ")redo")
                      0)
                   ((nequal s2 "")
                     (|undoCount| (parse-integer s2)))
@@ -11918,37 +14534,37 @@ removeUndoLines u == --called by writeInputLines
                 (rplaca y
                   (concat ">" code (stringimage n))))
                (t nil)))
-            (t (spadlet |$IOindex| (plus |$IOindex| 1)))))))
-        (spadlet acc nil)
+            (t (setq |$IOindex| (plus |$IOindex| 1)))))))
+        (setq acc nil)
         (do ((y (nreverse u) (cdr y)))
             ((atom y) nil)
          (seq
           (exit
            (cond
-            ((boot-equal (elt (spadlet x (car y)) 0) (|char| '>))
-              (spadlet code (elt x 1))
-              (spadlet n (parse-integer (substring x 2 nil)))
-              (spadlet y (cdr y))
+            ((eql (elt (setq x (car y)) 0) #\>)
+              (setq code (elt x 1))
+              (setq n (parse-integer (substring x 2 nil)))
+              (setq y (cdr y))
               (do () 
                   ((null y) nil)
                (seq
                 (exit
                  (progn
-                  (spadlet c (car y))
+                  (setq c (car y))
                   (cond 
-                   ((or (boot-equal (elt c 0) (|char| '|)|))
-                        (boot-equal (elt c 0) (|char| '>)))
-                     (spadlet y (cdr y)))
+                   ((or (eql (elt c 0) #\))
+                        (eql (elt c 0) #\>))
+                     (setq y (cdr y)))
                    ((eql n 0)
                      (return nil))
                    (t
-                     (spadlet n (spaddifference n 1))
-                     (spadlet y (cdr y))))))))
+                     (setq n (spaddifference n 1))
+                     (setq y (cdr y))))))))
               (cond
-               ((and y (nequal code (|char| '|b|)))
-                 (spadlet acc (cons c acc)))))
-            (t (spadlet acc (cons x acc)))))))
-        (spadlet |$IOindex| savedIOindex)
+               ((and y (nequal code #\b))
+                 (setq acc (cons c acc)))))
+            (t (setq acc (cons x acc)))))))
+        (setq |$IOindex| savedIOindex)
         acc)))))))
 
 @
@@ -12092,7 +14708,7 @@ whatSpad2Cmd l ==
  (prog (|x'|)
   (return
    (seq
-    (if (and (pairp x) (progn (spadlet |x'| (qcar x)) t))
+    (if (and (pairp x) (progn (setq |x'| (qcar x)) t))
       (exit (downcase |x'|)))
     (exit (downcase x)))))) 
 
@@ -12106,19 +14722,19 @@ whatSpad2Cmd l ==
   (return
    (seq
     (progn
-     (spadlet |$e| |$EmptyEnvironment|)
+     (setq |$e| |$EmptyEnvironment|)
      (cond
       ((null arg) (|reportWhatOptions|))
       (t
-        (spadlet |key0| (car arg))
-        (spadlet args (cdr arg))
-        (spadlet key (|selectOptionLC| |key0| |$whatOptions| nil))
+        (setq |key0| (car arg))
+        (setq args (cdr arg))
+        (setq key (|selectOptionLC| |key0| |$whatOptions| nil))
         (cond
          ((null key) (|sayKeyedMsg| 's2iz0043 nil))
          (t
-          (spadlet args
+          (setq args
            (prog (t0)
-            (spadlet t0 nil)
+            (setq t0 nil)
             (return
               (do ((t1 args (cdr t1)) (p nil))
                   ((or (atom t1)
@@ -12129,7 +14745,7 @@ whatSpad2Cmd l ==
                  (setq t0 (cons (|whatSpad2Cmd,fixpat| p) t0))))))))
           (seq
            (cond
-            ((boot-equal key '|things|)
+            ((eq key '|things|)
               (do ((t2 |$whatOptions| (cdr t2)) (opt nil))
                   ((or (atom t2) (progn (setq opt (CAR t2)) nil)) nil)
                (seq
@@ -12137,17 +14753,17 @@ whatSpad2Cmd l ==
                  (cond
                   ((null (memq opt '(|things|)))
                     (exit (|whatSpad2Cmd| (cons opt args)))))))))
-            ((boot-equal key '|categories|)
+            ((eq key '|categories|)
               (|filterAndFormatConstructors| '|category| "Categories" args))
-            ((boot-equal key '|commands|) (|whatCommands| args))
-            ((boot-equal key '|domains|)
+            ((eq key '|commands|) (|whatCommands| args))
+            ((eq key '|domains|)
               (|filterAndFormatConstructors| '|domain| "Domains" args))
-            ((boot-equal key '|operations|)
+            ((eq key '|operations|)
                (|apropos| args))
-            ((boot-equal key '|packages|)
+            ((eq key '|packages|)
               (|filterAndFormatConstructors| '|package| "Packages" args))
             (t
-             (cond ((boot-equal key '|synonyms|)
+             (cond ((eq key '|synonyms|)
                       (|printSynonyms| args))))))))))))))) 
 
 @
@@ -12173,7 +14789,7 @@ filterAndFormatConstructors(constrType,label,patterns) ==
   (return
    (progn (|centerAndHighlight| |label| $linelength 
            (|specialChar| '|hbar|))
-    (spadlet |l|
+    (setq |l|
      (|filterListOfStringsWithFn| |patterns|
        (|whatConstructors| |constrType|)
        (|function| cdr)))
@@ -12218,7 +14834,7 @@ whatConstructors constrType ==
    (seq
     (msort
      (prog (t0)
-      (spadlet t0 nil)
+      (setq t0 nil)
       (return
        (do ((t1 (|allConstructors|) (cdr t1)) (|con| nil))
            ((or (atom t1) (progn (setq |con| (car t1)) nil)) (nreverse0 t0))
@@ -12258,13 +14874,13 @@ apropos l ==
   (return
    (seq
     (progn
-     (spadlet |ops|
+     (setq |ops|
       (cond 
        ((null arg) (|allOperations|))
        (t
          (|filterListOfStrings|
           (prog (t0)
-           (spadlet t0 nil)
+           (setq t0 nil)
            (return
             (do ((t1 arg (cdr t1)) (p nil))
                 ((or (atom t1) (progn (setq p (car t1)) nil))
@@ -12341,45 +14957,45 @@ workfilesSpad2Cmd args ==
     (cond 
      (args (|throwKeyedMsg| 's2iz0047 nil))
      (t
-       (spadlet |deleteFlag| nil)
+       (setq |deleteFlag| nil)
        (do ((t0 |$options| (cdr t0)) (t1 nil))
            ((or (atom t0)
                 (progn (setq t1 (car t0)) nil)
-                (progn (progn (spadlet type (car t1)) t1) nil))
+                (progn (progn (setq type (car t1)) t1) nil))
              nil)
         (seq
          (exit
           (progn 
-           (spadlet |type1|
+           (setq |type1|
             (|selectOptionLC| type '(|boot| |lisp| |meta| |delete|) nil))
            (cond
             ((null |type1|)
               (|throwKeyedMsg| 's2iz0048 (cons type nil)))
-            ((boot-equal |type1| '|delete|)
-              (spadlet |deleteFlag| t)))))))
+            ((eq |type1| '|delete|)
+              (setq |deleteFlag| t)))))))
        (do ((t2 |$options| (cdr t2)) (t3 nil))
            ((or (atom t2)
             (progn (setq t3 (CAR t2)) nil)
             (progn
              (progn 
-              (spadlet type (car t3))
-              (spadlet |flist| (cdr t3)) t3)
+              (setq type (car t3))
+              (setq |flist| (cdr t3)) t3)
              nil))
             nil)
        (seq
         (exit
          (progn
-          (spadlet |type1|
+          (setq |type1|
            (|selectOptionLC| type '(|boot| |lisp| |meta| |delete|) nil))
           (cond
-           ((boot-equal |type1| '|delete|) nil)
+           ((eq |type1| '|delete|) nil)
            (t
             (do ((t4 |flist| (CDR t4)) (|file| nil))
                 ((or (atom t4) (progn (setq |file| (car t4)) nil)) nil)
              (seq
               (exit
                (progn
-                (spadlet |fl|
+                (setq |fl|
                  (|pathname|
                   (cons |file| (cons |type1| (cons "*" nil)))))
                 (cond 
@@ -12480,80 +15096,80 @@ zsystemdevelopment1(l,im) ==
   (return
    (seq
     (progn
-     (spadlet |$InteractiveMode| |im|)
-     (spadlet |fromopt| nil)
+     (setq |$InteractiveMode| |im|)
+     (setq |fromopt| nil)
      (do ((t0 |$options| (cdr t0)) (t1 nil))
          ((or (atom t0)
               (progn (setq t1 (car t0)) nil)
               (progn
                (progn
-                (spadlet opt (CAR t1))
-                (spadlet optargs (CDR t1))
+                (setq opt (CAR t1))
+                (setq optargs (CDR t1))
                 t1)
                nil))
            nil)
       (seq
        (exit
         (progn
-         (spadlet |opt1| (|selectOptionLC| opt '(|from|) nil))
+         (setq |opt1| (|selectOptionLC| opt '(|from|) nil))
          (cond
-          ((boot-equal |opt1| '|from|)
-            (spadlet |fromopt| (cons (cons 'from optargs) nil))))))))
+          ((eq |opt1| '|from|)
+            (setq |fromopt| (cons (cons 'from optargs) nil))))))))
      (do ((t2 |$options| (cdr t2)) (t3 nil))
          ((or (atom t2)
               (progn (setq t3 (car t2)) nil)
               (progn
                (progn
-                (spadlet opt (car t3))
-                (spadlet optargs (cdr t3))
+                (setq opt (car t3))
+                (setq optargs (cdr t3))
                 t3)
                nil))
           nil)
       (seq
        (exit
         (progn
-         (cond ((null optargs) (spadlet optargs arg)))
-         (spadlet |newopt| (append optargs |fromopt|))
-         (spadlet |opt1| (|selectOptionLC| opt '(|from|) nil))
+         (cond ((null optargs) (setq optargs arg)))
+         (setq |newopt| (append optargs |fromopt|))
+         (setq |opt1| (|selectOptionLC| opt '(|from|) nil))
          (cond
-          ((boot-equal |opt1| '|from|)
+          ((eq |opt1| '|from|)
             nil)
-          ((boot-equal opt '|c|)
+          ((eq opt '|c|)
             (|/D,1| |newopt| (/COMP) nil nil))
-          ((boot-equal opt '|d|)
+          ((eq opt '|d|)
             (|/D,1| |newopt| 'define nil nil))
-          ((boot-equal opt '|dt|)
+          ((eq opt '|dt|)
             (|/D,1| |newopt| 'define nil t))
-          ((boot-equal opt '|ct|)
+          ((eq opt '|ct|)
             (|/D,1| |newopt| (/COMP) nil t))
-          ((boot-equal opt '|ctl|)
+          ((eq opt '|ctl|)
             (|/D,1| |newopt| (/COMP) nil 'tracelet))
-          ((boot-equal opt '|ec|)
+          ((eq opt '|ec|)
             (|/D,1| |newopt| (/COMP) t nil))
-          ((boot-equal opt '|ect|)
+          ((eq opt '|ect|)
             (|/D,1| |newopt| (/COMP) t t))
-          ((boot-equal opt '|e|)
+          ((eq opt '|e|)
             (|/D,1| |newopt| nil t nil))
-          ((boot-equal opt '|version|)
+          ((eq opt '|version|)
             (|version|))
-          ((boot-equal opt '|pause|)
-            (spadlet |conStream|
+          ((eq opt '|pause|)
+            (setq |conStream|
               (defiostream '((device . console) (qual . v)) 120 0))
             (next |conStream|)
             (shut |conStream|))
           ((or 
-              (boot-equal opt '|update|)
-              (boot-equal opt '|patch|))
-            (spadlet |$InteractiveMode| nil)
-            (spadlet |upf|
+              (eq opt '|update|)
+              (eq opt '|patch|))
+            (setq |$InteractiveMode| nil)
+            (setq |upf|
              (cons
               (or (kar optargs) /version)
               (cons
                (or (kadr optargs) /wsname)
                (cons (or (kaddr optargs) '*) nil))))
-            (spadlet |fun|
+            (setq |fun|
              (cond
-              ((boot-equal opt '|patch|) '/update-lib-1)
+              ((eq opt '|patch|) '/update-lib-1)
               (t '/update-1)))
             (catch 'filenam (funcall |fun| |upf|))
             (|sayMessage| "   Update/patch is completed."))
@@ -12694,6 +15310,8 @@ load the file \verb|exposed.lsp| to set up the exposure group information.
 (in-package "BOOT")
 <<initvars>>
 
+<<defmacro funfind>>
+
 <<defun abbreviations>>
 <<defun abbreviationsSpad2Cmd>>
 <<defun addNewInterpreterFrame>>
@@ -12715,20 +15333,22 @@ load the file \verb|exposed.lsp| to set up the exposure group information.
 <<defun clearCmdExcept>>
 <<defun clearCmdParts>>
 <<defun clearCmdSortedCaches>>
-<<defun clearSpad2Cmd>>
 <<defun clearFrame>>
+<<defun clearSpad2Cmd>>
 <<defun close>>
 <<defun closeInterpreterFrame>>
+<<defun coerceSpadArgs2E>>
+<<defun coerceSpadFunValue2E>>
+<<defun coerceTraceArgs2E>>
+<<defun coerceTraceFunValue2E>>
+<<defun compileAsharpArchiveCmd>>
 <<defun compileAsharpCmd>>
 <<defun compileAsharpCmd1>>
-<<defun compileAsharpArchiveCmd>>
+<<defun compileAsharpLispCmd>>
 <<defun compileBoot>>
 <<defun compiler>>
 <<defun compileSpadLispCmd>>
-<<defun coerceSpadArgs2E>>
-<<defun coerceSpadFunValue2E>>
-<<defun coerceTraceArgs2E>>
-<<defun coerceTraceFunValue2E>>
+<<defun copyright>>
 <<defun createCurrentInterpreterFrame>>
 <<defun credits>>
 
@@ -12741,6 +15361,7 @@ load the file \verb|exposed.lsp| to set up the exposure group information.
 <<defun displayFrameNames>>
 <<defun displayMacros>>
 <<defun displayOperations>>
+<<defun displaySetOptionInformation>>
 <<defun displaySpad2Cmd>>
 <<defun domainToGenvar>>
 
@@ -12764,60 +15385,57 @@ load the file \verb|exposed.lsp| to set up the exposure group information.
 <<defun frameName>>
 <<defun frameNames>>
 <<defun frameSpad2Cmd>>
+<<defun funfind,LAM>>
 
+<<defun genDomainTraceName>>
+<<defun gensymInt>>
 <<defun getAliasIfTracedMapParameter>>
 <<defun getBpiNameIfTracedMap>>
-<<defun genDomainTraceName>>
 <<defun getenviron>>
 <<defun getMapSig>>
+<<defun getMapSubNames>>
 <<defun getOption>>
+<<defun getPreviousMapSubNames>>
 <<defun getTraceOption>>
-<<defun getTraceOptions>>
 <<defun getTraceOption,hn>>
-<<defun gensymInt>>
+<<defun getTraceOptions>>
 
 <<defun hasPair>>
+<<defun help>>
+<<defun helpSpad2Cmd>>
 <<defun histFileErase>>
-<<defun history>>
 <<defun histFileName>>
 <<defun histInputFileName>>
+<<defun history>>
 <<defun historySpad2Cmd>>
 
+<<defun importFromFrame>>
 <<defun incBiteOff>>
 <<defun incFileName>>
-<<defun importFromFrame>>
-<<defun init-memory-config>>
 <<defun initHist>>
 <<defun initHistList>>
 <<defun initializeInterpreterFrameRing>>
+<<defun init-memory-config>>
 <<defun initroot>>
 <<defun intloop>>
 <<defun intloopPrefix?>>
 <<defun intloopReadConsole>>
 <<defun isDomainOrPackage>>
 <<defun isInterpOnlyMap>>
+<<defun isListOfIdentifiers>>
+<<defun isListOfIdentifiersOrStrings>>
 <<defun isSubForRedundantMapName>>
 <<defun isTraceGensym>>
 <<defun isUncompiledMap>>
 
 <<defun lassocSub>>
+<<defun leaveScratchpad>>
 <<defun letPrint>>
 <<defun letPrint2>>
 <<defun letPrint3>>
 <<defun listConstructorAbbreviations>>
 <<defun loadExposureGroupData>>
 
-<<defmacro funfind>>
-<<defun funfind,LAM>>
-
-<<defun getMapSubNames>>
-<<defun getPreviousMapSubNames>>
-
-<<defun isListOfIdentifiers>>
-<<defun isListOfIdentifiersOrStrings>>
-
-<<defun leaveScratchpad>>
-
 <<defun make-absolute-filename>>
 <<defun makeHistFileName>>
 <<defun makeInitialModemapFrame>>
@@ -12826,11 +15444,12 @@ load the file \verb|exposed.lsp| to set up the exposure group information.
 <<defun ncIntLoop>>
 <<defun ncloopCommand>>
 <<defun ncloopEscaped>>
+<<defun ncloopIncFileName>>
 <<defun ncloopInclude>>
 <<defun ncloopInclude1>>
-<<defun ncloopIncFileName>>
 <<defun ncloopPrefix?>>
 <<defun ncTopLevel>>
+<<defun newHelpSpad2Cmd>>
 <<defun nextInterpreterFrame>>
 
 <<defun oldHistFileName>>
@@ -12854,11 +15473,11 @@ load the file \verb|exposed.lsp| to set up the exposure group information.
 <<defun rassocSub>>
 <<defun readHiFi>>
 <<defun reclaim>>
+<<defun recordFrame>>
 <<defun recordNewValue>>
 <<defun recordNewValue0>>
 <<defun recordOldValue>>
 <<defun recordOldValue0>>
-<<defun recordFrame>>
 <<defun removeOption>>
 <<defun removeTracedMapSigs>>
 <<defun removeUndoLines>>
@@ -12878,16 +15497,17 @@ load the file \verb|exposed.lsp| to set up the exposure group information.
 <<defun saveMapSig>>
 <<defun sayExample>>
 <<defun ScanOrPairVec>>
+<<defun set>>
+<<defun set1>>
 <<defun setCurrentLine>>
 <<defun setHistoryCore>>
+<<defun setIOindex>>
 <<defun set-restart-hook>>
 <<defun shortenForPrinting>>
+<<defun showHistory>>
 <<defun showInOut>>
 <<defun showInput>>
-<<defun setIOindex>>
-<<defun showHistory>>
 <<defun spad>>
-<<defun spad-save>>
 <<defun spadClosure?>>
 <<defun SpadInterpretStream>>
 <<defun spadReply>>
@@ -12895,10 +15515,11 @@ load the file \verb|exposed.lsp| to set up the exposure group information.
 <<defun SPADRREAD>>
 <<defun SPADRWRITE>>
 <<defun SPADRWRITE0>>
+<<defun spad-save>>
 <<defun spadTrace>>
-<<defun spadTrace,isTraceable>>
-<<defun spadTrace,g>>
 <<defun spadTraceAlias>>
+<<defun spadTrace,g>>
+<<defun spadTrace,isTraceable>>
 <<defun spadUntrace>>
 <<defun stackTraceOptionError>>
 <<defun statisticsInitialization>>
@@ -12912,11 +15533,13 @@ load the file \verb|exposed.lsp| to set up the exposure group information.
 <<defun traceDomainConstructor>>
 <<defun traceDomainLocalOps>>
 <<defun tracelet>>
-<<defun /tracereply>>
-<<defun transOnlyOption>>
 <<defun traceOptionError>>
+<<defun /tracereply>>
 <<defun traceReply>>
 <<defun traceSpad2Cmd>>
+<<defun translateTrueFalse2YesNo>>
+<<defun translateYesNo2TrueFalse>>
+<<defun transOnlyOption>>
 <<defun transTraceItem>>
 
 <<defun undo>>
@@ -12947,12 +15570,12 @@ load the file \verb|exposed.lsp| to set up the exposure group information.
 <<defun withAsharpCmd>>
 <<defun workfiles>>
 <<defun workfilesSpad2Cmd>>
-<<defun writify>>
-<<defun writify,writifyInner>>
-<<defun writifyComplain>>
 <<defun writeHiFi>>
 <<defun writeHistModesAndValues>>
 <<defun writeInputLines>>
+<<defun writify>>
+<<defun writifyComplain>>
+<<defun writify,writifyInner>>
 
 <<defun yesanswer>>
 
@@ -12960,7 +15583,6 @@ load the file \verb|exposed.lsp| to set up the exposure group information.
 <<defun zsystemdevelopment1>>
 <<defun zsystemDevelopmentSpad2Cmd>>
 
-
 @
 \chapter{The Global Variables}
 \section{Star Global Variables}
diff --git a/changelog b/changelog
index 9c57f29..5bccecf 100644
--- a/changelog
+++ b/changelog
@@ -1,3 +1,11 @@
+20090314 tpd src/axiom-website/patches.html 20090314.01.tpd.patch
+20090314 tpd books/bookvol5 document )set, include root code
+20090314 tpd src/input/Makefile add cmds, setcmd unit tests
+20090314 tpd src/interp/setvars.boot begin boot->lisp rewrite
+20090314 tpd src/interp/setvart.boot remove $setOptions
+20090314 tpd src/input/unittest1.input unit test )cmd commands
+20090314 tpd src/input/cmds.input unit test )cmd commands
+20090314 tpd src/input/setcmd.input unit test )set commands
 20090311 tpd src/axiom-website/patches.html 20090311.01.tpd.patch
 20090311 tpd books/bookvol5 move quit, pquit roots
 20090311 tpd src/interp/i-syscmd.boot move quit, pquit roots
diff --git a/src/axiom-website/patches.html b/src/axiom-website/patches.html
index ad4f219..f477e09 100644
--- a/src/axiom-website/patches.html
+++ b/src/axiom-website/patches.html
@@ -1001,5 +1001,7 @@ bookvol5 add summary, copyright, help roots<br/>
 bookvol10.4 add credits, summary to API package<br/>
 <a href="patches/20090311.01.tpd.patch">20090311.01.tpd.patch</a>
 bookvol5 add quit, pquit roots<br/>
+<a href="patches/20090314.01.tpd.patch">20090314.01.tpd.patch</a>
+bookvol5 document )set, include root code<br/>
  </body>
 </html>
diff --git a/src/input/Makefile.pamphlet b/src/input/Makefile.pamphlet
index 57c7c6b..0e0d567 100644
--- a/src/input/Makefile.pamphlet
+++ b/src/input/Makefile.pamphlet
@@ -285,7 +285,8 @@ REGRES= algaggr.regress algbrbf.regress  algfacob.regress alist.regress  \
     calculus2.regress calculus.regress cardinal.regress card.regress \
     carten.regress    cclass.regress   char.regress     ch.regress \
     chtheorem.regress classtalk.regress \
-    clifford.regress  clif.regress     coercels.regress collect.regress \
+    clifford.regress  clif.regress     cmds.regress \
+    coercels.regress  collect.regress \
     complex.regress   conformal.regress \
     constant.regress  contfrac.regress contfrc.regress \
     curl.regress      cwmmt.regress \
@@ -368,7 +369,7 @@ REGRES= algaggr.regress algbrbf.regress  algfacob.regress alist.regress  \
     scherk.regress    scope.regress    seccsc.regress \
     segbind.regress   seg.regress \
     series2.regress   series.regress   sersolve.regress set.regress \
-    sincos.regress    sinhcosh.regress \
+    setcmd.regress    sincos.regress    sinhcosh.regress \
     sincosex.regress  sint.regress     skew.regress     slowint.regress \
     solvetra.regress  space3.regress   sqmatrix.regress sqrt3.regress \
     sregset.regress \
@@ -540,7 +541,7 @@ FILES= ${OUT}/algaggr.input  ${OUT}/algbrbf.input    ${OUT}/algfacob.input \
        ${OUT}/cardinal.input ${OUT}/card.input       ${OUT}/carten.input \
        ${OUT}/cclass.input   ${OUT}/cdraw.input      ${OUT}/char.input \
        ${OUT}/ch.input       ${OUT}/chtheorem.input  ${OUT}/classtalk.input \
-       ${OUT}/clifford.input ${OUT}/clif.input \
+       ${OUT}/clifford.input ${OUT}/clif.input       ${OUT}/cmds.input \
        ${OUT}/coercels.input ${OUT}/collect.input    ${OUT}/color.input \
        ${OUT}/complex.input  ${OUT}/cone.input       ${OUT}/conformal.input \
        ${OUT}/constant.input \
@@ -668,7 +669,7 @@ FILES= ${OUT}/algaggr.input  ${OUT}/algbrbf.input    ${OUT}/algfacob.input \
        ${OUT}/scherk.input   ${OUT}/scope.input      ${OUT}/seccsc.input \
        ${OUT}/segbind.input  ${OUT}/seg.input        ${OUT}/series2.input \
        ${OUT}/series.input   ${OUT}/sersolve.input   ${OUT}/set.input \
-       ${OUT}/sincos.input   ${OUT}/sinhcosh.input \
+       ${OUT}/setcmd.input   ${OUT}/sincos.input   ${OUT}/sinhcosh.input \
        ${OUT}/sincosex.input ${OUT}/sininv.input     ${OUT}/sinsin.input \
        ${OUT}/sinsin2.input  ${OUT}/sint.input       ${OUT}/skew.input \
        ${OUT}/slowint.input  ${OUT}/solvetra.input   ${OUT}/space3.input \
@@ -767,6 +768,7 @@ DOCFILES= \
   ${DOC}/char.input.dvi        ${DOC}/ch.input.dvi         \
   ${DOC}/chtheorem.input.dvi   ${DOC}/classtalk.input.dvi  \
   ${DOC}/clifford.input.dvi    ${DOC}/clif.input.dvi       \
+  ${DOC}/cmds.input.dvi       \
   ${DOC}/coercels.input.dvi    ${DOC}/collect.input.dvi    \
   ${DOC}/color.input.dvi       ${DOC}/complex.input.dvi    \
   ${DOC}/cone.input.dvi        ${DOC}/conformal.input.dvi  \
@@ -1016,7 +1018,8 @@ DOCFILES= \
   ${DOC}/segbind.input.dvi    \
   ${DOC}/seg.input.dvi         ${DOC}/series2.input.dvi    \
   ${DOC}/series.input.dvi      ${DOC}/sersolve.input.dvi   \
-  ${DOC}/set.input.dvi         ${DOC}/sincos.input.dvi     \
+  ${DOC}/set.input.dvi         ${DOC}/setcmd.input.dvi     \
+  ${DOC}/sincos.input.dvi     \
   ${DOC}/sinhcosh.input.dvi    ${DOC}/sincosex.input.dvi   \
   ${DOC}/sininv.input.dvi      ${DOC}/sinsin2.input.dvi    \
   ${DOC}/sinsin.input.dvi      ${DOC}/sint.input.dvi       \
diff --git a/src/input/cmds.input.pamphlet b/src/input/cmds.input.pamphlet
new file mode 100644
index 0000000..4051b0c
--- /dev/null
+++ b/src/input/cmds.input.pamphlet
@@ -0,0 +1,847 @@
+\documentclass{article}
+\usepackage{axiom}
+\begin{document}
+\title{\$SPAD/src/input cmds.input}
+\author{Timothy Daly}
+\maketitle
+\begin{abstract}
+\end{abstract}
+\eject
+\tableofcontents
+\eject
+<<*>>=
+)spool cmds.output
+)set message test on
+)set message auto off
+)clear all
+ 
+--S 1 of 15
+)abbreviation domain TIM TimDaly )quiet
+--R 
+--E 1
+
+--S 2 of 15
+)abbreviation domain TIMD TimDalyDomain
+--R 
+--R   TIMD abbreviates domain TimDalyDomain 
+--E 2
+
+--S 3 of 15
+)abbreviation category TIMC TimDalyCategory
+--R 
+--R   TIMC abbreviates category TimDalyCategory 
+--E 3
+
+--S 4 of 15
+)abbreviation package TIMP TimDalyPackage
+--R 
+--R   TIMP abbreviates package TimDalyPackage 
+--E 4
+
+--S 5 of 15
+)abbreviation query LIST
+--R 
+--R   LIST abbreviates domain List 
+--E 5
+
+--S 6 of 15
+)abbreviation query List
+--R 
+--R   LIST abbreviates domain List 
+--E 6
+
+--S 7 of 15
+)abbreviation query TIMD
+--R 
+--R   TIMD abbreviates domain TimDalyDomain 
+--E 7
+
+--S 8 of 15
+)abbreviation remove TIMD
+--R 
+--E 8
+
+--S 9 of 15
+)abbreviation query TIMD
+--R 
+--R   TIMD is neither a constructor name nor a constructor abbreviation.
+--E 9
+
+--S 10 of 15
+)abbreviation query TimDalyPackage
+--R 
+--R   TIMP abbreviates package TimDalyPackage 
+--E 10
+
+--S 11 of 15
+)abbreviation remove TimDalyPackage
+--R 
+--E 11
+
+--S 12 of 15
+)abbreviation query TimDalyPackage
+--R 
+--R   TIMP abbreviates package TimDalyPackage 
+--E 12
+
+--S 13 of 15
+)what categories
+--R 
+--R------------------------------- Categories --------------------------------
+--R A1AGG    OneDimensionalArrayAggregate ABELGRP  AbelianGroup
+--R ABELMON  AbelianMonoid                ABELSG   AbelianSemiGroup
+--R ACF      AlgebraicallyClosedField
+--R ACFS     AlgebraicallyClosedFunctionSpace
+--R AGG      Aggregate
+--R AHYP     ArcHyperbolicFunctionCategory
+--R ALAGG    AssociationListAggregate     ALGEBRA  Algebra
+--R AMR      AbelianMonoidRing            ARR2CAT  TwoDimensionalArrayCategory
+--R ATRIG    ArcTrigonometricFunctionCategory
+--R ATTREG   AttributeRegistry            BASTYPE  BasicType
+--R BGAGG    BagAggregate                 BMODULE  BiModule
+--R BRAGG    BinaryRecursiveAggregate     BTAGG    BitAggregate
+--R BTCAT    BinaryTreeCategory           CABMON   CancellationAbelianMonoid
+--R CACHSET  CachableSet
+--R CFCAT    CombinatorialFunctionCategory
+--R CHARNZ   CharacteristicNonZero        CHARZ    CharacteristicZero
+--R CLAGG    Collection                   COMBOPC  CombinatorialOpsCategory
+--R COMPCAT  ComplexCategory              COMRING  CommutativeRing
+--R DIAGG    Dictionary                   DIFEXT   DifferentialExtension
+--R DIFRING  DifferentialRing             DIOPS    DictionaryOperations
+--R DIRPCAT  DirectProductCategory        DIVRING  DivisionRing
+--R DLAGG    DoublyLinkedAggregate
+--R DPOLCAT  DifferentialPolynomialCategory
+--R DQAGG    DequeueAggregate             DVARCAT  DifferentialVariableCategory
+--R ELAGG    ExtensibleLinearAggregate    ELEMFUN  ElementaryFunctionCategory
+--R ELTAB    Eltable                      ELTAGG   EltableAggregate
+--R ENTIRER  EntireRing                   ES       ExpressionSpace
+--R EUCDOM   EuclideanDomain              EVALAB   Evalable
+--R FAMONC   FreeAbelianMonoidCategory    FAMR     FiniteAbelianMonoidRing
+--R FAXF     FiniteAlgebraicExtensionField
+--R FDIVCAT  FiniteDivisorCategory        FEVALAB  FullyEvalableOver
+--R FFCAT    FunctionFieldCategory        FFIELDC  FiniteFieldCategory
+--R FIELD    Field                        FILECAT  FileCategory
+--R FINAALG  FiniteRankNonAssociativeAlgebra
+--R FINITE   Finite                       FINRALG  FiniteRankAlgebra
+--R FLAGG    FiniteLinearAggregate        FLALG    FreeLieAlgebra
+--R FLINEXP  FullyLinearlyExplicitRingOver
+--R FMC      FortranMatrixCategory        FMCAT    FreeModuleCat
+--R FMFUN    FortranMatrixFunctionCategory
+--R FMTC     FortranMachineTypeCategory   FNCAT    FileNameCategory
+--R FORTCAT  FortranProgramCategory       FORTFN   FortranFunctionCategory
+--R FPATMAB  FullyPatternMatchable        FPC      FieldOfPrimeCharacteristic
+--R FPS      FloatingPointSystem          FRAMALG  FramedAlgebra
+--R FRETRCT  FullyRetractableTo           FRNAALG  FramedNonAssociativeAlgebra
+--R FS       FunctionSpace                FSAGG    FiniteSetAggregate
+--R FVC      FortranVectorCategory
+--R FVFUN    FortranVectorFunctionCategory
+--R GCDDOM   GcdDomain                    GRALG    GradedAlgebra
+--R GRMOD    GradedModule                 GROUP    Group
+--R HOAGG    HomogeneousAggregate         HYPCAT   HyperbolicFunctionCategory
+--R IDPC     IndexedDirectProductCategory IEVALAB  InnerEvalable
+--R INS      IntegerNumberSystem          INTCAT   IntervalCategory
+--R INTDOM   IntegralDomain               IXAGG    IndexedAggregate
+--R KDAGG    KeyedDictionary              KOERCE   CoercibleTo
+--R KONVERT  ConvertibleTo                LALG     LeftAlgebra
+--R LFCAT    LiouvillianFunctionCategory  LIECAT   LieAlgebra
+--R LINEXP   LinearlyExplicitRingOver     LMODULE  LeftModule
+--R LNAGG    LinearAggregate
+--R LODOCAT  LinearOrdinaryDifferentialOperatorCategory
+--R LOGIC    Logic                        LSAGG    ListAggregate
+--R LZSTAGG  LazyStreamAggregate          MATCAT   MatrixCategory
+--R MDAGG    MultiDictionary              MLO      MonogenicLinearOperator
+--R MODULE   Module                       MONAD    Monad
+--R MONADWU  MonadWithUnit                MONOGEN  MonogenicAlgebra
+--R MONOID   Monoid                       MSETAGG  MultisetAggregate
+--R MTSCAT   MultivariateTaylorSeriesCategory
+--R NAALG    NonAssociativeAlgebra        NARNG    NonAssociativeRng
+--R NASRING  NonAssociativeRing
+--R NTSCAT   NormalizedTriangularSetCategory
+--R NUMINT   NumericalIntegrationCategory OAGROUP  OrderedAbelianGroup
+--R OAMON    OrderedAbelianMonoid         OAMONS   OrderedAbelianMonoidSup
+--R OASGP    OrderedAbelianSemiGroup      OC       OctonionCategory
+--R OCAMON   OrderedCancellationAbelianMonoid
+--R ODECAT   OrdinaryDifferentialEquationsSolverCategory
+--R OINTDOM  OrderedIntegralDomain        OM       OpenMath
+--R OMSAGG   OrderedMultisetAggregate
+--R OPTCAT   NumericalOptimizationCategory
+--R ORDFIN   OrderedFinite                ORDMON   OrderedMonoid
+--R ORDRING  OrderedRing                  ORDSET   OrderedSet
+--R OREPCAT  UnivariateSkewPolynomialCategory
+--R PADICCT  PAdicIntegerCategory         PATAB    Patternable
+--R PATMAB   PatternMatchable
+--R PDECAT   PartialDifferentialEquationsSolverCategory
+--R PDRING   PartialDifferentialRing      PERMCAT  PermutationCategory
+--R PFECAT   PolynomialFactorizationExplicit
+--R PID      PrincipalIdealDomain         POLYCAT  PolynomialCategory
+--R PPCURVE  PlottablePlaneCurveCategory  PRIMCAT  PrimitiveFunctionCategory
+--R PRQAGG   PriorityQueueAggregate       PSCAT    PowerSeriesCategory
+--R PSCURVE  PlottableSpaceCurveCategory  PSETCAT  PolynomialSetCategory
+--R PTCAT    PointCategory
+--R PTRANFN  PartialTranscendentalFunctions
+--R QFCAT    QuotientFieldCategory        QUAGG    QueueAggregate
+--R QUATCAT  QuaternionCategory           RADCAT   RadicalCategory
+--R RCAGG    RecursiveAggregate           RCFIELD  RealClosedField
+--R REAL     RealConstant                 RETRACT  RetractableTo
+--R RING     Ring                         RMATCAT  RectangularMatrixCategory
+--R RMODULE  RightModule                  RNG      Rng
+--R RNS      RealNumberSystem             RPOLCAT  RecursivePolynomialCategory
+--R RRCC     RealRootCharacterizationCategory
+--R RSETCAT  RegularTriangularSetCategory SEGCAT   SegmentCategory
+--R SEGXCAT  SegmentExpansionCategory     SETAGG   SetAggregate
+--R SETCAT   SetCategory                  SEXCAT   SExpressionCategory
+--R SFRTCAT  SquareFreeRegularTriangularSetCategory
+--R SGROUP   SemiGroup                    SKAGG    StackAggregate
+--R SMATCAT  SquareMatrixCategory
+--R SNTSCAT  SquareFreeNormalizedTriangularSetCategory
+--R SPACEC   ThreeSpaceCategory           SPFCAT   SpecialFunctionCategory
+--R SRAGG    StringAggregate              STAGG    StreamAggregate
+--R STEP     StepThrough                  STRICAT  StringCategory
+--R TBAGG    TableAggregate
+--R TRANFUN  TranscendentalFunctionCategory
+--R TRIGCAT  TrigonometricFunctionCategory
+--R TSETCAT  TriangularSetCategory        TYPE     Type
+--R UFD      UniqueFactorizationDomain
+--R ULSCAT   UnivariateLaurentSeriesCategory
+--R ULSCCAT  UnivariateLaurentSeriesConstructorCategory
+--R UPOLYC   UnivariatePolynomialCategory
+--R UPSCAT   UnivariatePowerSeriesCategory
+--R UPXSCAT  UnivariatePuiseuxSeriesCategory
+--R UPXSCCA  UnivariatePuiseuxSeriesConstructorCategory
+--R URAGG    UnaryRecursiveAggregate
+--R UTSCAT   UnivariateTaylorSeriesCategory
+--R VECTCAT  VectorCategory               VSPACE   VectorSpace
+--R XALG     XAlgebra                     XF       ExtensionField
+--R XFALG    XFreeAlgebra                 XPOLYC   XPolynomialsCat
+--E 13
+
+--S 14 of 15
+)what domains
+--R--------------------------------- Domains ---------------------------------
+--R A1AGG-   OneDimensionalArrayAggregate&
+--R ABELGRP- AbelianGroup&                ABELMON- AbelianMonoid&
+--R ABELSG-  AbelianSemiGroup&            ACF-     AlgebraicallyClosedField&
+--R ACFS-    AlgebraicallyClosedFunctionSpace&
+--R ACPLOT   PlaneAlgebraicCurvePlot      AGG-     Aggregate&
+--R ALGEBRA- Algebra&                     ALGFF    AlgebraicFunctionField
+--R ALGSC    AlgebraGivenByStructuralConstants
+--R ALIST    AssociationList              AMR-     AbelianMonoidRing&
+--R AN       AlgebraicNumber              ANON     AnonymousFunction
+--R ANTISYM  AntiSymm                     ANY      Any
+--R ARR2CAT- TwoDimensionalArrayCategory& ARRAY1   OneDimensionalArray
+--R ARRAY2   TwoDimensionalArray          ASP1     Asp1
+--R ASP10    Asp10                        ASP12    Asp12
+--R ASP19    Asp19                        ASP20    Asp20
+--R ASP24    Asp24                        ASP27    Asp27
+--R ASP28    Asp28                        ASP29    Asp29
+--R ASP30    Asp30                        ASP31    Asp31
+--R ASP33    Asp33                        ASP34    Asp34
+--R ASP35    Asp35                        ASP4     Asp4
+--R ASP41    Asp41                        ASP42    Asp42
+--R ASP49    Asp49                        ASP50    Asp50
+--R ASP55    Asp55                        ASP6     Asp6
+--R ASP7     Asp7                         ASP73    Asp73
+--R ASP74    Asp74                        ASP77    Asp77
+--R ASP78    Asp78                        ASP8     Asp8
+--R ASP80    Asp80                        ASP9     Asp9
+--R ASTACK   ArrayStack
+--R ATRIG-   ArcTrigonometricFunctionCategory&
+--R ATTRBUT  AttributeButtons             AUTOMOR  Automorphism
+--R BASTYPE- BasicType&                   BBTREE   BalancedBinaryTree
+--R BFUNCT   BasicFunctions               BGAGG-   BagAggregate&
+--R BINARY   BinaryExpansion              BINFILE  BinaryFile
+--R BITS     Bits                         BOOLEAN  Boolean
+--R BOP      BasicOperator                BPADIC   BalancedPAdicInteger
+--R BPADICRT BalancedPAdicRational        BRAGG-   BinaryRecursiveAggregate&
+--R BSTREE   BinarySearchTree             BTAGG-   BitAggregate&
+--R BTCAT-   BinaryTreeCategory&          BTOURN   BinaryTournament
+--R BTREE    BinaryTree                   CARD     CardinalNumber
+--R CARTEN   CartesianTensor              CCLASS   CharacterClass
+--R CHAR     Character                    CLAGG-   Collection&
+--R CLIF     CliffordAlgebra              COLOR    Color
+--R COMM     Commutator                   COMPCAT- ComplexCategory&
+--R COMPLEX  Complex                      COMPPROP SubSpaceComponentProperty
+--R CONTFRAC ContinuedFraction            D01AJFA  d01ajfAnnaType
+--R D01AKFA  d01akfAnnaType               D01ALFA  d01alfAnnaType
+--R D01AMFA  d01amfAnnaType               D01ANFA  d01anfAnnaType
+--R D01APFA  d01apfAnnaType               D01AQFA  d01aqfAnnaType
+--R D01ASFA  d01asfAnnaType               D01FCFA  d01fcfAnnaType
+--R D01GBFA  d01gbfAnnaType               D01TRNS  d01TransformFunctionType
+--R D02BBFA  d02bbfAnnaType               D02BHFA  d02bhfAnnaType
+--R D02CJFA  d02cjfAnnaType               D02EJFA  d02ejfAnnaType
+--R D03EEFA  d03eefAnnaType               D03FAFA  d03fafAnnaType
+--R DBASE    Database                     DECIMAL  DecimalExpansion
+--R DEQUEUE  Dequeue                      DERHAM   DeRhamComplex
+--R DFLOAT   DoubleFloat                  DHMATRIX DenavitHartenbergMatrix
+--R DIAGG-   Dictionary&                  DIFEXT-  DifferentialExtension&
+--R DIFRING- DifferentialRing&            DIOPS-   DictionaryOperations&
+--R DIRPCAT- DirectProductCategory&       DIRPROD  DirectProduct
+--R DIVRING- DivisionRing&                DLIST    DataList
+--R DMP      DistributedMultivariatePolynomial
+--R DPMM     DirectProductMatrixModule    DPMO     DirectProductModule
+--R DPOLCAT- DifferentialPolynomialCategory&
+--R DROPT    DrawOption
+--R DSMP     DifferentialSparseMultivariatePolynomial
+--R DVARCAT- DifferentialVariableCategory&
+--R E04DGFA  e04dgfAnnaType               E04FDFA  e04fdfAnnaType
+--R E04GCFA  e04gcfAnnaType               E04JAFA  e04jafAnnaType
+--R E04MBFA  e04mbfAnnaType               E04NAFA  e04nafAnnaType
+--R E04UCFA  e04ucfAnnaType               EAB      ExtAlgBasis
+--R EFULS    ElementaryFunctionsUnivariateLaurentSeries
+--R EFUPXS   ElementaryFunctionsUnivariatePuiseuxSeries
+--R ELAGG-   ExtensibleLinearAggregate&   ELEMFUN- ElementaryFunctionCategory&
+--R ELTAGG-  EltableAggregate&            EMR      EuclideanModularRing
+--R EQ       Equation                     EQTBL    EqTable
+--R ES-      ExpressionSpace&             EUCDOM-  EuclideanDomain&
+--R EVALAB-  Evalable&                    EXIT     Exit
+--R EXPEXPAN ExponentialExpansion         EXPR     Expression
+--R EXPUPXS  ExponentialOfUnivariatePuiseuxSeries
+--R FAGROUP  FreeAbelianGroup             FAMONOID FreeAbelianMonoid
+--R FAMR-    FiniteAbelianMonoidRing&     FARRAY   FlexibleArray
+--R FAXF-    FiniteAlgebraicExtensionField&
+--R FC       FortranCode                  FCOMP    FourierComponent
+--R FDIV     FiniteDivisor                FDIVCAT- FiniteDivisorCategory&
+--R FEVALAB- FullyEvalableOver&           FEXPR    FortranExpression
+--R FF       FiniteField                  FFCAT-   FunctionFieldCategory&
+--R FFCG     FiniteFieldCyclicGroup
+--R FFCGP    FiniteFieldCyclicGroupExtensionByPolynomial
+--R FFCGX    FiniteFieldCyclicGroupExtension
+--R FFIELDC- FiniteFieldCategory&         FFNB     FiniteFieldNormalBasis
+--R FFNBP    FiniteFieldNormalBasisExtensionByPolynomial
+--R FFNBX    FiniteFieldNormalBasisExtension
+--R FFP      FiniteFieldExtensionByPolynomial
+--R FFX      FiniteFieldExtension         FGROUP   FreeGroup
+--R FIELD-   Field&                       FILE     File
+--R FINAALG- FiniteRankNonAssociativeAlgebra&
+--R FINRALG- FiniteRankAlgebra&           FLAGG-   FiniteLinearAggregate&
+--R FLINEXP- FullyLinearlyExplicitRingOver&
+--R FLOAT    Float                        FM       FreeModule
+--R FM1      FreeModule1                  FMONOID  FreeMonoid
+--R FNAME    FileName                     FNLA     FreeNilpotentLie
+--R FORMULA  ScriptFormulaFormat          FORTRAN  FortranProgram
+--R FPARFRAC FullPartialFractionExpansion FPC-     FieldOfPrimeCharacteristic&
+--R FPS-     FloatingPointSystem&         FR       Factored
+--R FRAC     Fraction                     FRAMALG- FramedAlgebra&
+--R FRETRCT- FullyRetractableTo&          FRIDEAL  FractionalIdeal
+--R FRMOD    FramedModule                 FRNAALG- FramedNonAssociativeAlgebra&
+--R FS-      FunctionSpace&               FSAGG-   FiniteSetAggregate&
+--R FSERIES  FourierSeries                FST      FortranScalarType
+--R FT       FortranType                  FTEM     FortranTemplate
+--R FUNCTION FunctionCalled               GCDDOM-  GcdDomain&
+--R GCNAALG  GenericNonAssociativeAlgebra
+--R GDMP     GeneralDistributedMultivariatePolynomial
+--R GMODPOL  GeneralModulePolynomial      GOPT     GuessOption
+--R GOPT0    GuessOptionFunctions0        GPOLSET  GeneralPolynomialSet
+--R GRALG-   GradedAlgebra&               GRIMAGE  GraphImage
+--R GRMOD-   GradedModule&                GROUP-   Group&
+--R GSERIES  GeneralUnivariatePowerSeries GSTBL    GeneralSparseTable
+--R GTSET    GeneralTriangularSet         HACKPI   Pi
+--R HASHTBL  HashTable
+--R HDMP     HomogeneousDistributedMultivariatePolynomial
+--R HDP      HomogeneousDirectProduct     HEAP     Heap
+--R HELLFDIV HyperellipticFiniteDivisor   HEXADEC  HexadecimalExpansion
+--R HOAGG-   HomogeneousAggregate&        HYPCAT-  HyperbolicFunctionCategory&
+--R IAN      InnerAlgebraicNumber         IARRAY1  IndexedOneDimensionalArray
+--R IARRAY2  IndexedTwoDimensionalArray   IBITS    IndexedBits
+--R ICARD    IndexCard                    IDEAL    PolynomialIdeals
+--R IDPAG    IndexedDirectProductAbelianGroup
+--R IDPAM    IndexedDirectProductAbelianMonoid
+--R IDPO     IndexedDirectProductObject
+--R IDPOAM   IndexedDirectProductOrderedAbelianMonoid
+--R IDPOAMS  IndexedDirectProductOrderedAbelianMonoidSup
+--R IEVALAB- InnerEvalable&               IFAMON   InnerFreeAbelianMonoid
+--R IFARRAY  IndexedFlexibleArray         IFF      InnerFiniteField
+--R IIARRAY2 InnerIndexedTwoDimensionalArray
+--R ILIST    IndexedList                  IMATRIX  IndexedMatrix
+--R INDE     IndexedExponents             INFORM   InputForm
+--R INS-     IntegerNumberSystem&         INT      Integer
+--R INTABL   InnerTable                   INTDOM-  IntegralDomain&
+--R INTFTBL  IntegrationFunctionsTable    INTRVL   Interval
+--R IPADIC   InnerPAdicInteger            IPF      InnerPrimeField
+--R IR       IntegrationResult            ISTRING  IndexedString
+--R ISUPS    InnerSparseUnivariatePowerSeries
+--R ITAYLOR  InnerTaylorSeries            ITUPLE   InfiniteTuple
+--R IVECTOR  IndexedVector                IXAGG-   IndexedAggregate&
+--R JORDAN   AssociatedJordanAlgebra      KAFILE   KeyedAccessFile
+--R KDAGG-   KeyedDictionary&             KERNEL   Kernel
+--R LA       LocalAlgebra                 LALG-    LeftAlgebra&
+--R LAUPOL   LaurentPolynomial            LEXP     LieExponentials
+--R LIB      Library                      LIE      AssociatedLieAlgebra
+--R LIECAT-  LieAlgebra&                  LIST     List
+--R LMDICT   ListMultiDictionary          LMOPS    ListMonoidOps
+--R LNAGG-   LinearAggregate&             LO       Localize
+--R LODO     LinearOrdinaryDifferentialOperator
+--R LODO1    LinearOrdinaryDifferentialOperator1
+--R LODO2    LinearOrdinaryDifferentialOperator2
+--R LODOCAT- LinearOrdinaryDifferentialOperatorCategory&
+--R LOGIC-   Logic&                       LPOLY    LiePolynomial
+--R LSAGG-   ListAggregate&               LSQM     LieSquareMatrix
+--R LWORD    LyndonWord                   LZSTAGG- LazyStreamAggregate&
+--R M3D      ThreeDimensionalMatrix       MAGMA    Magma
+--R MATCAT-  MatrixCategory&              MATRIX   Matrix
+--R MCMPLX   MachineComplex               MFLOAT   MachineFloat
+--R MINT     MachineInteger               MKCHSET  MakeCachableSet
+--R MMLFORM  MathMLFormat                 MODFIELD ModularField
+--R MODMON   ModMonic                     MODMONOM ModuleMonomial
+--R MODOP    ModuleOperator               MODRING  ModularRing
+--R MODULE-  Module&                      MOEBIUS  MoebiusTransform
+--R MONAD-   Monad&                       MONADWU- MonadWithUnit&
+--R MONOGEN- MonogenicAlgebra&            MONOID-  Monoid&
+--R MPOLY    MultivariatePolynomial       MRING    MonoidRing
+--R MSET     Multiset                     MYEXPR   MyExpression
+--R MYUP     MyUnivariatePolynomial       NAALG-   NonAssociativeAlgebra&
+--R NARNG-   NonAssociativeRng&           NASRING- NonAssociativeRing&
+--R       Enumeration                           Mapping
+--R       Record                                Union
+--R NIPROB   NumericalIntegrationProblem  NNI      NonNegativeInteger
+--R NONE     None                         NOTTING  NottinghamGroup
+--R NSMP     NewSparseMultivariatePolynomial
+--R NSUP     NewSparseUnivariatePolynomial
+--R OC-      OctonionCategory&            OCT      Octonion
+--R ODEIFTBL ODEIntensityFunctionsTable   ODEPROB  NumericalODEProblem
+--R ODP      OrderedDirectProduct
+--R ODPOL    OrderlyDifferentialPolynomial
+--R ODR      OrdinaryDifferentialRing     ODVAR    OrderlyDifferentialVariable
+--R OFMONOID OrderedFreeMonoid            OMCONN   OpenMathConnection
+--R OMDEV    OpenMathDevice               OMENC    OpenMathEncoding
+--R OMERR    OpenMathError                OMERRK   OpenMathErrorKind
+--R OMLO     OppositeMonogenicLinearOperator
+--R ONECOMP  OnePointCompletion           OP       Operator
+--R OPTPROB  NumericalOptimizationProblem ORDCOMP  OrderedCompletion
+--R ORDRING- OrderedRing&                 ORDSET-  OrderedSet&
+--R OREPCAT- UnivariateSkewPolynomialCategory&
+--R ORESUP   SparseUnivariateSkewPolynomial
+--R OREUP    UnivariateSkewPolynomial     OSI      OrdSetInts
+--R OUTFORM  OutputForm                   OVAR     OrderedVariableList
+--R OWP      OrdinaryWeightedPolynomials  PADIC    PAdicInteger
+--R PADICRAT PAdicRational                PADICRC  PAdicRationalConstructor
+--R PALETTE  Palette                      PARPCURV ParametricPlaneCurve
+--R PARSCURV ParametricSpaceCurve         PARSURF  ParametricSurface
+--R PATLRES  PatternMatchListResult       PATRES   PatternMatchResult
+--R PATTERN  Pattern
+--R PBWLB    PoincareBirkhoffWittLyndonBasis
+--R PDEPROB  NumericalPDEProblem          PDRING-  PartialDifferentialRing&
+--R PENDTREE PendantTree                  PERM     Permutation
+--R PERMGRP  PermutationGroup             PF       PrimeField
+--R PFECAT-  PolynomialFactorizationExplicit&
+--R PFR      PartialFraction              PI       PositiveInteger
+--R PLOT     Plot                         PLOT3D   Plot3D
+--R POINT    Point                        POLY     Polynomial
+--R POLYCAT- PolynomialCategory&          PR       PolynomialRing
+--R PRIMARR  PrimitiveArray               PRODUCT  Product
+--R PRTITION Partition                    PSCAT-   PowerSeriesCategory&
+--R PSETCAT- PolynomialSetCategory&       QALGSET  QuasiAlgebraicSet
+--R QEQUAT   QueryEquation                QFCAT-   QuotientFieldCategory&
+--R QFORM    QuadraticForm                QUAT     Quaternion
+--R QUATCAT- QuaternionCategory&          QUEUE    Queue
+--R RADCAT-  RadicalCategory&             RADFF    RadicalFunctionField
+--R RADIX    RadixExpansion               RCAGG-   RecursiveAggregate&
+--R RCFIELD- RealClosedField&             RECLOS   RealClosure
+--R REF      Reference                    REGSET   RegularTriangularSet
+--R RESRING  ResidueRing                  RESULT   Result
+--R RETRACT- RetractableTo&               RGCHAIN  RegularChain
+--R RING-    Ring&                        RMATCAT- RectangularMatrixCategory&
+--R RMATRIX  RectangularMatrix            RNS-     RealNumberSystem&
+--R ROIRC    RightOpenIntervalRootCharacterization
+--R ROMAN    RomanNumeral                 ROUTINE  RoutinesTable
+--R RPOLCAT- RecursivePolynomialCategory&
+--R RRCC-    RealRootCharacterizationCategory&
+--R RSETCAT- RegularTriangularSetCategory&
+--R RULE     RewriteRule                  RULECOLD RuleCalled
+--R RULESET  Ruleset                      SAE      SimpleAlgebraicExtension
+--R SAOS     SingletonAsOrderedSet
+--R SDPOL    SequentialDifferentialPolynomial
+--R SDVAR    SequentialDifferentialVariable
+--R SEG      Segment                      SEGBIND  SegmentBinding
+--R SET      Set                          SETAGG-  SetAggregate&
+--R SETCAT-  SetCategory&                 SETMN    SetOfMIntegersInOneToN
+--R SEX      SExpression                  SEXOF    SExpressionOf
+--R SFORT    SimpleFortranProgram         SGROUP-  SemiGroup&
+--R SHDP     SplitHomogeneousDirectProduct
+--R SINT     SingleInteger                SMATCAT- SquareMatrixCategory&
+--R SMP      SparseMultivariatePolynomial
+--R SMTS     SparseMultivariateTaylorSeries
+--R SPACE3   ThreeSpace                   SPLNODE  SplittingNode
+--R SPLTREE  SplittingTree                SQMATRIX SquareMatrix
+--R SRAGG-   StringAggregate&
+--R SREGSET  SquareFreeRegularTriangularSet
+--R STACK    Stack                        STAGG-   StreamAggregate&
+--R STBL     SparseTable                  STREAM   Stream
+--R STRING   String                       STRTBL   StringTable
+--R SUBSPACE SubSpace                     SUCH     SuchThat
+--R SULS     SparseUnivariateLaurentSeries
+--R SUP      SparseUnivariatePolynomial
+--R SUPEXPR  SparseUnivariatePolynomialExpressions
+--R SUPXS    SparseUnivariatePuiseuxSeries
+--R SUTS     SparseUnivariateTaylorSeries SWITCH   Switch
+--R SYMBOL   Symbol                       SYMPOLY  SymmetricPolynomial
+--R SYMS     TheSymbolTable               SYMTAB   SymbolTable
+--R TABLE    Table                        TABLEAU  Tableau
+--R TBAGG-   TableAggregate&              TEX      TexFormat
+--R TEXTFILE TextFile
+--R TRANFUN- TranscendentalFunctionCategory&
+--R TREE     Tree
+--R TRIGCAT- TrigonometricFunctionCategory&
+--R TS       TaylorSeries                 TSETCAT- TriangularSetCategory&
+--R TUBE     TubePlot                     TUPLE    Tuple
+--R UFD-     UniqueFactorizationDomain&   UFPS     UnivariateFormalPowerSeries
+--R ULS      UnivariateLaurentSeries
+--R ULSCCAT- UnivariateLaurentSeriesConstructorCategory&
+--R ULSCONS  UnivariateLaurentSeriesConstructor
+--R UNISEG   UniversalSegment             UP       UnivariatePolynomial
+--R UPOLYC-  UnivariatePolynomialCategory&
+--R UPSCAT-  UnivariatePowerSeriesCategory&
+--R UPXS     UnivariatePuiseuxSeries
+--R UPXSCCA- UnivariatePuiseuxSeriesConstructorCategory&
+--R UPXSCONS UnivariatePuiseuxSeriesConstructor
+--R UPXSSING UnivariatePuiseuxSeriesWithExponentialSingularity
+--R URAGG-   UnaryRecursiveAggregate&     UTS      UnivariateTaylorSeries
+--R UTSCAT-  UnivariateTaylorSeriesCategory&
+--R VARIABLE Variable                     VECTCAT- VectorCategory&
+--R VECTOR   Vector                       VIEW2D   TwoDimensionalViewport
+--R VIEW3D   ThreeDimensionalViewport     VOID     Void
+--R VSPACE-  VectorSpace&                 WP       WeightedPolynomials
+--R WUTSET   WuWenTsunTriangularSet       XDPOLY   XDistributedPolynomial
+--R XF-      ExtensionField&              XPBWPOLY XPBWPolynomial
+--R XPOLY    XPolynomial                  XPR      XPolynomialRing
+--R XRPOLY   XRecursivePolynomial         ZMOD     IntegerMod
+--E 14
+
+--S 15 of 15
+)what packages
+--R-------------------------------- Packages ---------------------------------
+--R AF       AlgebraicFunction            ALGFACT  AlgFactor
+--R ALGMANIP AlgebraicManipulations       ALGMFACT AlgebraicMultFact
+--R ALGPKG   AlgebraPackage               ANY1     AnyFunctions1
+--R API      ApplicationProgramInterface
+--R APPLYORE ApplyUnivariateSkewPolynomial
+--R APPRULE  ApplyRules
+--R ARRAY12  OneDimensionalArrayFunctions2
+--R ASSOCEQ  AssociatedEquations          AXSERV   AxiomServer
+--R BALFACT  BalancedFactorisation        BEZOUT   BezoutMatrix
+--R BOP1     BasicOperatorFunctions1      BOUNDZRO BoundIntegerRoots
+--R BRILL    BrillhartTests               CARTEN2  CartesianTensorFunctions2
+--R CDEN     CommonDenominator
+--R CHARPOL  CharacteristicPolynomialPackage
+--R CHVAR    ChangeOfVariable
+--R CINTSLPE ComplexIntegerSolveLinearPolynomialEquation
+--R CLIP     TwoDimensionalPlotClipping   CMPLXRT  ComplexRootPackage
+--R COMBF    CombinatorialFunction        COMBINAT IntegerCombinatoricFunctions
+--R COMMONOP CommonOperators
+--R COMMUPC  CommuteUnivariatePolynomialCategory
+--R COMPFACT ComplexFactorization         COMPLEX2 ComplexFunctions2
+--R COMPLPAT ComplexPattern               COORDSYS CoordinateSystems
+--R CPIMA    CharacteristicPolynomialInMonogenicalAlgebra
+--R CPMATCH  ComplexPatternMatch          CRAPACK  CRApackage
+--R CRFP     ComplexRootFindingPackage    CSTTOOLS CyclicStreamTools
+--R CTRIGMNP ComplexTrigonometricManipulations
+--R CVMP     CoerceVectorMatrixPackage    CYCLES   CycleIndicators
+--R CYCLOTOM CyclotomicPolynomialPackage  D01AGNT  d01AgentsPackage
+--R D01WGTS  d01WeightsPackage            D02AGNT  d02AgentsPackage
+--R D03AGNT  d03AgentsPackage             DBLRESP  DoubleResultantPackage
+--R DDFACT   DistinctDegreeFactorize
+--R DEFINTEF ElementaryFunctionDefiniteIntegration
+--R DEFINTRF RationalFunctionDefiniteIntegration
+--R DEGRED   DegreeReductionPackage       DFINTTLS DefiniteIntegrationTools
+--R DFSFUN   DoubleFloatSpecialFunctions  DIOSP    DiophantineSolutionPackage
+--R DIRPROD2 DirectProductFunctions2      DISPLAY  DisplayPackage
+--R DLP      DiscreteLogarithmPackage     DRAW     TopLevelDrawFunctions
+--R DRAWCFUN TopLevelDrawFunctionsForCompiledFunctions
+--R DRAWCURV TopLevelDrawFunctionsForAlgebraicCurves
+--R DRAWCX   DrawComplex                  DRAWHACK DrawNumericHack
+--R DRAWPT   TopLevelDrawFunctionsForPoints
+--R DROPT0   DrawOptionFunctions0         DROPT1   DrawOptionFunctions1
+--R E04AGNT  e04AgentsPackage             EF       ElementaryFunction
+--R EFSTRUC  ElementaryFunctionStructurePackage
+--R ELFUTS   EllipticFunctionsUnivariateTaylorSeries
+--R EP       EigenPackage                 EQ2      EquationFunctions2
+--R ERROR    ErrorFunctions               ES1      ExpressionSpaceFunctions1
+--R ES2      ExpressionSpaceFunctions2
+--R ESCONT   ExpertSystemContinuityPackage
+--R ESCONT1  ExpertSystemContinuityPackage1
+--R ESTOOLS  ExpertSystemToolsPackage     ESTOOLS1 ExpertSystemToolsPackage1
+--R ESTOOLS2 ExpertSystemToolsPackage2    EVALCYC  EvaluateCycleIndicators
+--R EXPR2    ExpressionFunctions2
+--R EXPR2UPS ExpressionToUnivariatePowerSeries
+--R EXPRODE  ExpressionSpaceODESolver     EXPRSOL  ExpressionSolve
+--R EXPRTUBE ExpressionTubePlot           FACTFUNC FactoredFunctions
+--R FACUTIL  FactoringUtilities
+--R FAMR2    FiniteAbelianMonoidRingFunctions2
+--R FCPAK1   FortranCodePackage1          FDIV2    FiniteDivisorFunctions2
+--R FFCAT2   FunctionFieldCategoryFunctions2
+--R FFF      FiniteFieldFunctions         FFFG     FractionFreeFastGaussian
+--R FFFGF    FractionFreeFastGaussianFractions
+--R FFHOM    FiniteFieldHomomorphisms     FFINTBAS FunctionFieldIntegralBasis
+--R FFPOLY   FiniteFieldPolynomialPackage
+--R FFPOLY2  FiniteFieldPolynomialPackage2
+--R FFSLPE   FiniteFieldSolveLinearPolynomialEquation
+--R FGLMICPK FGLMIfCanPackage
+--R FLAGG2   FiniteLinearAggregateFunctions2
+--R FLASORT  FiniteLinearAggregateSort    FLOATCP  FloatingComplexPackage
+--R FLOATRP  FloatingRealPackage          FOP      FortranOutputStackPackage
+--R FORDER   FindOrderFinite              FORMULA1 ScriptFormulaFormat1
+--R FORT     FortranPackage               FR2      FactoredFunctions2
+--R FRAC2    FractionFunctions2           FRIDEAL2 FractionalIdealFunctions2
+--R FRNAAF2  FramedNonAssociativeAlgebraFunctions2
+--R FRUTIL   FactoredFunctionUtilities    FS2      FunctionSpaceFunctions2
+--R FS2EXPXP FunctionSpaceToExponentialExpansion
+--R FS2UPS   FunctionSpaceToUnivariatePowerSeries
+--R FSAGG2   FiniteSetAggregateFunctions2
+--R FSCINT   FunctionSpaceComplexIntegration
+--R FSINT    FunctionSpaceIntegration     FSPECF   FunctionalSpecialFunction
+--R FSPRMELT FunctionSpacePrimitiveElement
+--R FSRED    FunctionSpaceReduce
+--R FSUPFACT FunctionSpaceUnivariatePolynomialFactor
+--R GALFACT  GaloisGroupFactorizer
+--R GALFACTU GaloisGroupFactorizationUtilities
+--R GALPOLYU GaloisGroupPolynomialUtilities
+--R GALUTIL  GaloisGroupUtilities         GAUSSFAC GaussianFactorizationPackage
+--R GB       GroebnerPackage
+--R GBEUCLID EuclideanGroebnerBasisPackage
+--R GBF      GroebnerFactorizationPackage GBINTERN GroebnerInternalPackage
+--R GENEEZ   GenExEuclid
+--R GENMFACT GeneralizedMultivariateFactorize
+--R GENPGCD  GeneralPolynomialGcdPackage  GENUFACT GenUFactorize
+--R GENUPS   GenerateUnivariatePowerSeries
+--R GHENSEL  GeneralHenselPackage         GOSPER   GosperSummationMethod
+--R GRAY     GrayCode                     GRDEF    GraphicsDefaults
+--R GROEBSOL GroebnerSolve                GUESS    Guess
+--R GUESSAN  GuessAlgebraicNumber         GUESSF   GuessFinite
+--R GUESSF1  GuessFiniteFunctions         GUESSINT GuessInteger
+--R GUESSP   GuessPolynomial              GUESSUP  GuessUnivariatePolynomial
+--R HB       HallBasis                    HEUGCD   HeuGcd
+--R IALGFACT InnerAlgFactor
+--R IBACHIN  ChineseRemainderToolsForIntegralBases
+--R IBATOOL  IntegralBasisTools           IBPTOOLS IntegralBasisPolynomialTools
+--R ICDEN    InnerCommonDenominator       IDECOMP  IdealDecompositionPackage
+--R IMATLIN  InnerMatrixLinearAlgebraFunctions
+--R IMATQF   InnerMatrixQuotientFieldFunctions
+--R INBFF    InnerNormalBasisFieldFunctions
+--R INCRMAPS IncrementingMaps             INEP     InnerNumericEigenPackage
+--R INFINITY Infinity                     INFORM1  InputFormFunctions1
+--R INFPROD0 InfiniteProductCharacteristicZero
+--R INFSP    InnerNumericFloatSolvePackage
+--R INMODGCD InnerModularGcd              INNMFACT InnerMultFact
+--R INPRODFF InfiniteProductFiniteField   INPRODPF InfiniteProductPrimeField
+--R INPSIGN  InnerPolySign                INTAF    AlgebraicIntegration
+--R INTALG   AlgebraicIntegrate           INTBIT   IntegerBits
+--R INTEF    ElementaryIntegration        INTFACT  IntegerFactorizationPackage
+--R INTG0    GenusZeroIntegration         INTHEORY IntegerNumberTheoryFunctions
+--R INTHERAL AlgebraicHermiteIntegration
+--R INTHERTR TranscendentalHermiteIntegration
+--R INTPACK  AnnaNumericalIntegrationPackage
+--R INTPAF   PureAlgebraicIntegration     INTPM    PatternMatchIntegration
+--R INTRAT   RationalIntegration          INTRET   IntegerRetractions
+--R INTRF    RationalFunctionIntegration
+--R INTSLPE  IntegerSolveLinearPolynomialEquation
+--R INTTOOLS IntegrationTools             INTTR    TranscendentalIntegration
+--R INVLAPLA InverseLaplaceTransform      IPRNTPK  InternalPrintPackage
+--R IR2      IntegrationResultFunctions2  IR2F     IntegrationResultToFunction
+--R IROOT    IntegerRoots                 IRREDFFX IrredPolyOverFiniteField
+--R IRRF2F   IntegrationResultRFToFunction
+--R IRSN     IrrRepSymNatPackage
+--R IRURPK   InternalRationalUnivariateRepresentationPackage
+--R ISUMP    InnerPolySum                 ITFUN2   InfiniteTupleFunctions2
+--R ITFUN3   InfiniteTupleFunctions3
+--R ITRIGMNP InnerTrigonometricManipulations
+--R KERNEL2  KernelFunctions2             KOVACIC  Kovacic
+--R LAPLACE  LaplaceTransform             LAZM3PK  LazardSetSolvingPackage
+--R LEADCDET LeadingCoefDetermination     LEXTRIPK LexTriangularPackage
+--R LF       LiouvillianFunction          LGROBP   LinGroebnerPackage
+--R LIMITPS  PowerSeriesLimitPackage      LIMITRF  RationalFunctionLimitPackage
+--R LINDEP   LinearDependence             LIST2    ListFunctions2
+--R LIST2MAP ListToMap                    LIST3    ListFunctions3
+--R LODEEF   ElementaryFunctionLODESolver
+--R LODOF    LinearOrdinaryDifferentialOperatorFactorizer
+--R LODOOPS  LinearOrdinaryDifferentialOperatorsOps
+--R LPEFRAC  LinearPolynomialEquationByFractions
+--R LSMP     LinearSystemMatrixPackage    LSMP1    LinearSystemMatrixPackage1
+--R LSPP     LinearSystemPolynomialPackage
+--R MAPHACK1 MappingPackageInternalHacks1 MAPHACK2 MappingPackageInternalHacks2
+--R MAPHACK3 MappingPackageInternalHacks3 MAPPKG1  MappingPackage1
+--R MAPPKG2  MappingPackage2              MAPPKG3  MappingPackage3
+--R MAPPKG4  MappingPackage4              MATCAT2  MatrixCategoryFunctions2
+--R MATLIN   MatrixLinearAlgebraFunctions
+--R MATSTOR  StorageEfficientMatrixOperations
+--R MCALCFN  MultiVariableCalculusFunctions
+--R MCDEN    MatrixCommonDenominator
+--R MDDFACT  ModularDistinctDegreeFactorizer
+--R MESH     MeshCreationRoutinesForThreeDimensions
+--R MFINFACT MultFiniteFactorize          MHROWRED ModularHermitianRowReduction
+--R MKBCFUNC MakeBinaryCompiledFunction   MKFLCFN  MakeFloatCompiledFunction
+--R MKFUNC   MakeFunction                 MKRECORD MakeRecord
+--R MKUCFUNC MakeUnaryCompiledFunction    MLIFT    MultivariateLifting
+--R MMAP     MultipleMap                  MONOTOOL MonomialExtensionTools
+--R MPC2     MPolyCatFunctions2           MPC3     MPolyCatFunctions3
+--R MPCPF    MPolyCatPolyFactorizer
+--R MPRFF    MPolyCatRationalFunctionFactorizer
+--R MRATFAC  MRationalFactorize           MRF2     MonoidRingFunctions2
+--R MSYSCMD  MoreSystemCommands           MTHING   MergeThing
+--R MULTFACT MultivariateFactorize        MULTSQFR MultivariateSquareFree
+--R NAGC02   NagPolynomialRootsPackage    NAGC05   NagRootFindingPackage
+--R NAGC06   NagSeriesSummationPackage    NAGD01   NagIntegrationPackage
+--R NAGD02   NagOrdinaryDifferentialEquationsPackage
+--R NAGD03   NagPartialDifferentialEquationsPackage
+--R NAGE01   NagInterpolationPackage      NAGE02   NagFittingPackage
+--R NAGE04   NagOptimisationPackage       NAGF01   NagMatrixOperationsPackage
+--R NAGF02   NagEigenPackage
+--R NAGF04   NagLinearEquationSolvingPackage
+--R NAGF07   NagLapack                    NAGS     NagSpecialFunctionsPackage
+--R NAGSP    NAGLinkSupportPackage        NCEP     NumericComplexEigenPackage
+--R NCNTFRAC NumericContinuedFraction
+--R NCODIV   NonCommutativeOperatorDivision
+--R NEWTON   NewtonInterpolation          NFINTBAS NumberFieldIntegralBasis
+--R NLINSOL  NonLinearSolvePackage        NODE1    NonLinearFirstOrderODESolver
+--R NONE1    NoneFunctions1               NORMMA   NormInMonogenicAlgebra
+--R NORMPK   NormalizationPackage         NORMRETR NormRetractPackage
+--R NPCOEF   NPCoef                       NREP     NumericRealEigenPackage
+--R NSUP2    NewSparseUnivariatePolynomialFunctions2
+--R NTPOLFN  NumberTheoreticPolynomialFunctions
+--R NUMERIC  Numeric                      NUMFMT   NumberFormats
+--R NUMODE   NumericalOrdinaryDifferentialEquations
+--R NUMQUAD  NumericalQuadrature          NUMTUBE  NumericTubePlot
+--R OCTCT2   OctonionCategoryFunctions2   ODECONST ConstantLODE
+--R ODEEF    ElementaryFunctionODESolver  ODEINT   ODEIntegration
+--R ODEPACK  AnnaOrdinaryDifferentialEquationPackage
+--R ODEPAL   PureAlgebraicLODE            ODEPRIM  PrimitiveRatDE
+--R ODEPRRIC PrimitiveRatRicDE            ODERAT   RationalLODE
+--R ODERED   ReduceLODE                   ODERTRIC RationalRicDE
+--R ODESYS   SystemODESolver              ODETOOLS ODETools
+--R OMEXPR   ExpressionToOpenMath         OMPKG    OpenMathPackage
+--R OMSERVER OpenMathServerPackage        ONECOMP2 OnePointCompletionFunctions2
+--R OPQUERY  OperationsQuery
+--R OPTPACK  AnnaNumericalOptimizationPackage
+--R ORDCOMP2 OrderedCompletionFunctions2  ORDFUNS  OrderingFunctions
+--R OREPCTO  UnivariateSkewPolynomialCategoryOps
+--R ORTHPOL  OrthogonalPolynomialFunctions
+--R OUT      OutputPackage                PADE     PadeApproximants
+--R PADEPAC  PadeApproximantPackage       PAN2EXPR PolynomialAN2Expression
+--R PARPC2   ParametricPlaneCurveFunctions2
+--R PARSC2   ParametricSpaceCurveFunctions2
+--R PARSU2   ParametricSurfaceFunctions2  PARTPERM PartitionsAndPermutations
+--R PATMATCH PatternMatch                 PATRES2  PatternMatchResultFunctions2
+--R PATTERN1 PatternFunctions1            PATTERN2 PatternFunctions2
+--R PCOMP    PolynomialComposition        PDECOMP  PolynomialDecomposition
+--R PDEPACK  AnnaPartialDifferentialEquationPackage
+--R PERMAN   Permanent
+--R PFBR     PolynomialFactorizationByRecursion
+--R PFBRU    PolynomialFactorizationByRecursionUnivariate
+--R PFO      PointsOfFiniteOrder          PFOQ     PointsOfFiniteOrderRational
+--R PFOTOOLS PointsOfFiniteOrderTools     PFRPAC   PartialFractionPackage
+--R PGCD     PolynomialGcdPackage         PGE      PermutationGroupExamples
+--R PGROEB   PolyGroebner                 PICOERCE PiCoercions
+--R PINTERP  PolynomialInterpolation
+--R PINTERPA PolynomialInterpolationAlgorithms
+--R PLEQN    ParametricLinearEquations    PLOT1    PlotFunctions1
+--R PLOTTOOL PlotTools                    PMASS    PatternMatchAssertions
+--R PMASSFS  FunctionSpaceAssertions      PMDOWN   PatternMatchPushDown
+--R PMFS     PatternMatchFunctionSpace
+--R PMINS    PatternMatchIntegerNumberSystem
+--R PMKERNEL PatternMatchKernel           PMLSAGG  PatternMatchListAggregate
+--R PMPLCAT  PatternMatchPolynomialCategory
+--R PMPRED   AttachPredicates
+--R PMPREDFS FunctionSpaceAttachPredicates
+--R PMQFCAT  PatternMatchQuotientFieldCategory
+--R PMSYM    PatternMatchSymbol           PMTOOLS  PatternMatchTools
+--R PNTHEORY PolynomialNumberTheoryFunctions
+--R POLTOPOL PolToPol
+--R POLUTIL  RealPolynomialUtilitiesPackage
+--R POLY2    PolynomialFunctions2
+--R POLY2UP  PolynomialToUnivariatePolynomial
+--R POLYCATQ PolynomialCategoryQuotientFunctions
+--R POLYLIFT PolynomialCategoryLifting    POLYROOT PolynomialRoots
+--R PREASSOC PrecomputedAssociatedEquations
+--R PRIMARR2 PrimitiveArrayFunctions2     PRIMELT  PrimitiveElement
+--R PRIMES   IntegerPrimesPackage         PRINT    PrintPackage
+--R PRS      PseudoRemainderSequence
+--R PSETPK   PolynomialSetUtilitiesPackage
+--R PSEUDLIN PseudoLinearNormalForm       PSQFR    PolynomialSquareFree
+--R PTFUNC2  PointFunctions2              PTPACK   PointPackage
+--R PUSHVAR  PushVariables
+--R PWFFINTB PAdicWildFunctionFieldIntegralBasis
+--R QALGSET2 QuasiAlgebraicSet2           QCMPACK  QuasiComponentPackage
+--R QFCAT2   QuotientFieldCategoryFunctions2
+--R QUATCT2  QuaternionCategoryFunctions2 RADUTIL  RadixUtilities
+--R RANDSRC  RandomNumberSource           RATFACT  RationalFactorize
+--R RATRET   RationalRetractions          RDEEF    ElementaryRischDE
+--R RDEEFS   ElementaryRischDESystem      RDETR    TranscendentalRischDE
+--R RDETRS   TranscendentalRischDESystem  RDIST    RandomDistributions
+--R RDIV     ReducedDivisor               REAL0    RealZeroPackage
+--R REAL0Q   RealZeroPackageQ             REALSOLV RealSolvePackage
+--R RECOP    RecurrenceOperator           REDORDER ReductionOfOrder
+--R REP      RadicalEigenPackage          REP1     RepresentationPackage1
+--R REP2     RepresentationPackage2       REPDB    RepeatedDoubling
+--R REPSQ    RepeatedSquaring             RESLATC  ResolveLatticeCompletion
+--R RETSOL   RetractSolvePackage          RF       RationalFunction
+--R RFDIST   RandomFloatDistributions     RFFACT   RationalFunctionFactor
+--R RFFACTOR RationalFunctionFactorizer   RIDIST   RandomIntegerDistributions
+--R RINTERP  RationalInterpolation
+--R RMCAT2   RectangularMatrixCategoryFunctions2
+--R RSDCMPK  RegularSetDecompositionPackage
+--R RSETGCD  RegularTriangularSetGcdPackage
+--R RURPK    RationalUnivariateRepresentationPackage
+--R SAEFACT  SimpleAlgebraicExtensionAlgFactor
+--R SAERFFC  SAERationalFunctionAlgFactor SCACHE   SortedCache
+--R SCPKG    StructuralConstantsPackage   SEG2     SegmentFunctions2
+--R SEGBIND2 SegmentBindingFunctions2
+--R SFQCMPK  SquareFreeQuasiComponentPackage
+--R SFRGCD   SquareFreeRegularTriangularSetGcdPackage
+--R SGCF     SymmetricGroupCombinatoricFunctions
+--R SHP      SturmHabichtPackage          SIGNEF   ElementaryFunctionSign
+--R SIGNRF   RationalFunctionSign
+--R SIMPAN   SimplifyAlgebraicNumberConvertPackage
+--R SMITH    SmithNormalForm              SOLVEFOR PolynomialSolveByFormulas
+--R SOLVERAD RadicalSolvePackage          SOLVESER TransSolvePackageService
+--R SOLVETRA TransSolvePackage            SORTPAK  SortPackage
+--R SPECOUT  SpecialOutputPackage
+--R SRDCMPK  SquareFreeRegularSetDecompositionPackage
+--R STINPROD StreamInfiniteProduct        STREAM1  StreamFunctions1
+--R STREAM2  StreamFunctions2             STREAM3  StreamFunctions3
+--R STTAYLOR StreamTaylorSeriesOperations
+--R STTF     StreamTranscendentalFunctions
+--R STTFNC   StreamTranscendentalFunctionsNonCommutative
+--R SUBRESP  SubResultantPackage          SUMFS    FunctionSpaceSum
+--R SUMRF    RationalFunctionSum
+--R SUP2     SparseUnivariatePolynomialFunctions2
+--R SUPFRACF SupFractionFactorizer        SYMFUNC  SymmetricFunctions
+--R SYSSOLP  SystemSolvePackage           TABLBUMP TableauxBumpers
+--R TANEXP   TangentExpansions            TBCMPPK  TabulatedComputationPackage
+--R TEMUTL   TemplateUtilities            TEX1     TexFormat1
+--R TOOLSIGN ToolsForSign                 TOPSP    TopLevelThreeSpace
+--R TRIGMNIP TrigonometricManipulations   TRIMAT   TriangularMatrixOperations
+--R TRMANIP  TranscendentalManipulations  TUBETOOL TubePlotTools
+--R TWOFACT  TwoFactorize                 UDPO     UserDefinedPartialOrdering
+--R UDVO     UserDefinedVariableOrdering
+--R UFPS1    UnivariateFormalPowerSeriesFunctions
+--R ULS2     UnivariateLaurentSeriesFunctions2
+--R UNIFACT  UnivariateFactorize          UNISEG2  UniversalSegmentFunctions2
+--R UP2      UnivariatePolynomialFunctions2
+--R UPCDEN   UnivariatePolynomialCommonDenominator
+--R UPDECOMP UnivariatePolynomialDecompositionPackage
+--R UPDIVP   UnivariatePolynomialDivisionPackage
+--R UPMP     UnivariatePolynomialMultiplicationPackage
+--R UPOLYC2  UnivariatePolynomialCategoryFunctions2
+--R UPSQFREE UnivariatePolynomialSquareFree
+--R UPXS2    UnivariatePuiseuxSeriesFunctions2
+--R UTS2     UnivariateTaylorSeriesFunctions2
+--R UTSODE   UnivariateTaylorSeriesODESolver
+--R UTSODETL UTSodetools                  UTSSOL   TaylorSolve
+--R VECTOR2  VectorFunctions2             VIEW     ViewportPackage
+--R VIEWDEF  ViewDefaultsPackage          WEIER    WeierstrassPreparation
+--R WFFINTBS WildFunctionFieldIntegralBasis
+--R XEXPPKG  XExponentialPackage
+--R YSTREAM  ParadoxicalCombinatorsForStreams
+--R ZDSOLVE  ZeroDimensionalSolvePackage  ZLINDEP  IntegerLinearDependence
+--E 15
+
+
+)spool 
+)lisp (bye)
+ 
+@
+\eject
+\begin{thebibliography}{99}
+\bibitem{1} nothing
+\end{thebibliography}
+\end{document}
+
diff --git a/src/input/setcmd.input.pamphlet b/src/input/setcmd.input.pamphlet
new file mode 100644
index 0000000..cc01582
--- /dev/null
+++ b/src/input/setcmd.input.pamphlet
@@ -0,0 +1,1409 @@
+\documentclass{article}
+\usepackage{axiom}
+\begin{document}
+\title{\$SPAD/src/input setcmd.input}
+\author{Timothy Daly}
+\maketitle
+\begin{abstract}
+\end{abstract}
+\eject
+\tableofcontents
+\eject
+<<*>>=
+)spool setcmd.output
+)set message test on
+)set message auto off
+)clear all
+ 
+--S 1 of 86
+)set breakmode
+--R-------------------------- The breakmode Option ---------------------------
+--R
+--R Description: execute break processing on error
+--R
+--R The breakmode option may be followed by any one of the following:
+--R
+--R -> nobreak 
+--R    break
+--R    query
+--R    resume
+--R    fastlinks
+--R
+--R The current setting is indicated.
+--R
+--E 1
+
+--S 2 of 86
+)set compiler
+--R                  Current Values of  compiler  Variables                   
+--R
+--RVariable     Description                                Current Value
+--R-----------------------------------------------------------------------------
+--Routput       library in which to place compiled code     
+--Rinput        controls libraries from which to load compiled code  
+--Rargs         arguments for compiling AXIOM code         -O -Fasy -Fao -Flsp -laxiom -Mno-AXL_W_WillObsolete -DAxiom -Y $AXIOM/algebra 
+--R
+--E 2
+
+--S 3 of 86
+)set compiler
+--R                  Current Values of  compiler  Variables                   
+--R
+--RVariable     Description                                Current Value
+--R-----------------------------------------------------------------------------
+--Routput       library in which to place compiled code     
+--Rinput        controls libraries from which to load compiled code  
+--Rargs         arguments for compiling AXIOM code         -O -Fasy -Fao -Flsp -laxiom -Mno-AXL_W_WillObsolete -DAxiom -Y $AXIOM/algebra 
+--R
+--E 3
+
+--S 4 of 86
+)set compiler input
+--R---------------------------- The input Option -----------------------------
+--R
+--R Description: controls libraries from which to load compiled code
+--R
+--R )set compiler input add library is used to tell AXIOM to add library to
+--Rthe front of the path which determines where compiled code is loaded from.
+--R )set compiler input drop library is used to tell AXIOM to remove library 
+--Rfrom this path.
+--E 4
+
+--S 5 of 86
+)set compiler output
+--R---------------------------- The output Option ----------------------------
+--R
+--R Description: library in which to place compiled code
+--R
+--E 5
+
+--S 6 of 86
+)set compiler args
+--R----------------------------- The args Option -----------------------------
+--R
+--R Description: arguments for compiling AXIOM code
+--R
+--R )set compiler args  is used to tell AXIOM how to invoke the library compiler 
+--R when compiling code for AXIOM.
+--R The args option is followed by a string enclosed in double quotes.
+--R
+--R The current setting is
+--R "-O -Fasy -Fao -Flsp -laxiom -Mno-AXL_W_WillObsolete -DAxiom -Y $AXIOM/algebra" 
+--E 6
+
+--S 7 of 86
+)set expose
+--R---------------------------- The expose Option ----------------------------
+--R
+--R Description: control interpreter constructor exposure
+--R
+--R   The following groups are explicitly exposed in the current frame 
+--I      (called initial ):
+--R                                   basic                                   
+--R                                categories                                 
+--R                                  naglink                                  
+--R                                   anna                                    
+--R 
+--R   The following constructors are explicitly exposed in the current 
+--R      frame:
+--R               there are no explicitly exposed constructors                
+--R 
+--R   The following constructors are explicitly hidden in the current 
+--R      frame:
+--R                there are no explicitly hidden constructors                
+--R 
+--R   When )set expose is followed by no arguments, the information you 
+--R      now see is displayed. When followed by the initialize argument, 
+--R      the exposure group data in the file interp.exposed is read and is
+--R      then available. The arguments add and drop are used to add or 
+--R      drop exposure groups or explicit constructors from the local 
+--R      frame exposure data. Issue
+--R                  )set expose add    or    )set expose drop 
+--R      for more information.
+--E 7
+
+--S 8 of 86
+)set functions
+--R                  Current Values of  functions  Variables                  
+--R
+--RVariable     Description                                Current Value
+--R-----------------------------------------------------------------------------
+--Rcache        number of function results to cache        0 
+--Rcompile      compile, don't just define function bodies on 
+--Rrecurrence   specially compile recurrence relations     on 
+--R
+--E 8
+
+--S 9 of 86
+)set functions cache
+--R---------------------------- The cache Option -----------------------------
+--R
+--R Description: number of function results to cache
+--R
+--R )set functions cache is used to tell AXIOM how many
+--R values computed by interpreter functions should be saved.  This can save 
+--R quite a bit of time in recursive functions, though one must consider that
+--R the cached values will take up (perhaps valuable) room in the workspace.
+--R
+--R The value given  after cache must either be the word all or a positive
+--R integer.  This may be followed by any number of function names whose cache
+--R sizes you wish to so set.  If no functions are given, the default cache
+--R size is set.
+--R Examples:   )set fun cache all         )set fun cache 10 f g Legendre
+--R
+--R In general, functions will cache no returned values.
+--E 9
+
+--S 10 of 86
+)set functions compile
+--R--------------------------- The compile Option ----------------------------
+--R
+--R Description: compile, don't just define function bodies
+--R
+--R The compile option may be followed by any one of the following:
+--R
+--R -> on 
+--R    off
+--R
+--R The current setting is indicated.
+--R
+--E 10
+
+--S 11 of 86
+)set functions recurrence
+--R-------------------------- The recurrence Option --------------------------
+--R
+--R Description: specially compile recurrence relations
+--R
+--R The recurrence option may be followed by any one of the following:
+--R
+--R -> on 
+--R    off
+--R
+--R The current setting is indicated.
+--R
+--E 11
+
+--S 12 of 86
+)set fortran
+--R                   Current Values of  fortran  Variables                   
+--R
+--RVariable     Description                                Current Value
+--R-----------------------------------------------------------------------------
+--Rints2floats  where sensible, coerce integers to reals   on 
+--Rfortindent   the number of characters indented          6 
+--Rfortlength   the number of characters on a line         72 
+--Rtypedecs     print type and dimension lines             on 
+--Rdefaulttype  default generic type for FORTRAN object    REAL 
+--Rprecision    precision of generated FORTRAN objects     double 
+--Rintrinsic    whether to use INTRINSIC FORTRAN functions off 
+--Rexplength    character limit for FORTRAN expressions    1320 
+--Rsegment      split long FORTRAN expressions             on 
+--Roptlevel     FORTRAN optimisation level                 0 
+--Rstartindex   starting index for FORTRAN arrays          1 
+--Rcalling      options for external FORTRAN calls         ... 
+--R
+--RVariables with current values of ... have further sub-options. For example,
+--Rissue )set  calling to see what the options are for calling .
+--RFor more information, issue )help set .
+--E 12
+
+--S 13 of 86
+)set fortran ints2floats
+--R------------------------- The ints2floats Option --------------------------
+--R
+--R Description: where sensible, coerce integers to reals
+--R
+--R The ints2floats option may be followed by any one of the following:
+--R
+--R -> on 
+--R    off
+--R
+--R The current setting is indicated.
+--R
+--E 13
+
+--S 14 of 86
+)set fortran fortindent
+--R-------------------------- The fortindent Option --------------------------
+--R
+--R Description: the number of characters indented
+--R
+--R The fortindent option may be followed by an integer in the range 0 to
+--R  inclusive. The current setting is 6 
+--R
+--E 14
+
+--S 15 of 86
+)set fortran fortlength
+--R-------------------------- The fortlength Option --------------------------
+--R
+--R Description: the number of characters on a line
+--R
+--R The fortlength option may be followed by an integer in the range 1 to
+--R  inclusive. The current setting is 72 
+--R
+--E 15
+
+--S 16 of 86
+)set fortran typedecs
+--R--------------------------- The typedecs Option ---------------------------
+--R
+--R Description: print type and dimension lines
+--R
+--R The typedecs option may be followed by any one of the following:
+--R
+--R -> on 
+--R    off
+--R
+--R The current setting is indicated.
+--R
+--E 16
+
+--S 17 of 86
+)set fortran defaulttype
+--R------------------------- The defaulttype Option --------------------------
+--R
+--R Description: default generic type for FORTRAN object
+--R
+--R The defaulttype option may be followed by any one of the following:
+--R
+--R -> REAL 
+--R    INTEGER
+--R    COMPLEX
+--R    LOGICAL
+--R    CHARACTER
+--R
+--R The current setting is indicated.
+--R
+--E 17
+
+--S 18 of 86
+)set fortran precision
+--R-------------------------- The precision Option ---------------------------
+--R
+--R Description: precision of generated FORTRAN objects
+--R
+--R The precision option may be followed by any one of the following:
+--R
+--R    single
+--R -> double 
+--R
+--R The current setting is indicated.
+--R
+--E 18
+
+--S 19 of 86
+)set fortran intrinsic
+--R-------------------------- The intrinsic Option ---------------------------
+--R
+--R Description: whether to use INTRINSIC FORTRAN functions
+--R
+--R The intrinsic option may be followed by any one of the following:
+--R
+--R    on
+--R -> off 
+--R
+--R The current setting is indicated.
+--R
+--E 19
+
+--S 20 of 86
+)set fortran explength
+--R-------------------------- The explength Option ---------------------------
+--R
+--R Description: character limit for FORTRAN expressions
+--R
+--R The explength option may be followed by an integer in the range 0 to
+--R  inclusive. The current setting is 1320 
+--R
+--E 20
+
+--S 21 of 86
+)set fortran segment
+--R--------------------------- The segment Option ----------------------------
+--R
+--R Description: split long FORTRAN expressions
+--R
+--R The segment option may be followed by any one of the following:
+--R
+--R -> on 
+--R    off
+--R
+--R The current setting is indicated.
+--R
+--E 21
+
+--S 22 of 86
+)set fortran optlevel
+--R--------------------------- The optlevel Option ---------------------------
+--R
+--R Description: FORTRAN optimisation level
+--R
+--R The optlevel option may be followed by an integer in the range 0 to
+--R 2 inclusive. The current setting is 0 
+--R
+--E 22
+
+--S 23 of 86
+)set fortran startindex
+--R-------------------------- The startindex Option --------------------------
+--R
+--R Description: starting index for FORTRAN arrays
+--R
+--R The startindex option may be followed by an integer in the range 0 to
+--R 1 inclusive. The current setting is 1 
+--R
+--E 23
+
+--S 24 of 86
+)set fortran calling
+--R                   Current Values of  calling  Variables                   
+--R
+--RVariable     Description                                Current Value
+--R-----------------------------------------------------------------------------
+--Rtempfile     set location of temporary data files       /tmp/ 
+--Rdirectory    set location of generated FORTRAN files    ./ 
+--Rlinker       linker arguments (e.g. libraries to search) -lxlf 
+--R
+--E 24
+
+--S 25 of 86
+)set fortran calling tempfile
+--R--------------------------- The tempfile Option ---------------------------
+--R
+--R Description: set location of temporary data files
+--R
+--R )set fortran calling tempfile  is used to tell AXIOM where
+--R to place intermediate FORTRAN data files . This must be the 
+--R name of a valid existing directory to which you have permission 
+--R to write (including the final slash).
+--R
+--R Syntax:
+--R   )set fortran calling tempfile DIRECTORYNAME
+--R
+--R The current setting is /tmp/ 
+--E 25
+
+--S 26 of 86
+)set fortran calling directory
+--R-------------------------- The directory Option ---------------------------
+--R
+--R Description: set location of generated FORTRAN files
+--R
+--R )set fortran calling directory  is used to tell AXIOM where
+--R to place generated FORTRAN files. This must be the name 
+--R of a valid existing directory to which you have permission 
+--R to write (including the final slash).
+--R
+--R Syntax:
+--R   )set fortran calling directory DIRECTORYNAME
+--R
+--R The current setting is ./ 
+--E 26
+
+--S 27 of 86
+)set fortran calling linker
+--R---------------------------- The linker Option ----------------------------
+--R
+--R Description: linker arguments (e.g. libraries to search)
+--R
+--R )set fortran calling linkerargs  is used to pass arguments to the linker
+--R when using  mkFort  to create functions which call Fortran code.
+--R For example, it might give a list of libraries to be searched,
+--R and their locations.
+--R The string is passed verbatim, so must be the correct syntax for
+--R the particular linker being used.
+--R
+--R Example: )set fortran calling linker "-lxlf"
+--R
+--R The current setting is -lxlf 
+--E 27
+
+--S 28 of 86
+)set kernel
+--R                   Current Values of  kernel  Variables                    
+--R
+--RVariable     Description                                Current Value
+--R-----------------------------------------------------------------------------
+--Rwarn         warn when re-definition is attempted       off 
+--Rprotect      prevent re-definition of kernel functions  off 
+--R
+--E 28
+
+--S 29 of 86
+)set kernel warn
+--R----------------------------- The warn Option -----------------------------
+--R
+--R Description: warn when re-definition is attempted
+--R
+--RSome AXIOM library functions are compiled into the kernel for efficiency
+--Rreasons.  To prevent them being re-defined when loaded from a library
+--Rthey are specially protected.  If a user wishes to know when an attempt
+--Ris made to re-define such a function, he or she should issue the command:
+--R        )set kernel warn on
+--RTo restore the default behaviour, he or she should issue the command:
+--R        )set kernel warn off
+--E 29
+
+--S 30 of 86
+)set kernel protect
+--R--------------------------- The protect Option ----------------------------
+--R
+--R Description: prevent re-definition of kernel functions
+--R
+--RSome AXIOM library functions are compiled into the kernel for efficiency
+--Rreasons.  To prevent them being re-defined when loaded from a library
+--Rthey are specially protected.  If a user wishes to re-define these
+--Rfunctions, he or she should issue the command:
+--R        )set kernel protect off
+--RTo restore the default behaviour, he or she should issue the command:
+--R        )set kernel protect on
+--E 30
+
+--S 31 of 86
+)set hyperdoc
+--R                  Current Values of  hyperdoc  Variables                   
+--R
+--RVariable     Description                                Current Value
+--R-----------------------------------------------------------------------------
+--Rfullscreen   use full screen for this facility          off 
+--Rmathwidth    screen width for history output            120 
+--R
+--E 31
+
+--S 32 of 86
+)set hyperdoc fullscreen
+--R-------------------------- The fullscreen Option --------------------------
+--R
+--R Description: use full screen for this facility
+--R
+--R The fullscreen option may be followed by any one of the following:
+--R
+--R    on
+--R -> off 
+--R
+--R The current setting is indicated.
+--R
+--E 32
+
+--S 33 of 86
+)set hyperdoc mathwidth
+--R-------------------------- The mathwidth Option ---------------------------
+--R
+--R Description: screen width for history output
+--R
+--R The mathwidth option may be followed by an integer in the range 0 to
+--R  inclusive. The current setting is 120 
+--R
+--E 33
+
+--S 34 of 86
+)set help
+--R                    Current Values of  help  Variables                     
+--R
+--RVariable     Description                                Current Value
+--R-----------------------------------------------------------------------------
+--Rfullscreen   use fullscreen facility, if possible       off 
+--R
+--E 34
+
+--S 35 of 86
+)set help fullscreen
+--R-------------------------- The fullscreen Option --------------------------
+--R
+--R Description: use fullscreen facility, if possible
+--R
+--R The fullscreen option may be followed by any one of the following:
+--R
+--R    on
+--R -> off 
+--R
+--R The current setting is indicated.
+--R
+--E 35
+
+--S 36 of 86
+)set history
+--R--------------------------- The history Option ----------------------------
+--R
+--R Description: save workspace values in a history file
+--R
+--R The history option may be followed by any one of the following:
+--R
+--R -> on 
+--R    off
+--R
+--R The current setting is indicated.
+--R
+--E 36
+
+--S 37 of 86
+)set messages
+--R                  Current Values of  messages  Variables                   
+--R
+--RVariable     Description                                Current Value
+--R-----------------------------------------------------------------------------
+--Rany          print the internal type of objects of domain Any on 
+--Rautoload     print file auto-load messages              off 
+--Rbottomup     display bottom up modemap selection        off 
+--Rcoercion     display datatype coercion messages         off 
+--Rdropmap      display old map defn when replaced         off 
+--Rexpose       warning for unexposed functions            off 
+--Rfile         print msgs also to SPADMSG LISTING         off 
+--Rframe        display messages about frames              off 
+--Rhighlighting use highlighting in system messages        off 
+--Rinstant      present instantiation summary              off 
+--Rinsteach     present instantiation info                 off 
+--Rinterponly   say when function code is interpreted      on 
+--Rnaglink      show NAGLink messages                      on 
+--Rnumber       display message number with message        off 
+--Rprompt       set type of input prompt to display        step 
+--Rselection    display function selection msgs            off 
+--Rset          show )set setting after assignment         off 
+--Rstartup      display messages on start-up               on 
+--Rsummary      print statistics after computation         off 
+--Rtesting      print system testing header                on 
+--Rtime         print timings after computation            off 
+--Rtype         print type after computation               on 
+--Rvoid         print Void value when it occurs            off 
+--R
+--E 37
+
+--S 38 of 86
+)set messages autoload
+--R--------------------------- The autoload Option ---------------------------
+--R
+--R Description: print file auto-load messages
+--R
+--E 38
+
+--S 39 of 86
+)set messages bottomup
+--R--------------------------- The bottomup Option ---------------------------
+--R
+--R Description: display bottom up modemap selection
+--R
+--R The bottomup option may be followed by any one of the following:
+--R
+--R    on
+--R -> off 
+--R
+--R The current setting is indicated.
+--R
+--E 39
+
+--S 40 of 86
+)set messages coercion
+--R--------------------------- The coercion Option ---------------------------
+--R
+--R Description: display datatype coercion messages
+--R
+--R The coercion option may be followed by any one of the following:
+--R
+--R    on
+--R -> off 
+--R
+--R The current setting is indicated.
+--R
+--E 40
+
+--S 41 of 86
+)set messages dropmap
+--R--------------------------- The dropmap Option ----------------------------
+--R
+--R Description: display old map defn when replaced
+--R
+--R The dropmap option may be followed by any one of the following:
+--R
+--R    on
+--R -> off 
+--R
+--R The current setting is indicated.
+--R
+--E 41
+
+--S 42 of 86
+)set messages expose
+--R---------------------------- The expose Option ----------------------------
+--R
+--R Description: warning for unexposed functions
+--R
+--R The expose option may be followed by any one of the following:
+--R
+--R    on
+--R -> off 
+--R
+--R The current setting is indicated.
+--R
+--E 42
+
+--S 43 of 86
+)set messages file
+--R----------------------------- The file Option -----------------------------
+--R
+--R Description: print msgs also to SPADMSG LISTING
+--R
+--R The file option may be followed by any one of the following:
+--R
+--R    on
+--R -> off 
+--R
+--R The current setting is indicated.
+--R
+--E 43
+
+--S 44 of 86
+)set messages frame
+--R---------------------------- The frame Option -----------------------------
+--R
+--R Description: display messages about frames
+--R
+--R The frame option may be followed by any one of the following:
+--R
+--R    on
+--R -> off 
+--R
+--R The current setting is indicated.
+--R
+--E 44
+
+--S 45 of 86
+)set messages highlighting
+--R------------------------- The highlighting Option -------------------------
+--R
+--R Description: use highlighting in system messages
+--R
+--R The highlighting option may be followed by any one of the following:
+--R
+--R    on
+--R -> off 
+--R
+--R The current setting is indicated.
+--R
+--E 45
+
+--S 46 of 86
+)set messages instant
+--R--------------------------- The instant Option ----------------------------
+--R
+--R Description: present instantiation summary
+--R
+--R The instant option may be followed by any one of the following:
+--R
+--R    on
+--R -> off 
+--R
+--R The current setting is indicated.
+--R
+--E 46
+
+--S 47 of 86
+)set messages insteach
+--R--------------------------- The insteach Option ---------------------------
+--R
+--R Description: present instantiation info
+--R
+--R The insteach option may be followed by any one of the following:
+--R
+--R    on
+--R -> off 
+--R
+--R The current setting is indicated.
+--R
+--E 47
+
+--S 48 of 86
+)set messages interponly
+--R-------------------------- The interponly Option --------------------------
+--R
+--R Description: say when function code is interpreted
+--R
+--R The interponly option may be followed by any one of the following:
+--R
+--R -> on 
+--R    off
+--R
+--R The current setting is indicated.
+--R
+--E 48
+
+--S 49 of 86
+)set messages number
+--R---------------------------- The number Option ----------------------------
+--R
+--R Description: display message number with message
+--R
+--R The number option may be followed by any one of the following:
+--R
+--R    on
+--R -> off 
+--R
+--R The current setting is indicated.
+--R
+--E 49
+
+--S 50 of 86
+)set messages prompt
+--R---------------------------- The prompt Option ----------------------------
+--R
+--R Description: set type of input prompt to display
+--R
+--R The prompt option may be followed by any one of the following:
+--R
+--R    none
+--R    frame
+--R    plain
+--R -> step 
+--R    verbose
+--R
+--R The current setting is indicated.
+--R
+--E 50
+
+--S 51 of 86
+)set messages selection
+--R-------------------------- The selection Option ---------------------------
+--R
+--R Description: display function selection msgs
+--R
+--R The selection option may be followed by any one of the following:
+--R
+--R    on
+--R -> off 
+--R
+--R The current setting is indicated.
+--R
+--E 51
+
+--S 52 of 86
+)set messages set
+--R----------------------------- The set Option ------------------------------
+--R
+--R Description: show )set setting after assignment
+--R
+--R The set option may be followed by any one of the following:
+--R
+--R    on
+--R -> off 
+--R
+--R The current setting is indicated.
+--R
+--E 52
+
+--S 53 of 86
+)set messages startup
+--R--------------------------- The startup Option ----------------------------
+--R
+--R Description: display messages on start-up
+--R
+--R The startup option may be followed by any one of the following:
+--R
+--R -> on 
+--R    off
+--R
+--R The current setting is indicated.
+--R
+--E 53
+
+--S 54 of 86
+)set messages summary
+--R--------------------------- The summary Option ----------------------------
+--R
+--R Description: print statistics after computation
+--R
+--R The summary option may be followed by any one of the following:
+--R
+--R    on
+--R -> off 
+--R
+--R The current setting is indicated.
+--R
+--E 54
+
+--S 55 of 86
+)set messages testing
+--R--------------------------- The testing Option ----------------------------
+--R
+--R Description: print system testing header
+--R
+--R The testing option may be followed by any one of the following:
+--R
+--R -> on 
+--R    off
+--R
+--R The current setting is indicated.
+--R
+--E 55
+
+--S 56 of 86
+)set messages time
+--R----------------------------- The time Option -----------------------------
+--R
+--R Description: print timings after computation
+--R
+--R The time option may be followed by any one of the following:
+--R
+--R    on
+--R -> off 
+--R    long
+--R
+--R The current setting is indicated.
+--R
+--E 56
+
+--S 57 of 86
+)set messages type
+--R----------------------------- The type Option -----------------------------
+--R
+--R Description: print type after computation
+--R
+--R The type option may be followed by any one of the following:
+--R
+--R -> on 
+--R    off
+--R
+--R The current setting is indicated.
+--R
+--E 57
+
+--S 58 of 86
+)set messages void
+--R----------------------------- The void Option -----------------------------
+--R
+--R Description: print Void value when it occurs
+--R
+--R The void option may be followed by any one of the following:
+--R
+--R    on
+--R -> off 
+--R
+--R The current setting is indicated.
+--R
+--E 58
+
+--S 59 of 86
+)set messages any
+--R----------------------------- The any Option ------------------------------
+--R
+--R Description: print the internal type of objects of domain Any
+--R
+--R The any option may be followed by any one of the following:
+--R
+--R -> on 
+--R    off
+--R
+--R The current setting is indicated.
+--R
+--E 59
+
+--S 60 of 86
+)set messages naglink
+--R--------------------------- The naglink Option ----------------------------
+--R
+--R Description: show NAGLink messages
+--R
+--R The naglink option may be followed by any one of the following:
+--R
+--R -> on 
+--R    off
+--R
+--R The current setting is indicated.
+--R
+--E 60
+
+--S 61 of 86
+)set naglink host
+--R----------------------------- The host Option -----------------------------
+--R
+--R Description: internet address of host for NAGLink
+--R
+--R )set naglink host is used to tell  AXIOM which  host to contact for
+--R a NAGLink request. An Internet address should be supplied. The host
+--R specified must be running the NAGLink daemon.
+--R
+--R The current setting is localhost 
+--E 61
+
+--S 62 of 86
+)set naglink persistence
+--R------------------------- The persistence Option --------------------------
+--R
+--R Description: number of (fortran) functions to remember
+--R
+--R )set naglink persistence is used to tell  the  nagd  daemon how  many ASP
+--R source and object files to keep around in case you reuse them. This helps
+--R to avoid needless recompilations. The number specified should be a 
+--R non-negative integer.
+--R
+--R The current setting is 1 
+--E 62
+
+--S 63 of 86
+)set naglink messages
+--R--------------------------- The messages Option ---------------------------
+--R
+--R Description: show NAGLink messages
+--R
+--R The messages option may be followed by any one of the following:
+--R
+--R -> on 
+--R    off
+--R
+--R The current setting is indicated.
+--R
+--E 63
+
+--S 64 of 86
+)set naglink double
+--R---------------------------- The double Option ----------------------------
+--R
+--R Description: enforce DOUBLE PRECISION ASPs
+--R
+--R The double option may be followed by any one of the following:
+--R
+--R -> on 
+--R    off
+--R
+--R The current setting is indicated.
+--R
+--E 64
+
+--S 65 of 86
+)set output 
+--R                   Current Values of  output  Variables                    
+--R
+--RVariable     Description                                Current Value
+--R-----------------------------------------------------------------------------
+--Rabbreviate   abbreviate type names                      off 
+--Ralgebra      display output in algebraic form           On:CONSOLE 
+--Rcharacters   choose special output character set        plain 
+--Rfortran      create output in FORTRAN format            Off:CONSOLE 
+--Rfraction     how fractions are formatted                vertical 
+--Rlength       line length of output displays             77 
+--Rmathml       create output in MathML style              Off:CONSOLE 
+--Ropenmath     create output in OpenMath style            Off:CONSOLE 
+--Rscript       display output in SCRIPT formula format    Off:CONSOLE 
+--Rscripts      show subscripts,... linearly               off 
+--Rshoweditor   view output of )show in editor             off 
+--Rtex          create output in TeX style                 Off:CONSOLE 
+--R
+--E 65
+
+--S 66 of 86
+)set output abbreviate
+--R-------------------------- The abbreviate Option --------------------------
+--R
+--R Description: abbreviate type names
+--R
+--R The abbreviate option may be followed by any one of the following:
+--R
+--R    on
+--R -> off 
+--R
+--R The current setting is indicated.
+--R
+--E 66
+
+--S 67 of 86
+)set output algebra
+--R--------------------------- The algebra Option ----------------------------
+--R
+--R Description: display output in algebraic form
+--R
+--R )set output algebra is used to tell AXIOM to turn algebra-style output
+--Rprinting on and off, and where to place the output.  By default, the
+--Rdestination for the output is the screen but printing is turned off.
+--R
+--RSyntax:   )set output algebra <arg>
+--R    where arg can be one of
+--R  on          turn algebra printing on (default state)
+--R  off         turn algebra printing off
+--R  console     send algebra output to screen (default state)
+--R  fp<.fe>     send algebra output to file with file prefix fp
+--R              and file extension .fe. If not given, .fe defaults to .spout.
+--R
+--RIf you wish to send the output to a file, you may need to issue this command
+--Rtwice: once with on and once with the file name. For example, to send
+--Ralgebra output to the file polymer.spout, issue the two commands
+--R
+--R  )set output algebra on
+--R  )set output algebra polymer
+--R
+--RThe output is placed in the directory from which you invoked AXIOM or
+--Rthe one you set with the )cd system command.
+--RThe current setting is:  On:CONSOLE 
+--E 67
+
+--S 68 of 86
+)set output characters
+--R-------------------------- The characters Option --------------------------
+--R
+--R Description: choose special output character set
+--R
+--R
+--R The characters option may be followed by any one of the following:
+--R
+--R    default
+--R -> plain 
+--R
+--R The current setting is indicated within the list.  This option determines 
+--R the special characters used for algebraic output.  This is what the
+--R current choice of special characters looks like:
+--R   ulc is shown as +          urc is shown as +       
+--R   llc is shown as +          lrc is shown as +       
+--R   vbar is shown as |         hbar is shown as -      
+--R   quad is shown as ?         lbrk is shown as [      
+--R   rbrk is shown as ]         lbrc is shown as {      
+--R   rbrc is shown as }         ttee is shown as +      
+--R   btee is shown as +         rtee is shown as +      
+--R   ltee is shown as +         ctee is shown as +      
+--R   bslash is shown as \    
+--E 68
+
+--S 69 of 86
+)set output fortran
+--R--------------------------- The fortran Option ----------------------------
+--R
+--R Description: create output in FORTRAN format
+--R
+--R )set output fortran is used to tell AXIOM to turn FORTRAN-style output
+--Rprinting on and off, and where to place the output.  By default, the
+--Rdestination for the output is the screen but printing is turned off.
+--R
+--RAlso See: )set fortran
+--R
+--RSyntax:   )set output fortran <arg>
+--R    where arg can be one of
+--R  on          turn FORTRAN printing on
+--R  off         turn FORTRAN printing off (default state)
+--R  console     send FORTRAN output to screen (default state)
+--R  fp<.fe>     send FORTRAN output to file with file prefix fp and file
+--R              extension .fe. If not given, .fe defaults to .sfort.
+--R
+--RIf you wish to send the output to a file, you must issue this command
+--Rtwice: once with on and once with the file name. For example, to send
+--RFORTRAN output to the file polymer.sfort, issue the two commands
+--R
+--R  )set output fortran on
+--R  )set output fortran polymer
+--R
+--RThe output is placed in the directory from which you invoked AXIOM or
+--Rthe one you set with the )cd system command.
+--RThe current setting is:  Off:CONSOLE 
+--E 69
+
+--S 70 of 86
+)set output fraction
+--R--------------------------- The fraction Option ---------------------------
+--R
+--R Description: how fractions are formatted
+--R
+--R The fraction option may be followed by any one of the following:
+--R
+--R -> vertical 
+--R    horizontal
+--R
+--R The current setting is indicated.
+--R
+--E 70
+
+--S 71 of 86
+)set output length
+--R---------------------------- The length Option ----------------------------
+--R
+--R Description: line length of output displays
+--R
+--R The length option may be followed by an integer in the range 10 to
+--R 245 inclusive. The current setting is 77 
+--R
+--E 71
+
+--S 72 of 86
+)set output mathml
+--R---------------------------- The mathml Option ----------------------------
+--R
+--R Description: create output in MathML style
+--R
+--R )set output mathml is used to tell AXIOM to turn MathML-style output
+--Rprinting on and off, and where to place the output.  By default, the
+--Rdestination for the output is the screen but printing is turned off.
+--R
+--RSyntax:   )set output mathml <arg>
+--R    where arg can be one of
+--R  on          turn MathML printing on
+--R  off         turn MathML printing off (default state)
+--R  console     send MathML output to screen (default state)
+--R  fp<.fe>     send MathML output to file with file prefix fp and file
+--R              extension .fe. If not given, .fe defaults to .stex.
+--R
+--RIf you wish to send the output to a file, you must issue this command
+--Rtwice: once with on and once with the file name. For example, to send
+--RMathML output to the file polymer.smml, issue the two commands
+--R
+--R  )set output mathml on
+--R  )set output mathml polymer
+--R
+--RThe output is placed in the directory from which you invoked AXIOM or
+--Rthe one you set with the )cd system command.
+--RThe current setting is:  Off:CONSOLE 
+--E 72
+
+--S 73 of 86
+)set output openmath
+--R--------------------------- The openmath Option ---------------------------
+--R
+--R Description: create output in OpenMath style
+--R
+--R )set output openmath is used to tell AXIOM to turn OpenMath output
+--Rprinting on and off, and where to place the output.  By default, the
+--Rdestination for the output is the screen but printing is turned off.
+--R
+--RSyntax:   )set output openmath <arg>
+--R    where arg can be one of
+--R  on          turn OpenMath printing on
+--R  off         turn OpenMath printing off (default state)
+--R  console     send OpenMath output to screen (default state)
+--R  fp<.fe>     send OpenMath output to file with file prefix fp and file
+--R              extension .fe. If not given, .fe defaults to .som.
+--R
+--RIf you wish to send the output to a file, you must issue this command
+--Rtwice: once with on and once with the file name. For example, to send
+--ROpenMath output to the file polymer.som, issue the two commands
+--R
+--R  )set output openmath on
+--R  )set output openmath polymer
+--R
+--RThe output is placed in the directory from which you invoked AXIOM or
+--Rthe one you set with the )cd system command.
+--RThe current setting is:  Off:CONSOLE 
+--E 73
+
+--S 74 of 86
+)set output script
+--R---------------------------- The script Option ----------------------------
+--R
+--R Description: display output in SCRIPT formula format
+--R
+--R )set output script is used to tell AXIOM to turn IBM Script formula-style
+--Routput printing on and off, and where to place the output.  By default, the
+--Rdestination for the output is the screen but printing is turned off.
+--R
+--RSyntax:   )set output script <arg>
+--R    where arg can be one of
+--R  on          turn IBM Script formula printing on
+--R  off         turn IBM Script formula printing off (default state)
+--R  console     send IBM Script formula output to screen (default state)
+--R  fp<.fe>     send IBM Script formula output to file with file prefix fp
+--R              and file extension .fe. If not given, .fe defaults to .sform.
+--R
+--RIf you wish to send the output to a file, you must issue this command
+--Rtwice: once with on and once with the file name. For example, to send
+--RIBM Script formula output to the file polymer.sform, issue the two commands
+--R
+--R  )set output script on
+--R  )set output script polymer
+--R
+--RThe output is placed in the directory from which you invoked AXIOM or
+--Rthe one you set with the )cd system command.
+--RThe current setting is:  Off:CONSOLE 
+--E 74
+
+--S 75 of 86
+)set output scripts
+--R--------------------------- The scripts Option ----------------------------
+--R
+--R Description: show subscripts,... linearly
+--R
+--R The scripts option may be followed by any one of the following:
+--R
+--R    on
+--R -> off 
+--R
+--R The current setting is indicated.
+--R
+--E 75
+
+--S 76 of 86
+)set output showeditor
+--R-------------------------- The showeditor Option --------------------------
+--R
+--R Description: view output of )show in editor
+--R
+--R The showeditor option may be followed by any one of the following:
+--R
+--R    on
+--R -> off 
+--R
+--R The current setting is indicated.
+--R
+--E 76
+
+--S 77 of 86
+)set output tex
+--R----------------------------- The tex Option ------------------------------
+--R
+--R Description: create output in TeX style
+--R
+--R )set output tex is used to tell AXIOM to turn TeX-style output
+--Rprinting on and off, and where to place the output.  By default, the
+--Rdestination for the output is the screen but printing is turned off.
+--R
+--RSyntax:   )set output tex <arg>
+--R    where arg can be one of
+--R  on          turn TeX printing on
+--R  off         turn TeX printing off (default state)
+--R  console     send TeX output to screen (default state)
+--R  fp<.fe>     send TeX output to file with file prefix fp and file
+--R              extension .fe. If not given, .fe defaults to .stex.
+--R
+--RIf you wish to send the output to a file, you must issue this command
+--Rtwice: once with on and once with the file name. For example, to send
+--RTeX output to the file polymer.stex, issue the two commands
+--R
+--R  )set output tex on
+--R  )set output tex polymer
+--R
+--RThe output is placed in the directory from which you invoked AXIOM or
+--Rthe one you set with the )cd system command.
+--RThe current setting is:  Off:CONSOLE 
+--E 77
+
+--S 78 of 86
+)set quit
+--R----------------------------- The quit Option -----------------------------
+--R
+--R Description: protected or unprotected quit
+--R
+--R The quit option may be followed by any one of the following:
+--R
+--R -> protected 
+--R    unprotected
+--R
+--R The current setting is indicated.
+--R
+--E 78
+
+--S 79 of 86
+)set streams
+--R                   Current Values of  streams  Variables                   
+--R
+--RVariable     Description                                Current Value
+--R-----------------------------------------------------------------------------
+--Rcalculate    specify number of elements to calculate    10 
+--Rshowall      display all stream elements computed       off 
+--R
+--E 79
+
+--S 80 of 86
+)set streams calculate
+--R-------------------------- The calculate Option ---------------------------
+--R
+--R Description: specify number of elements to calculate
+--R
+--R   )set streams calculate is used to tell AXIOM how many elements of a 
+--R      stream to calculate when a computation uses the stream. The value
+--R      given after calculate must either be the word all or a positive 
+--R      integer.
+--R
+--R      The current setting is 10 .
+--E 80
+
+--S 81 of 86
+)set streams showall
+--R--------------------------- The showall Option ----------------------------
+--R
+--R Description: display all stream elements computed
+--R
+--R The showall option may be followed by any one of the following:
+--R
+--R    on
+--R -> off 
+--R
+--R The current setting is indicated.
+--R
+--E 81
+
+--S 82 of 86
+)set system
+--R                   Current Values of  system  Variables                    
+--R
+--RVariable     Description                                Current Value
+--R-----------------------------------------------------------------------------
+--Rfunctioncode show gen. LISP for functions when compiled off 
+--Roptimization show optimized LISP code                   off 
+--Rprettyprint  prettyprint BOOT func's as they compile    on 
+--R
+--E 82
+
+--S 83 of 86
+)set system functioncode
+--R------------------------- The functioncode Option -------------------------
+--R
+--R Description: show gen. LISP for functions when compiled
+--R
+--R The functioncode option may be followed by any one of the following:
+--R
+--R    on
+--R -> off 
+--R
+--R The current setting is indicated.
+--R
+--E 83
+
+--S 84 of 86
+)set system optimization
+--R------------------------- The optimization Option -------------------------
+--R
+--R Description: show optimized LISP code
+--R
+--R The optimization option may be followed by any one of the following:
+--R
+--R    on
+--R -> off 
+--R
+--R The current setting is indicated.
+--R
+--E 84
+
+--S 85 of 86
+)set system prettyprint
+--R------------------------- The prettyprint Option --------------------------
+--R
+--R Description: prettyprint BOOT func's as they compile
+--R
+--R The prettyprint option may be followed by any one of the following:
+--R
+--R -> on 
+--R    off
+--R
+--R The current setting is indicated.
+--R
+--E 85
+
+--S 86 of 86
+)set userlevel
+--R-------------------------- The userlevel Option ---------------------------
+--R
+--R Description: operation access level of system user
+--R
+--R The userlevel option may be followed by any one of the following:
+--R
+--R    interpreter
+--R    compiler
+--R -> development 
+--R
+--R The current setting is indicated.
+--R
+--E 86
+
+)spool 
+)lisp (bye)
+ 
+@
+\eject
+\begin{thebibliography}{99}
+\bibitem{1} nothing
+\end{thebibliography}
+\end{document}
+
diff --git a/src/input/unittest1.input.pamphlet b/src/input/unittest1.input.pamphlet
index ac70ef0..de6d372 100644
--- a/src/input/unittest1.input.pamphlet
+++ b/src/input/unittest1.input.pamphlet
@@ -55,8 +55,8 @@ The )apropos command is the same as a )what command
 --RzeroSquareMatrix                   
 --R   
 --R      To get more information about an operation such as 
---R      rectangularMatrix , issue the command )display op 
---R      rectangularMatrix 
+--R      createGenericMatrix , issue the command )display op 
+--R      createGenericMatrix 
 --R------------------------------- Categories --------------------------------
 --R
 --RCategories with names matching patterns:
@@ -257,9 +257,8 @@ The )apropos command is the same as a )what command
 --RzeroSetSplit                                    
 --RzeroSetSplitIntoTriangularSystems               
 --R   
---R      To get more information about an operation such as 
---R      setAttributeButtonStep , issue the command )display op 
---R      setAttributeButtonStep 
+--R      To get more information about an operation such as setButtonValue
+--R      , issue the command )display op setButtonValue 
 --E 6
 
 --S 7 0f 28
@@ -389,9 +388,8 @@ The )apropos command is the same as a )what command
 --RzeroSetSplit                                    
 --RzeroSetSplitIntoTriangularSystems               
 --R   
---R      To get more information about an operation such as 
---R      setAttributeButtonStep , issue the command )display op 
---R      setAttributeButtonStep 
+--R      To get more information about an operation such as setButtonValue
+--R      , issue the command )display op setButtonValue 
 --R------------------------------- Categories --------------------------------
 --R
 --RCategories with names matching patterns:
@@ -452,6 +450,7 @@ The )apropos command is the same as a )what command
 
 --S 10 0f 28
 )apropos set
+--R 
 --R
 --ROperations whose names satisfy the above pattern(s):
 --R
@@ -549,8 +548,8 @@ The )apropos command is the same as a )what command
 --RzeroSetSplit                                    
 --RzeroSetSplitIntoTriangularSystems               
 --R   
---R      To get more information about an operation such as setMaxPoints ,
---R      issue the command )display op setMaxPoints 
+--R      To get more information about an operation such as setButtonValue
+--R      , issue the command )display op setButtonValue 
 --R------------------------------- Categories --------------------------------
 --R
 --RCategories with names matching patterns:
@@ -623,7 +622,7 @@ The )apropos command is the same as a )what command
 --R -> step 
 --R    verbose
 --R
---R The current setting is indicated within the list.
+--R The current setting is indicated.
 --R
 --E 11
 
@@ -771,118 +770,92 @@ The )apropos command is the same as a )what command
 
 --S 27 0f 28
 )summary
- )credits      : list the people who have contributed to Axiom
-
- )help <command> gives more information
- )quit         : exit AXIOM 
-
- )abbreviation : query, set and remove abbreviations for constructors
- )cd           : set working directory
- )clear        : remove declarations, definitions or values
- )close        : throw away an interpreter client and workspace
- )compile      : invoke constructor compiler
- )display      : display Library operations and objects in your workspace
- )edit         : edit a file
- )frame        : manage interpreter workspaces
- )history      : manage aspects of interactive session
- )library      : introduce new constructors 
- )lisp         : evaluate a LISP expression
- )read         : execute AXIOM commands from a file
- )savesystem   : save LISP image to a file
- )set          : view and set system variables
- )show         : show constructor information
- )spool        : log input and output to a file
- )synonym      : define an abbreviation for system commands
- )system       : issue shell commands
- )trace        : trace execution of functions
- )undo         : restore workspace to earlier state
- )what         : search for various things by name
-
+--R 
 --E 27
 
 --S 28 0f 28
-)credits
-An alphabetical listing of contributors to AXIOM:
-Cyril Alberga          Roy Adler              Christian Aistleitner
-Richard Anderson       George Andrews         S.J. Atkins
-Henry Baker            Stephen Balzac         Yurij Baransky
-David R. Barton        Gerald Baumgartner     Gilbert Baumslag
-Jay Belanger           David Bindel           Fred Blair
-Vladimir Bondarenko    Mark Botch
-Alexandre Bouyer       Peter A. Broadbery     Martin Brock
-Manuel Bronstein       Stephen Buchwald       Florian Bundschuh
-Luanne Burns           William Burge
-Quentin Carpent        Robert Caviness        Bruce Char
-Ondrej Certik          Cheekai Chin           David V. Chudnovsky
-Gregory V. Chudnovsky  Josh Cohen             Christophe Conil
-Don Coppersmith        George Corliss         Robert Corless
-Gary Cornell           Meino Cramer           Claire Di Crescenzo
-David Cyganski
-Timothy Daly Sr.       Timothy Daly Jr.       James H. Davenport
-Didier Deshommes       Michael Dewar
-Jean Della Dora        Gabriel Dos Reis       Claire DiCrescendo
-Sam Dooley             Lionel Ducos           Martin Dunstan
-Brian Dupee            Dominique Duval
-Robert Edwards         Heow Eide-Goodman      Lars Erickson
-Richard Fateman        Bertfried Fauser       Stuart Feldman
-Brian Ford             Albrecht Fortenbacher  George Frances
-Constantine Frangos    Timothy Freeman        Korrinn Fu
-Marc Gaetano           Rudiger Gebauer        Kathy Gerber
-Patricia Gianni        Samantha Goldrich      Holger Gollan
-Teresa Gomez-Diaz      Laureano Gonzalez-Vega Stephen Gortler
-Johannes Grabmeier     Matt Grayson           Klaus Ebbe Grue
-James Griesmer         Vladimir Grinberg      Oswald Gschnitzer
-Jocelyn Guidry
-Steve Hague            Satoshi Hamaguchi      Mike Hansen
-Richard Harke          Vilya Harvey           Martin Hassner
-Arthur S. Hathaway     Dan Hatton             Waldek Hebisch
-Karl Hegbloom          Ralf Hemmecke          Henderson
-Antoine Hersen         Gernot Hueber
-Pietro Iglio
-Alejandro Jakubi       Richard Jenks
-Kai Kaminski           Grant Keady            Tony Kennedy
-Paul Kosinski          Klaus Kusche           Bernhard Kutzler
-Tim Lahey              Larry Lambe            Franz Lehner
-Frederic Lehobey       Michel Levaud          Howard Levy
-Liu Xiaojun            Rudiger Loos           Michael Lucks
-Richard Luczak
-Camm Maguire           Francois Maltey        Alasdair McAndrew
-Bob McElrath           Michael McGettrick     Ian Meikle
-David Mentre           Victor S. Miller       Gerard Milmeister
-Mohammed Mobarak       H. Michael Moeller     Michael Monagan
-Marc Moreno-Maza       Scott Morrison         Joel Moses
-Mark Murray
-William Naylor         C. Andrew Neff         John Nelder
-Godfrey Nolan          Arthur Norman          Jinzhong Niu
-Michael O'Connor       Summat Oemrawsingh     Kostas Oikonomou
-Humberto Ortiz-Zuazaga
-Julian A. Padget       Bill Page              Susan Pelzel
-Michel Petitot         Didier Pinchon         Ayal Pinkus
-Jose Alfredo Portes
-Claude Quitte
-Arthur C. Ralfs        Norman Ramsey          Anatoly Raportirenko
-Michael Richardson     Renaud Rioboo          Jean Rivlin
-Nicolas Robidoux       Simon Robinson         Raymond Rogers
-Michael Rothstein      Martin Rubey
-Philip Santas          Alfred Scheerhorn      William Schelter
-Gerhard Schneider      Martin Schoenert       Marshall Schor
-Frithjof Schulze       Fritz Schwarz          Nick Simicich
-William Sit            Elena Smirnova         Jonathan Steinbach
-Fabio Stumbo           Christine Sundaresan   Robert Sutor
-Moss E. Sweedler       Eugene Surowitz
-Max Tegmark            James Thatcher         Balbir Thomas
-Mike Thomas            Dylan Thurston         Barry Trager
-Themos T. Tsikas
-Gregory Vanuxem
-Bernhard Wall          Stephen Watt           Jaap Weel
-Juergen Weiss          M. Weller              Mark Wegman
-James Wen              Thorsten Werther       Michael Wester
-John M. Wiley          Berhard Will           Clifton J. Williamson
-Stephen Wilson         Shmuel Winograd        Robert Wisbauer
-Sandra Wityak          Waldemar Wiwianka      Knut Wolf
-Clifford Yapp          David Yun
-Vadim Zhytnikov        Richard Zippel         Evelyn Zoernack
-Bruno Zuercher         Dan Zwillinger
+--R)credits
+--RAn alphabetical listing of contributors to AXIOM:
+--RCyril Alberga          Roy Adler              Christian Aistleitner
+--RRichard Anderson       George Andrews         S.J. Atkins
+--RHenry Baker            Stephen Balzac         Yurij Baransky
+--RDavid R. Barton        Gerald Baumgartner     Gilbert Baumslag
+--RJay Belanger           David Bindel           Fred Blair
+--RVladimir Bondarenko    Mark Botch
+--RAlexandre Bouyer       Peter A. Broadbery     Martin Brock
+--RManuel Bronstein       Stephen Buchwald       Florian Bundschuh
+--RLuanne Burns           William Burge
+--RQuentin Carpent        Robert Caviness        Bruce Char
+--ROndrej Certik          Cheekai Chin           David V. Chudnovsky
+--RGregory V. Chudnovsky  Josh Cohen             Christophe Conil
+--RDon Coppersmith        George Corliss         Robert Corless
+--RGary Cornell           Meino Cramer           Claire Di Crescenzo
+--RDavid Cyganski
+--RTimothy Daly Sr.       Timothy Daly Jr.       James H. Davenport
+--RDidier Deshommes       Michael Dewar
+--RJean Della Dora        Gabriel Dos Reis       Claire DiCrescendo
+--RSam Dooley             Lionel Ducos           Martin Dunstan
+--RBrian Dupee            Dominique Duval
+--RRobert Edwards         Heow Eide-Goodman      Lars Erickson
+--RRichard Fateman        Bertfried Fauser       Stuart Feldman
+--RBrian Ford             Albrecht Fortenbacher  George Frances
+--RConstantine Frangos    Timothy Freeman        Korrinn Fu
+--RMarc Gaetano           Rudiger Gebauer        Kathy Gerber
+--RPatricia Gianni        Samantha Goldrich      Holger Gollan
+--RTeresa Gomez-Diaz      Laureano Gonzalez-Vega Stephen Gortler
+--RJohannes Grabmeier     Matt Grayson           Klaus Ebbe Grue
+--RJames Griesmer         Vladimir Grinberg      Oswald Gschnitzer
+--RJocelyn Guidry
+--RSteve Hague            Satoshi Hamaguchi      Mike Hansen
+--RRichard Harke          Vilya Harvey           Martin Hassner
+--RArthur S. Hathaway     Dan Hatton             Waldek Hebisch
+--RKarl Hegbloom          Ralf Hemmecke          Henderson
+--RAntoine Hersen         Gernot Hueber
+--RPietro Iglio
+--RAlejandro Jakubi       Richard Jenks
+--RKai Kaminski           Grant Keady            Tony Kennedy
+--RPaul Kosinski          Klaus Kusche           Bernhard Kutzler
+--RTim Lahey              Larry Lambe            Franz Lehner
+--RFrederic Lehobey       Michel Levaud          Howard Levy
+--RLiu Xiaojun            Rudiger Loos           Michael Lucks
+--RRichard Luczak
+--RCamm Maguire           Francois Maltey        Alasdair McAndrew
+--RBob McElrath           Michael McGettrick     Ian Meikle
+--RDavid Mentre           Victor S. Miller       Gerard Milmeister
+--RMohammed Mobarak       H. Michael Moeller     Michael Monagan
+--RMarc Moreno-Maza       Scott Morrison         Joel Moses
+--RMark Murray
+--RWilliam Naylor         C. Andrew Neff         John Nelder
+--RGodfrey Nolan          Arthur Norman          Jinzhong Niu
+--RMichael O'Connor       Summat Oemrawsingh     Kostas Oikonomou
+--RHumberto Ortiz-Zuazaga
+--RJulian A. Padget       Bill Page              Susan Pelzel
+--RMichel Petitot         Didier Pinchon         Ayal Pinkus
+--RJose Alfredo Portes
+--RClaude Quitte
+--RArthur C. Ralfs        Norman Ramsey          Anatoly Raportirenko
+--RMichael Richardson     Renaud Rioboo          Jean Rivlin
+--RNicolas Robidoux       Simon Robinson         Raymond Rogers
+--RMichael Rothstein      Martin Rubey
+--RPhilip Santas          Alfred Scheerhorn      William Schelter
+--RGerhard Schneider      Martin Schoenert       Marshall Schor
+--RFrithjof Schulze       Fritz Schwarz          Nick Simicich
+--RWilliam Sit            Elena Smirnova         Jonathan Steinbach
+--RFabio Stumbo           Christine Sundaresan   Robert Sutor
+--RMoss E. Sweedler       Eugene Surowitz
+--RMax Tegmark            James Thatcher         Balbir Thomas
+--RMike Thomas            Dylan Thurston         Barry Trager
+--RThemos T. Tsikas
+--RGregory Vanuxem
+--RBernhard Wall          Stephen Watt           Jaap Weel
+--RJuergen Weiss          M. Weller              Mark Wegman
+--RJames Wen              Thorsten Werther       Michael Wester
+--RJohn M. Wiley          Berhard Will           Clifton J. Williamson
+--RStephen Wilson         Shmuel Winograd        Robert Wisbauer
+--RSandra Wityak          Waldemar Wiwianka      Knut Wolf
+--RClifford Yapp          David Yun
+--RVadim Zhytnikov        Richard Zippel         Evelyn Zoernack
+--RBruno Zuercher         Dan Zwillinger
 --E 28
 
 )spool
diff --git a/src/interp/setvars.boot.pamphlet b/src/interp/setvars.boot.pamphlet
index b052e85..d75cde4 100644
--- a/src/interp/setvars.boot.pamphlet
+++ b/src/interp/setvars.boot.pamphlet
@@ -44,11 +44,6 @@ command line functions.
 <<toplevelsetfunctions>>=
 <<initializeSetVariables>>
 <<resetWorkspaceVariables>>
-<<translateYesNo2TrueFalse>>
-<<translateTrueFalse2YesNo>>
-<<set>>
-<<set1>>
-<<displaySetOptionInformation>>
 <<displaySetVariableSettings>>
 @
 \section{initializeSetVariables}
@@ -109,156 +104,7 @@ resetWorkspaceVariables () ==
   initializeSetVariables($setOptions)
 
 @
-\subsection{translateYesNo2TrueFalse}
-<<translateYesNo2TrueFalse>>=
-translateYesNo2TrueFalse x ==
-  x in '(yes on) => true
-  x in '(no off)  => false
-  x
-
-@
-\subsection{translateTrueFalse2YesNo}
-<<translateTrueFalse2YesNo>>=
-translateTrueFalse2YesNo x ==
-  x = true  => 'on
-  x = false => 'off
-  x
-
-@
-\subsection{set}
-<<set>>=
-set l ==  set1(l, $setOptions)
-
-@
-\subsection{set1}
-<<set1>>=
-set1(l,setTree) ==
-  null l => displaySetVariableSettings(setTree,"")
-  $setOptionNames : local := [x.0 for x in setTree]
-  arg := selectOption(DOWNCASE CAR l,$setOptionNames,'optionError)
-  setData := [arg,:LASSOC(arg,setTree)]
-
-  -- check is the user is authorized for the set variable
-  null satisfiesUserLevel setData.setLevel =>
-    sayKeyedMsg("S2IZ0007",[$UserLevel,'"set option"])
-
-  1 = #l => displaySetOptionInformation(arg,setData)
-  st := setData.setType
-
-  st = 'FUNCTION =>
-    -- allow the user to set the default
-    setfunarg :=
-      l.1 = 'DEFAULT => "%initialize%"
---    (arg2 := selectOption(l.1,['default],nil)) => "%initialize%"
-      KDR l
-    if functionp(setData.setVar)
-      then FUNCALL( setData.setVar,setfunarg)
-      else sayMSG '"   Function not implemented."
-    -- if so set, then show option information
-    if $displaySetValue then displaySetOptionInformation(arg,setData)
-    NIL
-
-  st = 'STRING   =>
-    arg2 := l.1
-    if arg2 = 'DEFAULT
-      then SET(setData.setVar, setData.setDef)
-      else if arg2 then SET(setData.setVar, arg2)
-    -- if so set or not a valid choice, then show option information
-    if $displaySetValue or (null arg2) then
-      displaySetOptionInformation(arg,setData)
-    NIL
-
-  st = 'INTEGER  =>
-    -- validate the option, allowing the user to set the default
-    arg2 :=
-      num := l.1
-      (FIXP num) and (num >= (setData.setLeaf).0) and
-        (null (upperlimit := setData.setLeaf.1) or num <= upperlimit) => num
-      selectOption(l.1,['default,:setData.setLeaf],nil)
-    if arg2 = 'DEFAULT
-      then SET(setData.setVar, setData.setDef)
-      else if arg2 then SET(setData.setVar, arg2)
-    -- if so set or not a valid choice, then show option information
-    if $displaySetValue or (null arg2) then
-      displaySetOptionInformation(arg,setData)
-    null arg2 => sayMessage ['" Your value",:bright object2String l.1,
-        '"is not among the valid choices."]
-    NIL
-
-  st = 'LITERALS =>
-    -- validate the option, allowing the user to set the default
-    if (arg2 := selectOption(l.1,['default,:setData.setLeaf],nil)) then
-      if arg2 = 'DEFAULT
-        then SET(setData.setVar, translateYesNo2TrueFalse setData.setDef)
-        else
-          if arg2 = 'nobreak then
-             USE_-FAST_-LINKS 'T
-          if arg2 = 'fastlinks then
-             USE_-FAST_-LINKS 'NIL
-             arg2 := 'break
-          SET(setData.setVar, translateYesNo2TrueFalse arg2)
-    -- if so set or not a valid choice, then show option information
-    if $displaySetValue or (null arg2) then
-      displaySetOptionInformation(arg,setData)
-    null arg2 => sayMessage ['" Your value",:bright object2String l.1,
-        '"is not among the valid choices."]
-    NIL
-
-  -- for a sub-tree, we must recurse
-  st = 'TREE =>
-    set1(KDR l,setData.setLeaf)
-    NIL
-  sayMessage ['"Cannot handle set tree node type",:bright st,"yet"]
-  NIL
-
-@
-\subsection{displaySetOptionInformation}
-<<displaySetOptionInformation>>=
-displaySetOptionInformation(arg,setData) ==
-  st := setData.setType
-  -- if the option is a sub-tree, show the full menu
-  st = 'TREE =>
-    displaySetVariableSettings(setData.setLeaf,setData.setName)
 
-  -- otherwise we want to show the current setting
-  centerAndHighlight (STRCONC('"The ",object2String arg,'" Option"),
-                      $LINELENGTH,specialChar 'hbar)
-  sayBrightly ['%l,:bright '"Description:",setData.setLabel]
-
-  st = 'FUNCTION =>
-    TERPRI()
-    if functionp(setData.setVar)
-      then FUNCALL(setData.setVar,"%describe%")
-      else sayMSG '"   Function not implemented."
-
-  st = 'INTEGER  =>
-    sayMessage ['" The",:bright arg,'"option",
-      '" may be followed by an integer in the range",
-       :bright (setData.setLeaf).0,'"to",'%l,
-        :bright (setData.setLeaf).1,'"inclusive.",
-         '" The current setting is",:bright eval setData.setVar]
-
-  st = 'STRING  =>
-    sayMessage ['" The",:bright arg,'"option",
-      '" is followed by a string enclosed in double quote marks.", '%l,
-         '" The current setting is",:bright ["_"",eval setData.setVar, "_""]]
-
-  st = 'LITERALS =>
-    sayMessage ['" The",:bright arg,'"option",
-      '" may be followed by any one of the following:"]
-    current := translateTrueFalse2YesNo eval setData.setVar
-    for name in setData.setLeaf repeat
-      if name = current
-        then sayBrightly ['" ->",:bright object2String name]
-        else sayBrightly ['"    ",object2String name]
-    sayMessage '" The current setting is indicated within the list."
-    if (setData.setLeaf = '(yes no on off)) or
-      (setData.setLeaf = '(yes no on off long)) then
-       sayMessage [:bright '"yes",'"and",:bright '"no",
-        '"have the same effect as",:bright '"on",'"and",:bright '"off",
-          '"respectively."]
-
-@
 \subsection{displaySetVariableSettings}
 <<displaySetVariableSettings>>=
 displaySetVariableSettings(setTree,label) ==
diff --git a/src/interp/setvart.boot.pamphlet b/src/interp/setvart.boot.pamphlet
index bfa2f14..da870d3 100644
--- a/src/interp/setvart.boot.pamphlet
+++ b/src/interp/setvart.boot.pamphlet
@@ -9,2428 +9,7 @@
 \eject
 \tableofcontents
 \eject
-\section{Overview}
-This file contains functions to initialize the {\bf )set} command
-in the interpreter. The current list is:
-\begin{verbatim}
-
-Variable     Description                           Current Value
------------------------------------------------------------------
-compiler   Library compiler options                   ... 
-breakmode  execute break processing on error          break 
-expose     control interpreter constructor exposure   ... 
-functions  some interpreter function options          ... 
-fortran    view and set options for FORTRAN output    ... 
-kernel     library functions built into the kernel for 
-           efficiency                                 ...
-hyperdoc   options in using HyperDoc                  ... 
-help       view and set some help options             ... 
-history    save workspace values in a history file    on 
-messages   show messages for various system features  ... 
-naglink    options for NAGLink                        ... 
-output     view and set some output options           ... 
-quit       protected or unprotected quit              unprotected 
-streams    set some options for working with streams  ... 
-system     set some system development variables      ... 
-userlevel  operation access level of system user      development 
-
-Variables with current values of ... have further sub-options. 
-For example, issue )set  system to see what the options are 
-for system. 
-For more information, issue )help set .
-
-\end{verbatim}
-\subsection{The list structure}
-The structure of each list item consists of 7 items.  Consider this 
-example:
-\begin{verbatim}
-  (userlevel
-   "operation access level of system user"
-   interpreter
-   LITERALS
-   $UserLevel
-   (interpreter compiler development)
-   development)
-\end{verbatim}
-The list looks like (the names in bold are accessor names that can be
-found in {\bf property.lisp.pamphlet\cite{1}}. Look for "setName".):
-\begin{list}{}
-\item {\bf 1} {\sl Name} the keyword the user will see. In this example
-the user would say "{\bf )set output userlevel}".
-\item {\bf 2} {\sl Label} the message the user will see. In this example
-the user would see "operation access level of system user".
-\item {\bf 3} {\sl Level} the level where the command will be 
-accepted. There are three levels: interpreter, compiler, development.
-These commands are restricted to keep the user from causing damage.
-\item {\bf 4} {\sl Type} a symbol, one of {\bf FUNCTION}, {\bf INTEGER},
-{\bf STRING}, {\bf LITERALS}, or {\bf TREE}. See the function
-{\bf initializeSetVariables} in the file
-{\bf setvars.boot.pamphlet\cite{2}}.
-\item {\bf 5} {\sl Var} variable which holds the current user setting.
-\item {\bf 6} {\sl Leaf} is a list of all of the user levels
-that expose this command.
-\item {\bf 7} {\sl Def} is the default value of this variable.
-\end{list}
-\section{breakmode}
-\begin{verbatim}
--------------------- The breakmode Option ---------------------
-
- Description: execute break processing on error
-
- The breakmode option may be followed by any one of the 
- following:
-
-    nobreak
- -> break 
-    query
-    resume
-    fastlinks
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<breakmode>>=
-  (breakmode
-   "execute break processing on error"
-   interpreter
-   LITERALS
-   $BreakMode
-   (nobreak break query resume fastlinks)
-   nobreak)         -- needed to avoid possible startup looping
-@
-\section{compiler}
-\begin{verbatim}
-                  Current Values of  compiler  Variables                   
-
-Variable     Description                           Current Value
------------------------------------------------------------------
-output       library in which to place compiled code     
-input        controls libraries from which to load compiled code  
-args         arguments for compiling AXIOM code         
-             -O -Fasy -Fao -Flsp -laxiom -Mno-AXL_W_WillObsolete 
-             -DAxiom -Y $AXIOM/algebra 
-
-\end{verbatim}
-<<compiler>>=
-   (compiler
-    "Library compiler options"
-    interpreter
-    TREE
-    novar
-    (
-<<compileroutput>>
-<<compilerinput>>
-<<compilerargs>>
-    ))
-@
-\subsection{output}
-\begin{verbatim}
----------------------- The output Option ----------------------
-
- Description: library in which to place compiled code
-
-\end{verbatim}
-<<compileroutput>>=
-      (output
-       "library in which to place compiled code"
-       interpreter
-       FUNCTION
-       setOutputLibrary
-       NIL
-       htSetOutputLibrary 
-	)
-@
-\subsection{input}
-\begin{verbatim}
----------------------- The input Option -----------------------
-
- Description: controls libraries from which to load compiled code
-
- )set compiler input add library is used to tell AXIOM to add 
-  library to the front of the path which determines where 
-  compiled code is loaded from.
- )set compiler input drop library is used to tell AXIOM to remove 
-  library from this path.
-\end{verbatim}
-<<compilerinput>>=
-      (input
-       "controls libraries from which to load compiled code"
-       interpreter
-       FUNCTION
-       setInputLibrary
-       NIL
-       htSetInputLibrary)
-@
-\subsection{args}
-\begin{verbatim}
------------------------ The args Option -----------------------
-
- Description: arguments for compiling AXIOM code
-
- )set compiler args  is used to tell AXIOM how to invoke the 
-  library compiler when compiling code for AXIOM.
-  The args option is followed by a string enclosed in double 
-  quotes.
-
- The current setting is
- "-O -Fasy -Fao -Flsp -laxiom -Mno-AXL_W_WillObsolete 
-  -DAxiom -Y $AXIOM/algebra" 
-\end{verbatim}
-<<compilerargs>>=
-      (args
-       "arguments for compiling AXIOM code"
-       interpreter
-       FUNCTION
-       setAsharpArgs
-       (("enter compiler options "
-          STRING
-          $asharpCmdlineFlags
-          chkDirectory
-          "-O -Fasy -Fao -Flsp -laxiom -Mno-AXL__W__WillObsolete -DAxiom -Y $AXIOM/algebra"))
-       NIL)
-@
-\section{expose}
-\begin{verbatim}
----------------------- The expose Option ----------------------
-
- Description: control interpreter constructor exposure
-
-   The following groups are explicitly exposed in the current 
-   frame (called initial ):
-                                   basic                                   
-                                categories                                 
-                                  naglink                                  
-                                   anna                                    
- 
-   The following constructors are explicitly exposed in the 
-   current frame:
-               there are no explicitly exposed constructors                
- 
-   The following constructors are explicitly hidden in the 
-   current frame:
-                there are no explicitly hidden constructors                
- 
-   When )set expose is followed by no arguments, the information
-   you now see is displayed. When followed by the initialize 
-   argument, the exposure group data in the file interp.exposed 
-   is read and is then available. The arguments add and drop are 
-   used to add or drop exposure groups or explicit constructors 
-   from the local frame exposure data. Issue
-                  )set expose add    or    )set expose drop 
-   for more information.
-\end{verbatim}
-<<expose>>=
-  (expose
-   "control interpreter constructor exposure"
-   interpreter
-   FUNCTION
-   setExpose
-   NIL
-   htSetExpose)
-@
-\section{functions}
-\begin{verbatim}
-             Current Values of  functions  Variables                  
-
-Variable     Description                           Current Value
------------------------------------------------------------------
-cache        number of function results to cache        0 
-compile      compile, don't just define function bodies off 
-recurrence   specially compile recurrence relations     on 
-
-\end{verbatim}
-<<functions>>=
-  (functions
-   "some interpreter function options"
-   interpreter
-   TREE
-   novar
-   (
-<<functionscache>>
-<<functionscompile>>
-<<functionsrecurrence>>
-  ))
-@
-\subsection{cache}
-\begin{verbatim}
----------------------- The cache Option -----------------------
-
- Description: number of function results to cache
-
- )set functions cache is used to tell AXIOM how many  values 
-  computed by interpreter functions should be saved.  This can 
-  save quite a bit of time in recursive functions, though one 
-  must consider that the cached values will take up (perhaps 
-  valuable) room in the workspace.
-
- The value given  after cache must either be the word all or 
- a positive integer. This may be followed by any number of 
- function names whose cache sizes you wish to so set.  If no 
- functions are given, the default cache  size is set.
-
- Examples:   )set fun cache all
-             )set fun cache 10 f g Legendre
-
- In general, functions will cache no returned values.
-\end{verbatim}
-<<functionscache>>=
-     (cache
-      "number of function results to cache"
-      interpreter
-      FUNCTION
-      setFunctionsCache
-      NIL
-      htSetCache)
-@
-\subsection{compile}
-Per suggestion by Bill Page this has been defaulted to [[on]].
-\begin{verbatim}
---------------------- The compile Option ----------------------
-
- Description: compile, don't just define function bodies
-
- The compile option may be followed by any one of the following:
-
- -> on
-    off 
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<functionscompile>>=
-     (compile
-      "compile, don't just define function bodies"
-      interpreter
-      LITERALS
-      $compileDontDefineFunctions
-      (on off)
-      on)
-@
-\subsection{recurrence}
-\begin{verbatim}
--------------------- The recurrence Option --------------------
-
- Description: specially compile recurrence relations
-
- The recurrence option may be followed by any one of the 
- following:
-
- -> on 
-    off
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<functionsrecurrence>>=
-     (recurrence
-      "specially compile recurrence relations"
-      interpreter
-      LITERALS
-      $compileRecurrence
-      (on off)
-      on)
-@
-\section{fortran}
-\begin{verbatim}
-              Current Values of  fortran  Variables                   
-
-Variable     Description                           Current Value
------------------------------------------------------------------
-ints2floats  where sensible, coerce integers to reals   on 
-fortindent   the number of characters indented          6 
-fortlength   the number of characters on a line         72 
-typedecs     print type and dimension lines             on 
-defaulttype  default generic type for FORTRAN object    REAL 
-precision    precision of generated FORTRAN objects     double 
-intrinsic    whether to use INTRINSIC FORTRAN functions off 
-explength    character limit for FORTRAN expressions    1320 
-segment      split long FORTRAN expressions             on 
-optlevel     FORTRAN optimisation level                 0 
-startindex   starting index for FORTRAN arrays          1 
-calling      options for external FORTRAN calls         ... 
-
-Variables with current values of ... have further sub-options. 
-For example, issue )set calling to see what the options are for 
-calling.
-For more information, issue )help set .
-\end{verbatim}
-<<fortran>>=
-  (fortran
-   "view and set options for FORTRAN output"
-   interpreter
-   TREE
-   novar
-    (
-<<fortranints2floats>>
-<<fortranfortindent>>
-<<fortranfortlength>>
-<<fortrantypedecs>>
-<<fortrandefaulttype>>
-<<fortranprecision>>
-<<fortranintrinsic>>
-<<fortranexplength>>
-<<fortransegment>>
-<<fortranoptlevel>>
-<<fortranstartindex>>
-<<fortrancalling>>
-  ))
-@
-\subsection{ints2floats}
-\begin{verbatim}
-------------------- The ints2floats Option --------------------
-
- Description: where sensible, coerce integers to reals
-
- The ints2floats option may be followed by any one of the 
- following:
-
- -> on 
-    off
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<fortranints2floats>>=
-     (ints2floats
-      "where sensible, coerce integers to reals"
-      interpreter
-      LITERALS
-      $fortInts2Floats
-      (on off)
-      on)
-@
-\subsection{fortindent}
-\begin{verbatim}
--------------------- The fortindent Option --------------------
-
- Description: the number of characters indented
-
- The fortindent option may be followed by an integer in the range 
- 0 to inclusive. The current setting is 6 
-
-\end{verbatim}
-<<fortranfortindent>>=
-     (fortindent
-      "the number of characters indented"
-      interpreter
-      INTEGER
-      $fortIndent
-      (0 NIL)
-      6)
-@
-\subsection{fortlength}
-\begin{verbatim}
--------------------- The fortlength Option --------------------
-
- Description: the number of characters on a line
-
- The fortlength option may be followed by an integer in the range 
- 1 to inclusive. The current setting is 72 
-
-\end{verbatim}
-<<fortranfortlength>>=
-     (fortlength
-      "the number of characters on a line"
-      interpreter
-      INTEGER
-      $fortLength
-      (1 NIL)
-      72)
-@
-\subsection{typedecs}
-\begin{verbatim}
---------------------- The typedecs Option ---------------------
-
- Description: print type and dimension lines
-
- The typedecs option may be followed by any one of the 
- following:
-
- -> on 
-    off
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<fortrantypedecs>>=
-     (typedecs
-      "print type and dimension lines"
-      interpreter
-      LITERALS
-      $printFortranDecs
-      (on off)
-      on)
-@
-\subsection{defaulttype}
-\begin{verbatim}
-------------------- The defaulttype Option --------------------
-
- Description: default generic type for FORTRAN object
-
- The defaulttype option may be followed by any one of the 
- following:
-
- -> REAL 
-    INTEGER
-    COMPLEX
-    LOGICAL
-    CHARACTER
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<fortrandefaulttype>>=
-     (defaulttype
-      "default generic type for FORTRAN object"
-      interpreter
-      LITERALS
-      $defaultFortranType
-      (REAL INTEGER COMPLEX LOGICAL CHARACTER)
-      REAL)
-@
-\subsection{precision}
-\begin{verbatim}
--------------------- The precision Option ---------------------
-
- Description: precision of generated FORTRAN objects
-
- The precision option may be followed by any one of the 
- following:
-
-    single
- -> double 
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<fortranprecision>>=
-      (precision
-      "precision of generated FORTRAN objects"
-       interpreter
-       LITERALS
-       $fortranPrecision
-       (single double)
-       double)
-@
-\subsection{intrinsic}
-\begin{verbatim}
--------------------- The intrinsic Option ---------------------
-
- Description: whether to use INTRINSIC FORTRAN functions
-
- The intrinsic option may be followed by any one of the 
- following:
-
-    on
- -> off 
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<fortranintrinsic>>=
-      (intrinsic
-       "whether to use INTRINSIC FORTRAN functions"
-       interpreter
-       LITERALS
-       $useIntrinsicFunctions
-       (on off)
-       off)
-@
-\subsection{explength}
-\begin{verbatim}
--------------------- The explength Option ---------------------
-
- Description: character limit for FORTRAN expressions
-
- The explength option may be followed by an integer in the range 
- 0 to inclusive. The current setting is 1320 
-
-\end{verbatim}
-<<fortranexplength>>=
-      (explength
-       "character limit for FORTRAN expressions"
-       interpreter
-       INTEGER
-       $maximumFortranExpressionLength
-       (0 NIL)
-       1320)
-@
-\subsection{segment}
-\begin{verbatim}
---------------------- The segment Option ----------------------
-
- Description: split long FORTRAN expressions
-
- The segment option may be followed by any one of the following:
-
- -> on 
-    off
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<fortransegment>>=
-      (segment
-       "split long FORTRAN expressions"
-       interpreter
-       LITERALS
-       $fortranSegment
-       (on off)
-       on)
-@
-\subsection{optlevel}
-\begin{verbatim}
---------------------- The optlevel Option ---------------------
-
- Description: FORTRAN optimisation level
-
- The optlevel option may be followed by an integer in the range 
- 0 to 2 inclusive. The current setting is 0 
-
-\end{verbatim}
-<<fortranoptlevel>>=
-      (optlevel
-       "FORTRAN optimisation level"
-       interpreter
-       INTEGER
-       $fortranOptimizationLevel
-       (0 2)
-       0)
-@
-\subsection{startindex}
-\begin{verbatim}
--------------------- The startindex Option --------------------
-
- Description: starting index for FORTRAN arrays
-
- The startindex option may be followed by an integer in the range 
- 0 to 1 inclusive. The current setting is 1 
-
-\end{verbatim}
-<<fortranstartindex>>=
-      (startindex
-       "starting index for FORTRAN arrays"
-       interpreter
-       INTEGER
-       $fortranArrayStartingIndex
-       (0 1)
-       1)
-@
-\subsection{calling}
-\begin{verbatim}
-              Current Values of  calling  Variables                   
-
-Variable     Description                           Current Value
------------------------------------------------------------------
-tempfile     set location of temporary data files       /tmp/ 
-directory    set location of generated FORTRAN files    ./ 
-linker       linker arguments (e.g. libraries to search) -lxlf 
-
-\end{verbatim}
-<<fortrancalling>>=
-      (calling
-      "options for external FORTRAN calls"
-      interpreter
-      TREE
-      novar
-      (
-<<callingtempfile>>
-<<callingdirectory>>
-<<callinglinker>>
-       )
-      )
-@
-\subsubsection{tempfile}
-\begin{verbatim}
---------------------- The tempfile Option ---------------------
-
- Description: set location of temporary data files
-
- )set fortran calling tempfile  is used to tell AXIOM where
- to place intermediate FORTRAN data files . This must be the 
- name of a valid existing directory to which you have permission 
- to write (including the final slash).
-
- Syntax:
-   )set fortran calling tempfile DIRECTORYNAME
-
- The current setting is /tmp/ 
-\end{verbatim}
-<<callingtempfile>>=
-        (tempfile
-         "set location of temporary data files"
-         interpreter
-         FUNCTION
-         setFortTmpDir
-         (("enter directory name for which you have write-permission"
-           DIRECTORY
-           $fortranTmpDir
-           chkDirectory
-           "/tmp/"))
-         NIL)
-@
-\subsubsection{directory}
-\begin{verbatim}
--------------------- The directory Option ---------------------
-
- Description: set location of generated FORTRAN files
-
- )set fortran calling directory  is used to tell AXIOM where
- to place generated FORTRAN files. This must be the name 
- of a valid existing directory to which you have permission 
- to write (including the final slash).
-
- Syntax:
-   )set fortran calling directory DIRECTORYNAME
-
- The current setting is ./ 
-\end{verbatim}
-<<callingdirectory>>=
-        (directory
-         "set location of generated FORTRAN files"
-         interpreter
-         FUNCTION
-         setFortDir
-         (("enter directory name for which you have write-permission"
-           DIRECTORY
-           $fortranDirectory
-           chkDirectory
-           "./"))
-         NIL)
-@
-\subsubsection{linker}
-\begin{verbatim}
----------------------- The linker Option ----------------------
-
- Description: linker arguments (e.g. libraries to search)
-
- )set fortran calling linkerargs is used to pass arguments to 
- the linker when using  mkFort  to create functions which call 
- Fortran code. For example, it might give a list of libraries 
- to be searched, and their locations.
- The string is passed verbatim, so must be the correct syntax for
- the particular linker being used.
-
- Example: )set fortran calling linker "-lxlf"
-
- The current setting is -lxlf 
-\end{verbatim}
-<<callinglinker>>=
-        (linker
-         "linker arguments (e.g. libraries to search)"
-         interpreter
-         FUNCTION
-         setLinkerArgs
-         (("enter linker arguments "
-           STRING
-           $fortranLibraries
-           chkDirectory
-           "-lxlf"))
-         NIL
-         )
-@
-\section{kernel}
-\begin{verbatim}
-              Current Values of  kernel  Variables                    
-
-Variable     Description                           Current Value
------------------------------------------------------------------
-warn         warn when re-definition is attempted       off 
-protect      prevent re-definition of kernel functions  off 
-
-\end{verbatim}
-<<kernel>>=
-  (kernel
-   "library functions built into the kernel for efficiency"
-   interpreter
-   TREE
-   novar
-   (
-<<kernelwarn>>
-<<kernelprotect>>
-   )
-  )
-@
-\subsection{kernelwarn}
-\begin{verbatim}
------------------------ The warn Option -----------------------
-
- Description: warn when re-definition is attempted
-
-Some AXIOM library functions are compiled into the kernel for 
-efficiency reasons. To prevent them being re-defined when loaded 
-from a library they are specially protected. If a user wishes to 
-know when an attempt is made to re-define such a function, he or 
-she should issue the command:
-        )set kernel warn on
-To restore the default behaviour, he or she should issue the 
-command:
-        )set kernel warn off
-\end{verbatim}
-<<kernelwarn>>=
-     (warn
-      "warn when re-definition is attempted"
-      interpreter
-      FUNCTION
-      protectedSymbolsWarning
-      NIL
-      htSetKernelWarn)
-@
-\subsection{kernelprotect}
-\begin{verbatim}
---------------------- The protect Option ----------------------
-
- Description: prevent re-definition of kernel functions
-
-Some AXIOM library functions are compiled into the kernel for 
-efficiency reasons. To prevent them being re-defined when loaded
-from a library they are specially protected.  If a user wishes 
-to re-define these functions, he or she should issue the command:
-        )set kernel protect off
-To restore the default behaviour, he or she should issue the 
-command:
-        )set kernel protect on
-\end{verbatim}
-<<kernelprotect>>=
-     (protect
-      "prevent re-definition of kernel functions"
-      interpreter
-      FUNCTION
-      protectSymbols
-      NIL
-      htSetKernelProtect)
-@
-\section{hyperdoc}
-\begin{verbatim}
-             Current Values of  hyperdoc  Variables                   
-
-Variable     Description                           Current Value
------------------------------------------------------------------
-fullscreen   use full screen for this facility          off 
-mathwidth    screen width for history output            120 
-
-\end{verbatim}
-<<hyperdoc>>=
-  (hyperdoc
-   "options in using HyperDoc"
-   interpreter
-   TREE
-   novar
-   (
-<<hyperdocfullscreen>>
-<<hyperdocmathwidth>>
-   ))
-@
-\subsection{fullscreen}
-\begin{verbatim}
--------------------- The fullscreen Option --------------------
-
- Description: use full screen for this facility
-
- The fullscreen option may be followed by any one of the 
- following:
-
-    on
- -> off 
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<hyperdocfullscreen>>=
-     (fullscreen
-      "use full screen for this facility"
-      interpreter
-      LITERALS
-      $fullScreenSysVars
-      (on off)
-      off)
-@
-\subsection{mathwidth}
-\begin{verbatim}
--------------------- The mathwidth Option ---------------------
-
- Description: screen width for history output
-
- The mathwidth option may be followed by an integer in the range 
- 0 to inclusive. The current setting is 120 
-
-\end{verbatim}
-<<hyperdocmathwidth>>=
-     (mathwidth
-      "screen width for history output"
-      interpreter
-      INTEGER
-      $historyDisplayWidth
-      (0 NIL)
-      120)
-@
-\section{help}
-\begin{verbatim}
-               Current Values of  help  Variables                     
-
-Variable     Description                           Current Value
------------------------------------------------------------------
-fullscreen   use fullscreen facility, if possible       off 
-
-\end{verbatim}
-<<help>>=
-  (help
-   "view and set some help options"
-   interpreter
-   TREE
-   novar
-   (
-<<helpfullscreen>>
-   ))
-@
-\subsection{fullscreen}
-\begin{verbatim}
--------------------- The fullscreen Option --------------------
-
- Description: use fullscreen facility, if possible
-
- The fullscreen option may be followed by any one of the 
- following:
-
-    on
- -> off 
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<helpfullscreen>>=
-    (fullscreen
-     "use fullscreen facility, if possible"
-     interpreter
-     LITERALS
-     $useFullScreenHelp
-     (on off)
-     off)
-@
-\section{history}
-\begin{verbatim}
---------------------- The history Option ----------------------
-
- Description: save workspace values in a history file
-
- The history option may be followed by any one of the 
- following:
-
- -> on 
-    off
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<history>>=
-  (history
-   "save workspace values in a history file"
-   interpreter
-   LITERALS
-   $HiFiAccess
-   (on off)
-   on)
-@
-\section{messages}
-\begin{verbatim}
-             Current Values of  messages  Variables                   
-
-Variable     Description                           Current Value
------------------------------------------------------------------
-autoload     print file auto-load messages              off 
-bottomup     display bottom up modemap selection        off 
-coercion     display datatype coercion messages         off 
-dropmap      display old map defn when replaced         off 
-expose       warning for unexposed functions            off 
-file         print msgs also to SPADMSG LISTING         off 
-frame        display messages about frames              off 
-highlighting use highlighting in system messages        off 
-instant      present instantiation summary              off 
-insteach     present instantiation info                 off 
-interponly   say when function code is interpreted      on 
-number       display message number with message        off 
-prompt       set type of input prompt to display        step 
-selection    display function selection msgs            off 
-set          show )set setting after assignment         off 
-startup      display messages on start-up               off 
-summary      print statistics after computation         off 
-testing      print system testing header                off 
-time         print timings after computation            off 
-type         print type after computation               on 
-void         print Void value when it occurs            off 
-any          print the internal type of objects of domain Any on 
-naglink      show NAGLink messages                      on 
-
-\end{verbatim}
-<<messages>>=
-  (messages
-   "show messages for various system features"
-   interpreter
-   TREE
-   novar
-   (
-<<messagesany>>
-<<messagesautoload>>
-<<messagesbottomup>>
-<<messagescoercion>>
-<<messagesdropmap>>
-<<messagesexpose>>
-<<messagesfile>>
-<<messagesframe>>
-<<messageshighlighting>>
-<<messagesinstant>>
-<<messagesinsteach>>
-<<messagesinterponly>>
-<<messagesnaglink>>
-<<messagesnumber>>
-<<messagesprompt>>
-<<messagesselection>>
-<<messagesset>>
-<<messagesstartup>>
-<<messagessummary>>
-<<messagestesting>>
-<<messagestime>>
-<<messagestype>>
-<<messagesvoid>>
-   ))
-@
-\subsection{any}
-\begin{verbatim}
------------------------ The any Option ------------------------
-
- Description: print the internal type of objects of domain Any
-
- The any option may be followed by any one of the following:
-
- -> on 
-    off
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<messagesany>>=
-     (any
-      "print the internal type of objects of domain Any"
-      interpreter
-      LITERALS
-      $printAnyIfTrue
-      (on off)
-      on)
-@
-\subsection{autoload}
-\begin{verbatim}
---------------------- The autoload Option ---------------------
-
- Description: print file auto-load messages
-
-\end{verbatim}
-<<messagesautoload>>=
-     (autoload
-      "print file auto-load messages"
-      interpreter
-      FUNCTION
-      printLoadMessages
-      (on off)
-      on)
-@
-\subsection{bottomup}
-\begin{verbatim}
---------------------- The bottomup Option ---------------------
-
- Description: display bottom up modemap selection
-
- The bottomup option may be followed by any one of the 
- following:
-
-    on
- -> off 
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<messagesbottomup>>=
-     (bottomup
-      "display bottom up modemap selection"
-      development
-      LITERALS
-      $reportBottomUpFlag
-      (on off)
-      off)
-@
-\subsection{coercion}
-\begin{verbatim}
---------------------- The coercion Option ---------------------
-
- Description: display datatype coercion messages
-
- The coercion option may be followed by any one of the 
- following:
-
-    on
- -> off 
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<messagescoercion>>=
-     (coercion
-      "display datatype coercion messages"
-      development
-      LITERALS
-      $reportCoerceIfTrue
-      (on off)
-      off)
-@
-\subsection{dropmap}
-\begin{verbatim}
---------------------- The dropmap Option ----------------------
-
- Description: display old map defn when replaced
-
- The dropmap option may be followed by any one of the 
- following:
-
-    on
- -> off 
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<messagesdropmap>>=
-     (dropmap
-      "display old map defn when replaced"
-      interpreter
-      LITERALS
-      $displayDroppedMap
-      (on off)
-      off)
-@
-\subsection{expose}
-\begin{verbatim}
----------------------- The expose Option ----------------------
-
- Description: warning for unexposed functions
-
- The expose option may be followed by any one of the 
- following:
-
-    on
- -> off 
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<messagesexpose>>=
-     (expose
-      "warning for unexposed functions"
-      interpreter
-      LITERALS
-      $giveExposureWarning
-      (on off)
-      off)
-@
-\subsection{file}
-\begin{verbatim}
------------------------ The file Option -----------------------
-
- Description: print msgs also to SPADMSG LISTING
-
- The file option may be followed by any one of the 
- following:
-
-    on
- -> off 
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<messagesfile>>=
-     (file
-      "print msgs also to SPADMSG LISTING"
-      development
-      LITERALS
-      $printMsgsToFile
-      (on off)
-      off)
-@
-\subsection{frame}
-\begin{verbatim}
----------------------- The frame Option -----------------------
-
- Description: display messages about frames
-
- The frame option may be followed by any one of the following:
-
-    on
- -> off 
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<messagesframe>>=
-     (frame
-      "display messages about frames"
-      interpreter
-      LITERALS
-      $frameMessages
-      (on off)
-      off)
-@
-\subsection{highlighting}
-\begin{verbatim}
-------------------- The highlighting Option -------------------
-
- Description: use highlighting in system messages
-
- The highlighting option may be followed by any one of the 
- following:
-
-    on
- -> off 
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<messageshighlighting>>=
-     (highlighting
-      "use highlighting in system messages"
-      interpreter
-      LITERALS
-      $highlightAllowed
-      (on off)
-      off)
-@
-\subsection{instant}
-\begin{verbatim}
---------------------- The instant Option ----------------------
-
- Description: present instantiation summary
-
- The instant option may be followed by any one of the 
- following:
-
-    on
- -> off 
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<messagesinstant>>=
-     (instant
-      "present instantiation summary"
-      development
-      LITERALS
-      $reportInstantiations
-      (on off)
-      off)
-@
-\subsection{insteach}
-\begin{verbatim}
---------------------- The insteach Option ---------------------
-
- Description: present instantiation info
-
- The insteach option may be followed by any one of the 
- following:
-
-    on
- -> off 
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<messagesinsteach>>=
-     (insteach
-      "present instantiation info"
-      development
-      LITERALS
-      $reportEachInstantiation
-      (on off)
-      off)
-@
-\subsection{interponly}
-\begin{verbatim}
--------------------- The interponly Option --------------------
-
- Description: say when function code is interpreted
-
- The interponly option may be followed by any one of the 
- following:
-
- -> on 
-    off
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<messagesinterponly>>=
-     (interponly
-      "say when function code is interpreted"
-      interpreter
-      LITERALS
-      $reportInterpOnly
-      (on off)
-      on)
-@
-\subsection{naglink}
-\begin{verbatim}
---------------------- The naglink Option ----------------------
-
- Description: show NAGLink messages
-
- The naglink option may be followed by any one of the 
- following:
-
- -> on 
-    off
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<messagesnaglink>>=
-     (naglink
-      "show NAGLink messages"
-      interpreter
-      LITERALS
-      $nagMessages
-      (on off)
-      on)
-@
-\subsection{number}
-\begin{verbatim}
----------------------- The number Option ----------------------
-
- Description: display message number with message
-
- The number option may be followed by any one of the 
- following:
-
-    on
- -> off 
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<messagesnumber>>=
-     (number
-      "display message number with message"
-      interpreter
-      LITERALS
-      $displayMsgNumber
-      (on off)
-      off)
-@
-\subsection{prompt}
-\begin{verbatim}
----------------------- The prompt Option ----------------------
-
- Description: set type of input prompt to display
-
- The prompt option may be followed by any one of the following:
-
-    none
-    frame
-    plain
- -> step 
-    verbose
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<messagesprompt>>=
-     (prompt
-      "set type of input prompt to display"
-      interpreter
-      LITERALS
-      $inputPromptType
-      (none frame plain step verbose)
-      step)
-@
-\subsection{selection}
-\begin{verbatim}
--------------------- The selection Option ---------------------
-
- Description: display function selection msgs
-
- The selection option may be followed by any one of the 
- following:
-
-    on
- -> off 
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<messagesselection>>=
-     (selection
-      "display function selection msgs"
-      interpreter
-      LITERALS
-      $reportBottomUpFlag
-      (on off)
-      off)
-@
-\subsection{set}
-\begin{verbatim}
------------------------ The set Option ------------------------
-
- Description: show )set setting after assignment
-
- The set option may be followed by any one of the following:
-
-    on
- -> off 
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<messagesset>>=
-     (set
-      "show )set setting after assignment"
-      interpreter
-      LITERALS
-      $displaySetValue
-      (on off)
-      off)
-@
-\subsection{startup}
-\begin{verbatim}
---------------------- The startup Option ----------------------
-
- Description: display messages on start-up
-
- The startup option may be followed by any one of the 
- following:
-
-    on
- -> off 
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<messagesstartup>>=
-     (startup
-      "display messages on start-up"
-      interpreter
-      LITERALS
-      $displayStartMsgs
-      (on off)
-      on)
-@
-\subsection{summary}
-\begin{verbatim}
---------------------- The summary Option ----------------------
-
- Description: print statistics after computation
-
- The summary option may be followed by any one of the 
- following:
-
-    on
- -> off 
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<messagessummary>>=
-     (summary
-      "print statistics after computation"
-      interpreter
-      LITERALS
-      $printStatisticsSummaryIfTrue
-      (on off)
-      off)
-@
-\subsection{testing}
-\begin{verbatim}
---------------------- The testing Option ----------------------
-
- Description: print system testing header
-
- The testing option may be followed by any one of the 
- following:
-
-    on
- -> off 
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<messagestesting>>=
-     (testing
-      "print system testing header"
-      development
-      LITERALS
-      $testingSystem
-      (on off)
-      off)
-@
-\subsection{time}
-\begin{verbatim}
------------------------ The time Option -----------------------
-
- Description: print timings after computation
-
- The time option may be followed by any one of the following:
-
-    on
- -> off 
-    long
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<messagestime>>=
-     (time
-      "print timings after computation"
-      interpreter
-      LITERALS
-      $printTimeIfTrue
-      (on off long)
-      off)
-@
-\subsection{type}
-\begin{verbatim}
------------------------ The type Option -----------------------
-
- Description: print type after computation
-
- The type option may be followed by any one of the following:
-
- -> on 
-    off
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<messagestype>>=
-     (type
-      "print type after computation"
-      interpreter
-      LITERALS
-      $printTypeIfTrue
-      (on off)
-      on)
-@
-\subsection{void}
-\begin{verbatim}
------------------------ The void Option -----------------------
-
- Description: print Void value when it occurs
-
- The void option may be followed by any one of the following:
-
-    on
- -> off 
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<messagesvoid>>=
-     (void
-      "print Void value when it occurs"
-      interpreter
-      LITERALS
-      $printVoidIfTrue
-      (on off)
-      off)
-@
-\section{naglink}
-\begin{verbatim}
-              Current Values of  naglink  Variables                   
-
-Variable     Description                           Current Value
------------------------------------------------------------------
-host         internet address of host for NAGLink       localhost 
-persistence  number of (fortran) functions to remember  1 
-messages     show NAGLink messages                      on 
-double       enforce DOUBLE PRECISION ASPs              on 
-
-\end{verbatim}
-<<naglink>>=
-  (naglink
-   "options for NAGLink"
-   interpreter
-   TREE
-   novar
-   (
-<<naglinkhost>>
-<<naglinkpersistence>>
-<<naglinkmessages>>
-<<naglinkdouble>>
-   ))
-@
-\subsection{host}
-\begin{verbatim}
------------------------ The host Option -----------------------
-
- Description: internet address of host for NAGLink
-
- )set naglink host is used to tell  AXIOM which  host to contact
- for a NAGLink request. An Internet address should be supplied. 
- The host specified must be running the NAGLink daemon.
-
- The current setting is localhost 
-\end{verbatim}
-<<naglinkhost>>=
-     (host
-      "internet address of host for NAGLink"
-      interpreter
-      FUNCTION
-      setNagHost
-      (("enter host name"
-        DIRECTORY
-        $nagHost
-        chkDirectory
-        "localhost"))
-      NIL)
-@
-\subsection{persistence}
-\begin{verbatim}
-------------------- The persistence Option --------------------
-
- Description: number of (fortran) functions to remember
-
- )set naglink persistence is used to tell  the  nagd  daemon how
-  many ASP source and object files to keep around in case you 
-  reuse them. This helps to avoid needless recompilations. The 
-  number specified should be a non-negative integer.
-
- The current setting is 1 
-\end{verbatim}
-<<naglinkpersistence>>=
-     (persistence
-      "number of (fortran) functions to remember"
-      interpreter
-      FUNCTION
-      setFortPers
-      (("Requested remote storage (for asps):"
-       INTEGER
-       $fortPersistence
-       (0 NIL)
-       10))
-      NIL)
-@
-\subsection{messages}
-\begin{verbatim}
---------------------- The messages Option ---------------------
-
- Description: show NAGLink messages
-
- The messages option may be followed by any one of the 
- following:
-
- -> on 
-    off
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<naglinkmessages>>=
-     (messages
-      "show NAGLink messages"
-      interpreter
-      LITERALS
-      $nagMessages
-      (on off)
-       on)
-@
-\subsection{double}
-\begin{verbatim}
----------------------- The double Option ----------------------
-
- Description: enforce DOUBLE PRECISION ASPs
-
- The double option may be followed by any one of the following:
-
- -> on 
-    off
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<naglinkdouble>>=
-     (double
-      "enforce DOUBLE PRECISION ASPs"
-      interpreter
-      LITERALS
-      $nagEnforceDouble
-      (on off)
-      on)
-@
-\section{output}
-The result of the {\bf )set output} command is:
-\begin{verbatim}
-Variable     Description                           Current Value
------------------------------------------------------------------
-abbreviate  abbreviate type names                    off 
-algebra     display output in algebraic form         On:CONSOLE 
-characters  choose special output character set      plain 
-script      display output in SCRIPT formula format  Off:CONSOLE 
-fortran     create output in FORTRAN format          Off:CONSOLE 
-fraction    how fractions are formatted              vertical 
-length      line length of output displays           77 
-scripts     show subscripts,... linearly             off 
-showeditor  view output of )show in editor           off 
-tex         create output in TeX style               Off:CONSOLE 
-mathml	    create output in MathML style	     Off:CONSOLE 
-\end{verbatim}
-Since the output option has a bunch of sub-options each suboption 
-is defined within the output structure.
-<<output>>=
-  (output
-   "view and set some output options"
-   interpreter
-   TREE
-   novar
-    (
-<<outputabbreviate>>
-<<outputalgebra>>
-<<outputcharacters>>
-<<outputfortran>>
-<<outputfraction>>
-<<outputlength>>
-<<outputopenmath>>
-<<outputscript>>
-<<outputscripts>>
-<<outputshoweditor>>
-<<outputtex>>
-<<outputmathml>>
- ))
-@
-\subsection{abbreviate}
-\begin{verbatim}
--------------------- The abbreviate Option --------------------
-
- Description: abbreviate type names
-
- The abbreviate option may be followed by any one of the 
- following:
-
-    on
- -> off 
-
- The current setting is indicated within the list.
-\end{verbatim}
-<<outputabbreviate>>=
-     (abbreviate
-      "abbreviate type names"
-      interpreter
-      LITERALS
-      $abbreviateTypes
-      (on off)
-      off)
-@
-\subsection{algebra}
-\begin{verbatim}
---------------------- The algebra Option ----------------------
-
- Description: display output in algebraic form
-
- )set output algebra is used to tell AXIOM to turn algebra-style
-  output printing on and off, and where to place the output.  By
-  default, the destination for the output is the screen but 
-  printing is turned off.
-
-Syntax:   )set output algebra <arg>
-    where arg can be one of
-  on          turn algebra printing on (default state)
-  off         turn algebra printing off
-  console     send algebra output to screen (default state)
-  fp<.fe>     send algebra output to file with file prefix fp
-              and file extension .fe. If not given, 
-              .fe defaults to .spout.
-
-If you wish to send the output to a file, you may need to issue
-this command twice: once with on and once with the file name. 
-For example, to send algebra output to the file polymer.spout,
-issue the two commands
-
-  )set output algebra on
-  )set output algebra polymer
-
-The output is placed in the directory from which you invoked 
-AXIOM or the one you set with the )cd system command.
-The current setting is:  On:CONSOLE 
-\end{verbatim}
-<<outputalgebra>>=
-     (algebra
-      "display output in algebraic form"
-      interpreter
-      FUNCTION
-      setOutputAlgebra
-      (("display output in algebraic form"
-        LITERALS
-        $algebraFormat
-        (off on)
-        on)
-       (break $algebraFormat)
-       ("where algebra printing goes (enter {\em console} or a pathname)?"
-        FILENAME
-        $algebraOutputFile
-        chkOutputFileName
-        "console"))
-      NIL)
-@
-\subsection{characters}
-\begin{verbatim}
--------------------- The characters Option --------------------
-
- Description: choose special output character set
-
-
- The characters option may be followed by any one of the 
- following:
-
-    default
- -> plain 
-
- The current setting is indicated within the list.  This 
- option  determines the special characters used for algebraic 
- output. This is what the current choice of special characters 
- looks like:
-   ulc is shown as +          urc is shown as +       
-   llc is shown as +          lrc is shown as +       
-   vbar is shown as |         hbar is shown as -      
-   quad is shown as ?         lbrk is shown as [      
-   rbrk is shown as ]         lbrc is shown as {      
-   rbrc is shown as }         ttee is shown as +      
-   btee is shown as +         rtee is shown as +      
-   ltee is shown as +         ctee is shown as +      
-   bslash is shown as \    
-\end{verbatim}
-<<outputcharacters>>=
-     (characters
-      "choose special output character set"
-      interpreter
-      FUNCTION
-      setOutputCharacters
-      NIL
-      htSetOutputCharacters)
-@
-\subsection{fortran}
-\begin{verbatim}
---------------------- The fortran Option ----------------------
-
- Description: create output in FORTRAN format
-
- )set output fortran is used to tell AXIOM to turn FORTRAN-style
-  output printing on and off, and where to place the output.  By
-  default, the destination for the output is the screen but 
-  printing is turned off.
-
-Also See: )set fortran
-
-Syntax:   )set output fortran <arg>
-    where arg can be one of
-  on          turn FORTRAN printing on
-  off         turn FORTRAN printing off (default state)
-  console     send FORTRAN output to screen (default state)
-  fp<.fe>     send FORTRAN output to file with file prefix 
-              fp and file extension .fe. If not given, 
-              .fe defaults to .sfort.
-
-If you wish to send the output to a file, you must issue 
-this command twice: once with on and once with the file name.
-For example, to send FORTRAN output to the file polymer.sfort,
- issue the two commands
-
-  )set output fortran on
-  )set output fortran polymer
-
-The output is placed in the directory from which you invoked
-AXIOM or the one you set with the )cd system command.
-The current setting is:  Off:CONSOLE 
-\end{verbatim}
-<<outputfortran>>=
-     (fortran
-      "create output in FORTRAN format"
-      interpreter
-      FUNCTION
-      setOutputFortran
-      (("create output in FORTRAN format"
-        LITERALS
-        $fortranFormat
-        (off on)
-        off)
-       (break $fortranFormat)
-       ("where FORTRAN output goes (enter {\em console} or a a pathname)"
-        FILENAME
-        $fortranOutputFile
-        chkOutputFileName
-        "console"))
-      NIL)
-@
-\subsection{fraction}
-\begin{verbatim}
---------------------- The fraction Option ---------------------
-
- Description: how fractions are formatted
-
- The fraction option may be followed by any one of the following:
-
- -> vertical 
-    horizontal
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<outputfraction>>=
-     (fraction
-      "how fractions are formatted"
-      interpreter
-      LITERALS
-      $fractionDisplayType
-      (vertical horizontal)
-      vertical)
-@
-\subsection{length}
-\begin{verbatim}
----------------------- The length Option ----------------------
-
- Description: line length of output displays
-
- The length option may be followed by an integer in the range 
- 10 to 245 inclusive. The current setting is 77 
-
-\end{verbatim}
-<<outputlength>>=
-     (length
-      "line length of output displays"
-      interpreter
-      INTEGER
-      $LINELENGTH
-      (10 245)
-      77)
-@
-\subsection{mathml}
-\begin{verbatim}
------------------------ The mathml Option ------------------------
-
- Description: create output in MathML style
-
- )set output mathml is used to tell AXIOM to turn MathML-style output
-printing on and off, and where to place the output.  By default,
-the destination for the output is the screen but printing is 
-turned off.
-
-Syntax:   )set output mathml <arg>
-    where arg can be one of
-  on          turn MathML printing on
-  off         turn MathML printing off (default state)
-  console     send MathML output to screen (default state)
-  fp<.fe>     send MathML output to file with file prefix fp
-              and file extension .fe. If not given, 
-              .fe defaults to .smml.
-
-If you wish to send the output to a file, you must issue 
-this command twice: once with on and once with the file name. 
-For example, to send MathML output to the file polymer.smml, 
-issue the two commands
-
-  )set output mathml on
-  )set output mathml polymer
-
-The output is placed in the directory from which you invoked 
-AXIOM or the one you set with the )cd system command.
-The current setting is:  Off:CONSOLE 
-\end{verbatim}
-<<outputmathml>>=
-     (mathml
-      "create output in MathML style"
-      interpreter
-      FUNCTION
-      setOutputMathml
-      (("create output in MathML format"
-        LITERALS
-        $mathmlFormat
-        (off on)
-        off)
-       (break $mathmlFormat)
-       ("where MathML output goes (enter {\em console} or a pathname)"
-        FILENAME
-        $mathmlOutputFile
-        chkOutputFileName
-        "console"))
-      NIL)
-
-@
-\subsection{openmath}
-\begin{verbatim}
------------------------ The openmath Option ------------------------
-
- Description: create output in OpenMath style
-
- )set output tex is used to tell AXIOM to turn OpenMath output
-printing on and off, and where to place the output.  By default,
-the destination for the output is the screen but printing is 
-turned off.
-
-Syntax:   )set output tex <arg>
-    where arg can be one of
-  on          turn OpenMath printing on
-  off         turn OpenMath printing off (default state)
-  console     send OpenMath output to screen (default state)
-  fp<.fe>     send OpenMath output to file with file prefix fp
-              and file extension .fe. If not given, 
-              .fe defaults to .sopen.
-
-If you wish to send the output to a file, you must issue 
-this command twice: once with on and once with the file name. 
-For example, to send OpenMath output to the file polymer.sopen, 
-issue the two commands
-
-  )set output openmath on
-  )set output openmath polymer
-
-The output is placed in the directory from which you invoked 
-AXIOM or the one you set with the )cd system command.
-The current setting is:  Off:CONSOLE 
-\end{verbatim}
-<<outputopenmath>>=
-     (openmath
-      "create output in OpenMath style"
-      interpreter
-      FUNCTION
-      setOutputOpenMath
-      (("create output in OpenMath format"
-        LITERALS
-        $openMathFormat
-        (off on)
-        off)
-       (break $openMathFormat)
-       ("where TeX output goes (enter {\em console} or a pathname)"
-        FILENAME
-        $openMathOutputFile
-        chkOutputFileName
-        "console"))
-      NIL)
-@
-\subsection{script}
-\begin{verbatim}
----------------------- The script Option ----------------------
-
- Description: display output in SCRIPT formula format
-
- )set output script is used to tell AXIOM to turn IBM Script
- formula-style output printing on and off, and where to place
- the output.  By default, the destination for the output is the 
- screen but printing is turned off.
-
-Syntax:   )set output script <arg>
-    where arg can be one of
-  on      turn IBM Script formula printing on
-  off     turn IBM Script formula printing off 
-          (default state)
-  console send IBM Script formula output to screen 
-          (default state)
-  fp<.fe> send IBM Script formula output to file with file 
-          prefix fp and file extension .fe. If not given, 
-          .fe defaults to .sform.
-
-If you wish to send the output to a file, you must issue 
-this command twice: once with on and once with the file 
-name. For example, to send IBM Script formula output to 
-the file polymer.sform, issue the two commands
-
-  )set output script on
-  )set output script polymer
-
-The output is placed in the directory from which you 
-invoked AXIOM or the one you set with the )cd system command.
-The current setting is:  Off:CONSOLE 
-\end{verbatim}
-<<outputscript>>=
-     (script
-      "display output in SCRIPT formula format"
-      interpreter
-      FUNCTION
-      setOutputFormula
-      (("display output in SCRIPT format"
-        LITERALS
-        $formulaFormat
-        (off on)
-        off)
-       (break $formulaFormat)
-       ("where script output goes (enter {\em console} or a a pathname)"
-        FILENAME
-        $formulaOutputFile
-        chkOutputFileName
-        "console"))
-      NIL)
-@
-\subsection{scripts}
-\begin{verbatim}
---------------------- The scripts Option ----------------------
-
- Description: show subscripts,... linearly
-
- The scripts option may be followed by any one of the following:
-
-    yes
-    no
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<outputscripts>>=
-     (scripts
-      "show subscripts,... linearly"
-      interpreter
-      LITERALS
-      $linearFormatScripts
-      (yes no)
-      no)
-@
-\subsection{showeditor}
-\begin{verbatim}
--------------------- The showeditor Option --------------------
-
- Description: view output of )show in editor
-
- The showeditor option may be followed by any one of the 
- following:
-
-    on
- -> off 
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<outputshoweditor>>=
-     (showeditor
-      "view output of )show in editor"
-      interpreter
-      LITERALS
-      $useEditorForShowOutput
-      (on off)
-      off)
-@
-\subsection{tex}
-\begin{verbatim}
------------------------ The tex Option ------------------------
-
- Description: create output in TeX style
-
- )set output tex is used to tell AXIOM to turn TeX-style output
-printing on and off, and where to place the output.  By default,
-the destination for the output is the screen but printing is 
-turned off.
-
-Syntax:   )set output tex <arg>
-    where arg can be one of
-  on          turn TeX printing on
-  off         turn TeX printing off (default state)
-  console     send TeX output to screen (default state)
-  fp<.fe>     send TeX output to file with file prefix fp
-              and file extension .fe. If not given, 
-              .fe defaults to .stex.
-
-If you wish to send the output to a file, you must issue 
-this command twice: once with on and once with the file name. 
-For example, to send TeX output to the file polymer.stex, 
-issue the two commands
-
-  )set output tex on
-  )set output tex polymer
-
-The output is placed in the directory from which you invoked 
-AXIOM or the one you set with the )cd system command.
-The current setting is:  Off:CONSOLE 
-\end{verbatim}
-<<outputtex>>=
-     (tex
-      "create output in TeX style"
-      interpreter
-      FUNCTION
-      setOutputTex
-      (("create output in TeX format"
-        LITERALS
-        $texFormat
-        (off on)
-        off)
-       (break $texFormat)
-       ("where TeX output goes (enter {\em console} or a pathname)"
-        FILENAME
-        $texOutputFile
-        chkOutputFileName
-        "console"))
-      NIL)
-@
-\section{quit}
-\begin{verbatim}
------------------------ The quit Option -----------------------
-
- Description: protected or unprotected quit
-
- The quit option may be followed by any one of the following:
-
-    protected
- -> unprotected 
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<quit>>=
-  (quit
-   "protected or unprotected quit"
-   interpreter
-   LITERALS
-   $quitCommandType
-   (protected unprotected)
-   protected)
-@
-\section{streams}
-\begin{verbatim}
-              Current Values of  streams  Variables                   
-
-Variable     Description                           Current Value
------------------------------------------------------------------
-calculate    specify number of elements to calculate    10 
-showall      display all stream elements computed       off 
-
-\end{verbatim}
-<<streams>>=
-  (streams
-   "set some options for working with streams"
-   interpreter
-   TREE
-   novar
-   (
-<<streamscalculate>>
-<<streamsshowall>>
-  ))
-@
-\subsection{calculate}
-\begin{verbatim}
--------------------- The calculate Option ---------------------
-
- Description: specify number of elements to calculate
-
-   )set streams calculate is used to tell AXIOM how many elements
-    of a stream to calculate when a computation uses the stream. 
-    The value given after calculate must either be the word all 
-    or a positive integer.
-
-      The current setting is 10 .
-\end{verbatim}
-<<streamscalculate>>=
-     (calculate
-      "specify number of elements to calculate"
-      interpreter
-      FUNCTION
-      setStreamsCalculate
-      (("number of initial stream elements you want calculated"
-       INTEGER
-       $streamCount
-       (0 NIL)
-       10))
-      NIL)
-@
-\subsection{showall}
-\begin{verbatim}
---------------------- The showall Option ----------------------
-
- Description: display all stream elements computed
-
- The showall option may be followed by any one of the following:
-
-    on
- -> off 
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<streamsshowall>>=
-    (showall
-     "display all stream elements computed"
-     interpreter
-     LITERALS
-     $streamsShowAll
-     (on off)
-     off)
-@
-\section{system}
-\begin{verbatim}
-              Current Values of  system  Variables                    
-
-Variable     Description                           Current Value
------------------------------------------------------------------
-functioncode show gen. LISP for functions when compiled off 
-optimization show optimized LISP code                   off 
-prettyprint  prettyprint BOOT func's as they compile    off 
-
-\end{verbatim}
-<<system>>=
-  (system
-   "set some system development variables"
-   development
-   TREE
-   novar
-   (
-<<systemfunctioncode>>
-<<systemoptimization>>
-<<systemprettyprint>>
-   ))
-@
-\subsection{functioncode}
-\begin{verbatim}
-------------------- The functioncode Option -------------------
-
- Description: show gen. LISP for functions when compiled
-
- The functioncode option may be followed by any one of the 
- following:
-
-    on
- -> off 
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<systemfunctioncode>>=
-     (functioncode
-      "show gen. LISP for functions when compiled"
-      development
-      LITERALS
-      $reportCompilation
-      (on off)
-      off)
-@
-\subsection{optimization}
-\begin{verbatim}
-------------------- The optimization Option -------------------
-
- Description: show optimized LISP code
-
- The optimization option may be followed by any one of the 
- following:
-
-    on
- -> off 
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<systemoptimization>>=
-     (optimization
-      "show optimized LISP code"
-      development
-      LITERALS
-      $reportOptimization
-      (on off)
-      off)
-@
-\subsection{prettyprint}
-\begin{verbatim}
-------------------- The prettyprint Option --------------------
-
- Description: prettyprint BOOT func's as they compile
-
- The prettyprint option may be followed by any one of the 
- following:
-
-    on
- -> off 
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<systemprettyprint>>=
-     (prettyprint
-      "prettyprint BOOT func's as they compile"
-      development
-      LITERALS
-      $PRETTYPRINT
-      (on off)
-      off)
-@
-\section{userlevel}
-\begin{verbatim}
--------------------- The userlevel Option ---------------------
-
- Description: operation access level of system user
-
- The userlevel option may be followed by any one of the 
- following:
-
-    interpreter
-    compiler
- -> development 
-
- The current setting is indicated within the list.
-
-\end{verbatim}
-<<userlevel>>=
-  (userlevel
-   "operation access level of system user"
-   interpreter
-   LITERALS
-   $UserLevel
-   (interpreter compiler development)
-   development)
-@
-\section{License}
-<<license>>=
--- Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd.
--- All rights reserved.
---
--- Redistribution and use in source and binary forms, with or without
--- modification, are permitted provided that the following conditions are
--- met:
---
---     - Redistributions of source code must retain the above copyright
---       notice, this list of conditions and the following disclaimer.
---
---     - Redistributions in binary form must reproduce the above copyright
---       notice, this list of conditions and the following disclaimer in
---       the documentation and/or other materials provided with the
---       distribution.
---
---     - Neither the name of The Numerical ALgorithms Group Ltd. nor the
---       names of its contributors may be used to endorse or promote products
---       derived from this software without specific prior written permission.
---
--- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
--- IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
--- TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
--- PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
--- OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
--- EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
--- PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
--- PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
--- LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
--- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
--- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-@
 <<*>>=
-<<license>>
-
---% Table of )set options
-SETANDFILEQ($setOptions,'(
-<<breakmode>>
-<<compiler>>
-<<expose>>
-<<functions>>
-<<fortran>>
-<<kernel>>
-<<hyperdoc>>
-<<help>>
-<<history>>
-<<messages>>
-<<naglink>>
-<<output>>
-<<quit>>
-<<streams>>
-<<system>>
-<<userlevel>>
- ))
-
--- The following creates a list of option names in the above table.
-
-SETANDFILEQ($setOptionNames, [x.0 for x in $setOptions])
-
 EVALANDFILEACTQ (initializeSetVariables $setOptions)
 @
 \eject