diff --git a/books/bookvol5.pamphlet b/books/bookvol5.pamphlet
index abdca14..21bee4a 100644
--- a/books/bookvol5.pamphlet
+++ b/books/bookvol5.pamphlet
@@ -9439,6 +9439,69 @@ in practice.
 
 @
 
+\defun{printSynonyms}{printSynonyms}
+\calls{printSynonyms}{centerAndHighlight}
+\calls{printSynonyms}{specialChar}
+\calls{printSynonyms}{filterListOfStringsWithFn}
+\calls{printSynonyms}{synonymsForUserLevel}
+\calls{printSynonyms}{stringimage}
+\calls{printSynonyms}{printLabelledList}
+\usesdollar{printSynonyms}{CommandSynonymAlist}
+\usesdollar{printSynonyms}{linelength}
+<<defun printSynonyms>>=
+(defun |printSynonyms| (|patterns|)
+ (prog (|ls| t1)
+  (declare (special |$CommandSynonymAlist| $linelength))
+   (|centerAndHighlight| '|System Command Synonyms|
+                  $linelength (|specialChar| '|hbar|))
+   (setq |ls|
+    (|filterListOfStringsWithFn| |patterns|
+     (do ((t2 (|synonymsForUserLevel| |$CommandSynonymAlist|) (cdr t2)))
+         ((atom t2) (nreverse0 t1))
+        (push (cons (stringimage (caar t2)) (cdar t2)) t1))
+     (|function| car)))
+   (|printLabelledList| |ls| "user" "synonyms" ")" |patterns|)))
+
+@
+
+\defun{printLabelledList}{Print a list of each matching synonym}
+The prefix goes before each element on each side of the list, eg, ")"
+\calls{printLabelledList}{sayMessage}
+\calls{printLabelledList}{blankList}
+\calls{printLabelledList}{substring}
+\calls{printLabelledList}{entryWidth}
+\calls{printLabelledList}{sayBrightly}
+\calls{printLabelledList}{concat}
+\calls{printLabelledList}{fillerSpaces}
+<<defun printLabelledList>>=
+(defun |printLabelledList| (ls label1 label2 prefix patterns)
+ (let (comm syn wid)
+  (if (null ls)
+   (if (null patterns)
+    (|sayMessage| (list "   No " label1 "-defined " label2 " in effect."))
+    (|sayMessage|
+     `("   No " ,label1 "-defined " ,label2 " satisfying patterns:"
+       |%l| "     " |%b| ,@(append (|blankList| patterns) (list '|%d|)))))
+   (progn
+    (when patterns
+      (|sayMessage|
+       `(,label1 "-defined " ,label2 " satisfying patterns:" |%l| "   "
+          |%b| ,@(append (|blankList| patterns) (list '|%d|)))))
+     (do ((t1 ls (cdr t1)) (t2 nil))
+         ((atom t1) nil)
+      (setq syn (caar t1))
+      (setq comm (cdar t1))
+      (when (string= (substring syn 0 1) "|")
+       (setq syn (substring syn 1 nil)))
+      (when (string= syn "%i") (setq syn "%i "))
+      (setq wid (max (- 30 (|entryWidth| syn)) 1))
+      (|sayBrightly|
+       (|concat| '|%b| prefix syn '|%d| (|fillerSpaces| wid ".")
+         " " prefix comm)))
+     (|sayBrightly| "")))))
+
+@
+
 \defdollar{tokenCommands}
 This is a list of the commands that expect the interpreter to parse
 their arguments. Thus the history command expects that Axiom will have
@@ -21124,6 +21187,39 @@ o )what
 
 @
 
+\defun{displayOperationsFromLisplib}{displayOperationsFromLisplib}
+\calls{displayOperationsFromLisplib}{getdatabase}
+\calls{displayOperationsFromLisplib}{centerAndHighlight}
+\calls{displayOperationsFromLisplib}{specialChar}
+\calls{displayOperationsFromLisplib}{reportOpsFromUnitDirectly}
+\calls{displayOperationsFromLisplib}{remdup}
+\calls{displayOperationsFromLisplib}{msort}
+\calls{displayOperationsFromLisplib}{eqsubstlist}
+\calls{displayOperationsFromLisplib}{formatOperationAlistEntry}
+\calls{displayOperationsFromLisplib}{say2PerLine}
+\usesdollar{displayOperationsFromLisplib}{FormalMapVariableList}
+\usesdollar{displayOperationsFromLisplib}{linelength}
+<<defun displayOperationsFromLisplib>>=
+(defun |displayOperationsFromLisplib| (form)
+ (let (name argl kind opList opl ops)
+ (declare (special |$FormalMapVariableList| $linelength))
+  (setq name (car form))
+  (setq argl (cdr form))
+  (setq kind (getdatabase name 'constructorkind))
+  (|centerAndHighlight| "Operations" $linelength (|specialChar| '|hbar|))
+  (setq opList (getdatabase name 'operationalist))
+  (if (null opList)
+   (|reportOpsFromUnitDirectly| form)
+   (progn
+    (setq opl
+     (remdup (msort (eqsubstlist argl |$FormalMapVariableList| opList))))
+    (setq ops nil)
+    (dolist (x opl)
+     (setq ops (append ops (|formatOperationAlistEntry| x))))
+    (|say2PerLine| ops)))))
+
+@
+
 \defun{reportOpsFromUnitDirectly0}{reportOpsFromUnitDirectly0}
 \calls{reportOpsFromUnitDirectly0}{reportOpsFromUnitDirectly1}
 \calls{reportOpsFromUnitDirectly0}{reportOpsFromUnitDirectly}
@@ -21423,6 +21519,80 @@ o )what
 \fnref{set}
 \fnref{what}}
 
+\defun{synonym}{The )synonym command}
+\calls{synonym}{}
+<<defun synonym>>=
+(defun |synonym| (&rest ignore)
+ (declare (ignore ignore))
+ (|synonymSpad2Cmd|))
+
+@
+
+\defun{synonymSpad2Cmd}{The )synonym command implementation}
+\calls{synonymSpad2Cmd}{getSystemCommandLine}
+\calls{synonymSpad2Cmd}{printSynonyms}
+\calls{synonymSpad2Cmd}{processSynonymLine}
+\calls{synonymSpad2Cmd}{putalist}
+\calls{synonymSpad2Cmd}{terminateSystemCommand}
+\usesdollar{synonymSpad2Cmd}{CommandSynonymAlist}
+<<defun synonymSpad2Cmd>>=
+(defun |synonymSpad2Cmd| ()
+ (let (line pair)
+ (declare (special |$CommandSynonymAlist|))
+  (setq line (|getSystemCommandLine|))
+  (if (string= line "")
+   (|printSynonyms| nil)
+   (progn
+    (setq pair (|processSynonymLine| line))
+    (if |$CommandSynonymAlist|
+     (putalist |$CommandSynonymAlist| (car pair) (cdr pair))
+     (setq |$CommandSynonymAlist| (cons pair nil)))))
+  (|terminateSystemCommand|)))
+
+@
+
+
+\defun{processSynonymLine,removeKeyFromLine}{}
+\calls{processSynonymLine,removeKeyFromLine}{dropLeadingBlanks}
+\calls{processSynonymLine,removeKeyFromLine}{maxindex}
+\calls{processSynonymLine,removeKeyFromLine}{qsadd1}
+\calls{processSynonymLine,removeKeyFromLine}{qsgreaterp}
+<<defun processSynonymLine,removeKeyFromLine>>=
+(defun |processSynonymLine,removeKeyFromLine| (|line|)
+ (prog (|mx|)
+  (return
+   (seq
+    (setq |line| (|dropLeadingBlanks| |line|))
+    (setq |mx| (maxindex |line|))
+    (exit 
+     (do ((|i| 0 (qsadd1 |i|)))
+         ((qsgreaterp |i| |mx|) nil)
+       (seq
+        (exit
+         (if (char= (elt |line| |i|) #\space)
+          (exit
+           (return
+            (do ((|j| (PLUS |i| 1) (+ |j| 1)))
+                ((> |j| |mx|) nil)
+              (seq
+               (exit
+                (if (char\= (elt |line| |j|) #\space)
+                 (exit
+                  (return
+                   (substring |line| |j| nil))))))))))))))))))
+
+@
+
+\defun{processSynonymLine}{processSynonymLine}
+\calls{processSynonymLine}{processSynonymLine,removeKeyFromLine}
+<<defun processSynonymLine>>=
+(defun |processSynonymLine| (line)
+ (cons
+  (string2id-n line 1)
+  (|processSynonymLine,removeKeyFromLine| line)))
+
+@
+
 This command is in the list of \verb|$noParseCommands|
 \ref{noParseCommands} which means that its arguments are passed
 verbatim. This will eventually result in a call to the function
@@ -29077,6 +29247,7 @@ See Steele Common Lisp 1990 pp305-307
 <<defun displayMode>>
 <<defun displayModemap>>
 <<defun displayOperations>>
+<<defun displayOperationsFromLisplib>>
 <<defun displayProperties>>
 <<defun displayProperties,sayFunctionDeps>>
 <<defun displaySetOptionInformation>>
@@ -29437,10 +29608,14 @@ See Steele Common Lisp 1990 pp305-307
 <<defun pquit>>
 <<defun pquitSpad2Cmd>>
 <<defun previousInterpreterFrame>>
+<<defun printLabelledList>>
+<<defun printSynonyms>>
 <<defun processChPosesForOneLine>>
 <<defun processKeyedError>>
 <<defun processMsgList>>
 <<defun protectedSymbolsWarning>>
+<<defun processSynonymLine>>
+<<defun processSynonymLine,removeKeyFromLine>>
 <<defun processSynonyms>>
 <<defun protectSymbols>>
 <<defun prTraceNames>>
@@ -29638,6 +29813,8 @@ See Steele Common Lisp 1990 pp305-307
 <<defun substringMatch>>
 <<defun subTypes>>
 <<defun summary>>
+<<defun synonym>>
+<<defun synonymSpad2Cmd>>
 <<defun systemCommand>>
 
 <<defun ?t>>
diff --git a/changelog b/changelog
index 0a53bbe..66c5032 100644
--- a/changelog
+++ b/changelog
@@ -1,3 +1,6 @@
+20091230 tpd src/axiom-website/patches.html 20091230.01.tpd.patch
+20091230 tpd src/interp/i-syscmd.lisp treeshake
+20091230 tpd books/bookvol5 treeshake
 20091229 tpd src/axiom-website/patches.html 20091229.01.tpd.patch
 20091229 tpd src/interp/i-syscmd.lisp treeshake
 20091229 tpd books/bookvol5 treeshake
diff --git a/src/axiom-website/patches.html b/src/axiom-website/patches.html
index 8df5d0f..416619f 100644
--- a/src/axiom-website/patches.html
+++ b/src/axiom-website/patches.html
@@ -2340,5 +2340,7 @@ books/bookvol5 treeshake<br/>
 books/bookvol5 treeshake i-syscmd<br/>
 <a href="patches/20091229.01.tpd.patch">20091229.01.tpd.patch</a>
 books/bookvol5 treeshake i-syscmd<br/>
+<a href="patches/20091230.01.tpd.patch">20091230.01.tpd.patch</a>
+books/bookvol5 treeshake i-syscmd<br/>
  </body>
 </html>
diff --git a/src/interp/i-syscmd.lisp.pamphlet b/src/interp/i-syscmd.lisp.pamphlet
index 04223be..d2dc033 100644
--- a/src/interp/i-syscmd.lisp.pamphlet
+++ b/src/interp/i-syscmd.lisp.pamphlet
@@ -223,484 +223,6 @@
                          (CONS (|fillerSpaces| 29 (MAKESTRING "."))
                                (CONS '| | (CONS |$streamCount| NIL))))))))))
 
-;reportOpsFromLisplib(op,u) ==
-;  null(fn:= constructor? op) => sayKeyedMsg("S2IZ0054",[u])
-;  argml :=
-;    (s := getConstructorSignature op) => KDR s
-;    NIL
-;  typ:= GETDATABASE(op,'CONSTRUCTORKIND)
-;  nArgs:= #argml
-;  argList:= KDR GETDATABASE(op,'CONSTRUCTORFORM)
-;  functorForm:= [op,:argList]
-;  argml:= EQSUBSTLIST(argList,$FormalMapVariableList,argml)
-;  functorFormWithDecl:= [op,:[[":",a,m] for a in argList for m in argml]]
-;  sayBrightly concat(bright form2StringWithWhere functorFormWithDecl,
-;                     '" is a",bright typ,'"constructor")
-;  sayBrightly ['" Abbreviation for",:bright op,'"is",:bright fn]
-;  verb :=
-;    isExposedConstructor op => '"is"
-;    '"is not"
-;  sayBrightly ['" This constructor",:bright verb,
-;    '"exposed in this frame."]
-;  sourceFile := GETDATABASE(op,'SOURCEFILE)
-;  sayBrightly ['" Issue",:bright STRCONC('")edit ",
-;    namestring sourceFile),
-;      '"to see algebra source code for",:bright fn,'%l]
-;  for [opt] in $options repeat
-;    opt := selectOptionLC(opt,$showOptions,'optionError)
-;    opt = 'layout =>
-;      dc1 fn
-;    opt = 'views => sayBrightly ['"To get",:bright '"views",
-;      '"you must give parameters of constructor"]
-;    opt = 'attributes =>
-;      centerAndHighlight('"Attributes",$LINELENGTH,specialChar 'hbar)
-;      sayBrightly '""
-;      attList:= REMDUP MSORT [x for [x,:.] in
-;        GETDATABASE(op,'ATTRIBUTES)]
-;      null attList => sayBrightly
-;        concat('%b,form2String functorForm,'%d,"has no attributes.",'%l)
-;      say2PerLine [formatAttribute x for x in attList]
-;      NIL
-;    opt = 'operations => displayOperationsFromLisplib functorForm
-;    nil
-
-;(DEFUN |reportOpsFromLisplib| (|op| |u|)
-;  (PROG (|fn| |s| |typ| |nArgs| |argList| |functorForm| |argml|
-;              |functorFormWithDecl| |verb| |sourceFile| |opt| |x| |attList|)
-;  (declare (special $LINELENGTH |$showOptions| |$options|
-;                    |$FormalMapVariableList|))
-;    (RETURN
-;      (SEQ (COND
-;             ((NULL (SPADLET |fn| (|constructor?| |op|)))
-;              (|sayKeyedMsg| 'S2IZ0054 (CONS |u| NIL)))
-;             ('T
-;              (SPADLET |argml|
-;                       (COND
-;                         ((SPADLET |s|
-;                                   (|getConstructorSignature| |op|))
-;                          (KDR |s|))
-;                         ('T NIL)))
-;              (SPADLET |typ| (GETDATABASE |op| 'CONSTRUCTORKIND))
-;              (SPADLET |nArgs| (|#| |argml|))
-;              (SPADLET |argList|
-;                       (KDR (GETDATABASE |op| 'CONSTRUCTORFORM)))
-;              (SPADLET |functorForm| (CONS |op| |argList|))
-;              (SPADLET |argml|
-;                       (EQSUBSTLIST |argList| |$FormalMapVariableList|
-;                           |argml|))
-;              (SPADLET |functorFormWithDecl|
-;                       (CONS |op|
-;                             (PROG (G166872)
-;                               (SPADLET G166872 NIL)
-;                               (RETURN
-;                                 (DO ((G166878 |argList|
-;                                       (CDR G166878))
-;                                      (|a| NIL)
-;                                      (G166879 |argml|
-;                                       (CDR G166879))
-;                                      (|m| NIL))
-;                                     ((OR (ATOM G166878)
-;                                       (PROGN
-;                                         (SETQ |a| (CAR G166878))
-;                                         NIL)
-;                                       (ATOM G166879)
-;                                       (PROGN
-;                                         (SETQ |m| (CAR G166879))
-;                                         NIL))
-;                                      (NREVERSE0 G166872))
-;                                   (SEQ
-;                                    (EXIT
-;                                     (SETQ G166872
-;                                      (CONS
-;                                       (CONS '|:|
-;                                        (CONS |a| (CONS |m| NIL)))
-;                                       G166872)))))))))
-;              (|sayBrightly|
-;                  (|concat|
-;                      (|bright|
-;                          (|form2StringWithWhere|
-;                              |functorFormWithDecl|))
-;                      (MAKESTRING " is a") (|bright| |typ|)
-;                      (MAKESTRING "constructor")))
-;              (|sayBrightly|
-;                  (CONS (MAKESTRING " Abbreviation for")
-;                        (APPEND (|bright| |op|)
-;                                (CONS (MAKESTRING "is")
-;                                      (|bright| |fn|)))))
-;              (SPADLET |verb|
-;                       (COND
-;                         ((|isExposedConstructor| |op|)
-;                          (MAKESTRING "is"))
-;                         ('T (MAKESTRING "is not"))))
-;              (|sayBrightly|
-;                  (CONS (MAKESTRING " This constructor")
-;                        (APPEND (|bright| |verb|)
-;                                (CONS (MAKESTRING
-;                                       "exposed in this frame.")
-;                                      NIL))))
-;              (SPADLET |sourceFile| (GETDATABASE |op| 'SOURCEFILE))
-;              (|sayBrightly|
-;                  (CONS (MAKESTRING " Issue")
-;                        (APPEND (|bright|
-;                                    (STRCONC (MAKESTRING ")edit ")
-;                                     (|namestring| |sourceFile|)))
-;                                (CONS (MAKESTRING
-;                                       "to see algebra source code for")
-;                                      (APPEND (|bright| |fn|)
-;                                       (CONS '|%l| NIL))))))
-;              (DO ((G166896 |$options| (CDR G166896))
-;                   (G166863 NIL))
-;                  ((OR (ATOM G166896)
-;                       (PROGN (SETQ G166863 (CAR G166896)) NIL)
-;                       (PROGN
-;                         (PROGN
-;                           (SPADLET |opt| (CAR G166863))
-;                           G166863)
-;                         NIL))
-;                   NIL)
-;                (SEQ (EXIT (PROGN
-;                             (SPADLET |opt|
-;                                      (|selectOptionLC| |opt|
-;                                       |$showOptions| '|optionError|))
-;                             (COND
-;                               ((BOOT-EQUAL |opt| '|layout|)
-;                                (|dc1| |fn|))
-;                               ((BOOT-EQUAL |opt| '|views|)
-;                                (|sayBrightly|
-;                                    (CONS (MAKESTRING "To get")
-;                                     (APPEND
-;                                      (|bright| (MAKESTRING "views"))
-;                                      (CONS
-;                                       (MAKESTRING
-;                                     "you must give parameters of constructor")
-;                                       NIL)))))
-;                               ((BOOT-EQUAL |opt| '|attributes|)
-;                                (|centerAndHighlight|
-;                                    (MAKESTRING "Attributes")
-;                                    $LINELENGTH
-;                                    (|specialChar| '|hbar|))
-;                                (|sayBrightly| (MAKESTRING ""))
-;                                (SPADLET |attList|
-;                                         (REMDUP
-;                                          (MSORT
-;                                           (PROG (G166908)
-;                                             (SPADLET G166908 NIL)
-;                                             (RETURN
-;                                               (DO
-;                                                ((G166914
-;                                                  (GETDATABASE |op|
-;                                                   'ATTRIBUTES)
-;                                                  (CDR G166914))
-;                                                 (G166858 NIL))
-;                                                ((OR (ATOM G166914)
-;                                                  (PROGN
-;                                                    (SETQ G166858
-;                                                     (CAR G166914))
-;                                                    NIL)
-;                                                  (PROGN
-;                                                    (PROGN
-;                                                      (SPADLET |x|
-;                                                       (CAR G166858))
-;                                                      G166858)
-;                                                    NIL))
-;                                                 (NREVERSE0 G166908))
-;                                                 (SEQ
-;                                                  (EXIT
-;                                                   (SETQ G166908
-;                                                    (CONS |x|
-;                                                     G166908))))))))))
-;                                (COND
-;                                  ((NULL |attList|)
-;                                   (|sayBrightly|
-;                                    (|concat| '|%b|
-;                                     (|form2String| |functorForm|)
-;                                     '|%d| '|has no attributes.| '|%l|)))
-;                                  ('T
-;                                   (|say2PerLine|
-;                                    (PROG (G166925)
-;                                      (SPADLET G166925 NIL)
-;                                      (RETURN
-;                                        (DO
-;                                         ((G166930 |attList|
-;                                           (CDR G166930))
-;                                          (|x| NIL))
-;                                         ((OR (ATOM G166930)
-;                                           (PROGN
-;                                             (SETQ |x| (CAR G166930))
-;                                             NIL))
-;                                          (NREVERSE0 G166925))
-;                                          (SEQ
-;                                           (EXIT
-;                                            (SETQ G166925
-;                                             (CONS
-;                                              (|formatAttribute| |x|)
-;                                              G166925))))))))
-;                                   NIL)))
-;                               ((BOOT-EQUAL |opt| '|operations|)
-;                                (|displayOperationsFromLisplib|
-;                                    |functorForm|))
-;                               ('T NIL))))))))))))
-
-;displayOperationsFromLisplib form ==
-;  [name,:argl] := form
-;  kind := GETDATABASE(name,'CONSTRUCTORKIND)
-;  centerAndHighlight('"Operations",$LINELENGTH,specialChar 'hbar)
-;  opList:= GETDATABASE(name,'OPERATIONALIST)
-;  null opList => reportOpsFromUnitDirectly form
-;  opl:=REMDUP MSORT EQSUBSTLIST(argl,$FormalMapVariableList,opList)
-;  ops:= nil
-;  for x in opl repeat
-;    ops := [:ops,:formatOperationAlistEntry(x)]
-;  say2PerLine ops
-;  nil
-
-(DEFUN |displayOperationsFromLisplib| (|form|)
-  (PROG (|name| |argl| |kind| |opList| |opl| |ops|)
-  (declare (special |$FormalMapVariableList| $LINELENGTH))
-    (RETURN
-      (SEQ (PROGN
-             (SPADLET |name| (CAR |form|))
-             (SPADLET |argl| (CDR |form|))
-             (SPADLET |kind| (GETDATABASE |name| 'CONSTRUCTORKIND))
-             (|centerAndHighlight| (MAKESTRING "Operations")
-                 $LINELENGTH (|specialChar| '|hbar|))
-             (SPADLET |opList| (GETDATABASE |name| 'OPERATIONALIST))
-             (COND
-               ((NULL |opList|) (|reportOpsFromUnitDirectly| |form|))
-               ('T
-                (SPADLET |opl|
-                         (REMDUP (MSORT (EQSUBSTLIST |argl|
-                                         |$FormalMapVariableList|
-                                         |opList|))))
-                (SPADLET |ops| NIL)
-                (DO ((G166964 |opl| (CDR G166964)) (|x| NIL))
-                    ((OR (ATOM G166964)
-                         (PROGN (SETQ |x| (CAR G166964)) NIL))
-                     NIL)
-                  (SEQ (EXIT (SPADLET |ops|
-                                      (APPEND |ops|
-                                       (|formatOperationAlistEntry|
-                                        |x|))))))
-                (|say2PerLine| |ops|) NIL)))))))
-
-;--% )synonym
-;synonym(:l) == synonymSpad2Cmd()  -- always passed a null list
-
-(DEFUN |synonym| (&REST G166983 &AUX |l|)
-  (DSETQ |l| G166983)
-  (|synonymSpad2Cmd|))
-
-;synonymSpad2Cmd() ==
-;  line := getSystemCommandLine()
-;  if line = '"" then printSynonyms(NIL)
-;  else
-;    pair := processSynonymLine line
-;    if $CommandSynonymAlist then
-;      PUTALIST($CommandSynonymAlist,CAR pair, CDR pair)
-;    else $CommandSynonymAlist := [pair]
-;  terminateSystemCommand()
-
-(DEFUN |synonymSpad2Cmd| ()
-  (PROG (|line| |pair|)
-  (declare (special |$CommandSynonymAlist|))
-    (RETURN
-      (PROGN
-        (SPADLET |line| (|getSystemCommandLine|))
-        (COND
-          ((BOOT-EQUAL |line| (MAKESTRING "")) (|printSynonyms| NIL))
-          ('T (SPADLET |pair| (|processSynonymLine| |line|))
-           (COND
-             (|$CommandSynonymAlist|
-                 (PUTALIST |$CommandSynonymAlist| (CAR |pair|)
-                     (CDR |pair|)))
-             ('T (SPADLET |$CommandSynonymAlist| (CONS |pair| NIL))))))
-        (|terminateSystemCommand|)))))
-
-;processSynonymLine line ==
-;  key := STRING2ID_-N (line, 1)
-;  value := removeKeyFromLine line where
-;    removeKeyFromLine line ==
-;      line := dropLeadingBlanks line
-;      mx := MAXINDEX line
-;      for i in 0..mx repeat
-;        line.i = " " =>
-;          return (for j in (i+1)..mx repeat
-;            line.j ^= " " => return (SUBSTRING (line, j, nil)))
-;  [key, :value]
-
-(DEFUN |processSynonymLine,removeKeyFromLine| (|line|)
-  (PROG (|mx|)
-    (RETURN
-      (SEQ (SPADLET |line| (|dropLeadingBlanks| |line|))
-           (SPADLET |mx| (MAXINDEX |line|))
-           (EXIT (DO ((|i| 0 (QSADD1 |i|))) ((QSGREATERP |i| |mx|) NIL)
-                   (SEQ (EXIT (IF (BOOT-EQUAL (ELT |line| |i|) '| |)
-                                  (EXIT (RETURN
-                                          (DO
-                                           ((|j| (PLUS |i| 1)
-                                             (+ |j| 1)))
-                                           ((> |j| |mx|) NIL)
-                                            (SEQ
-                                             (EXIT
-                                              (IF
-                                               (NEQUAL (ELT |line| |j|)
-                                                '| |)
-                                               (EXIT
-                                                (RETURN
-                                                  (SUBSTRING |line| |j|
-                                                   NIL))))))))))))))))))
-
-
-(DEFUN |processSynonymLine| (|line|)
-  (PROG (|key| |value|)
-    (RETURN
-      (PROGN
-        (SPADLET |key| (STRING2ID-N |line| 1))
-        (SPADLET |value|
-                 (|processSynonymLine,removeKeyFromLine| |line|))
-        (CONS |key| |value|)))))
-
-;printSynonyms(patterns) ==
-;  centerAndHighlight("System Command Synonyms",$LINELENGTH,specialChar 'hbar)
-;  ls := filterListOfStringsWithFn(patterns, [[STRINGIMAGE a,:b]
-;    for [a,:b] in synonymsForUserLevel $CommandSynonymAlist],
-;      function CAR)
-;  printLabelledList(ls,'"user",'"synonyms",'")",patterns)
-;  nil
-
-(DEFUN |printSynonyms| (|patterns|)
-  (PROG (|a| |b| |ls|)
-  (declare (special |$CommandSynonymAlist| $LINELENGTH))
-    (RETURN
-      (SEQ (PROGN
-             (|centerAndHighlight| '|System Command Synonyms|
-                 $LINELENGTH (|specialChar| '|hbar|))
-             (SPADLET |ls|
-                      (|filterListOfStringsWithFn| |patterns|
-                          (PROG (G167027)
-                            (SPADLET G167027 NIL)
-                            (RETURN
-                              (DO ((G167033
-                                    (|synonymsForUserLevel|
-                                     |$CommandSynonymAlist|)
-                                    (CDR G167033))
-                                   (G167017 NIL))
-                                  ((OR (ATOM G167033)
-                                    (PROGN
-                                      (SETQ G167017 (CAR G167033))
-                                      NIL)
-                                    (PROGN
-                                      (PROGN
-                                        (SPADLET |a| (CAR G167017))
-                                        (SPADLET |b| (CDR G167017))
-                                        G167017)
-                                      NIL))
-                                   (NREVERSE0 G167027))
-                                (SEQ (EXIT
-                                      (SETQ G167027
-                                       (CONS
-                                        (CONS (STRINGIMAGE |a|) |b|)
-                                        G167027)))))))
-                          (|function| CAR)))
-             (|printLabelledList| |ls| (MAKESTRING "user")
-                 (MAKESTRING "synonyms") (MAKESTRING ")") |patterns|)
-             NIL)))))
-
-;printLabelledList(ls,label1,label2,prefix,patterns) ==
-;  -- prefix goes before each element on each side of the list, eg,
-;  --   ")"
-;  null ls =>
-;    null patterns =>
-;      sayMessage ['"   No ",label1,'"-defined ",label2,'" in effect."]
-;    sayMessage ['"   No ",label1,'"-defined ",label2,'" satisfying patterns:",
-;     '%l,'"     ",'%b,:blankList patterns,'%d]
-;  if patterns then
-;    sayMessage [label1,'"-defined ",label2,'" satisfying patterns:",
-;     '%l,'"   ",'%b,:blankList patterns,'%d]
-;  for [syn,:comm] in ls repeat
-;    if SUBSTRING(syn,0,1) = '"|" then syn := SUBSTRING(syn,1,NIL)
-;    if syn = '"%i" then syn := '"%i "
-;    wid := MAX(30 - (entryWidth syn),1)
-;    sayBrightly concat('%b,prefix,syn,'%d,
-;      fillerSpaces(wid,'"."),'" ",prefix,comm)
-;  sayBrightly '""
-
-(DEFUN |printLabelledList| (|ls| |label1| |label2| |prefix| |patterns|)
-  (PROG (|comm| |syn| |wid|)
-    (RETURN
-      (SEQ (COND
-             ((NULL |ls|)
-              (COND
-                ((NULL |patterns|)
-                 (|sayMessage|
-                     (CONS (MAKESTRING "   No ")
-                           (CONS |label1|
-                                 (CONS (MAKESTRING "-defined ")
-                                       (CONS |label2|
-                                        (CONS
-                                         (MAKESTRING " in effect.")
-                                         NIL)))))))
-                ('T
-                 (|sayMessage|
-                     (CONS (MAKESTRING "   No ")
-                           (CONS |label1|
-                                 (CONS (MAKESTRING "-defined ")
-                                       (CONS |label2|
-                                        (CONS
-                                         (MAKESTRING
-                                          " satisfying patterns:")
-                                         (CONS '|%l|
-                                          (CONS (MAKESTRING "     ")
-                                           (CONS '|%b|
-                                            (APPEND
-                                             (|blankList| |patterns|)
-                                             (CONS '|%d| NIL))))))))))))))
-             ('T
-              (COND
-                (|patterns|
-                    (|sayMessage|
-                        (CONS |label1|
-                              (CONS (MAKESTRING "-defined ")
-                                    (CONS |label2|
-                                     (CONS
-                                      (MAKESTRING
-                                       " satisfying patterns:")
-                                      (CONS '|%l|
-                                       (CONS (MAKESTRING "   ")
-                                        (CONS '|%b|
-                                         (APPEND
-                                          (|blankList| |patterns|)
-                                          (CONS '|%d| NIL))))))))))))
-              (DO ((G167062 |ls| (CDR G167062)) (G167049 NIL))
-                  ((OR (ATOM G167062)
-                       (PROGN (SETQ G167049 (CAR G167062)) NIL)
-                       (PROGN
-                         (PROGN
-                           (SPADLET |syn| (CAR G167049))
-                           (SPADLET |comm| (CDR G167049))
-                           G167049)
-                         NIL))
-                   NIL)
-                (SEQ (EXIT (PROGN
-                             (COND
-                               ((BOOT-EQUAL (SUBSTRING |syn| 0 1)
-                                    (MAKESTRING "|"))
-                                (SPADLET |syn| (SUBSTRING |syn| 1 NIL))))
-                             (COND
-                               ((BOOT-EQUAL |syn| (MAKESTRING "%i"))
-                                (SPADLET |syn| (MAKESTRING "%i "))))
-                             (SPADLET |wid|
-                                      (MAX
-                                       (SPADDIFFERENCE 30
-                                        (|entryWidth| |syn|))
-                                       1))
-                             (|sayBrightly|
-                                 (|concat| '|%b| |prefix| |syn| '|%d|
-                                     (|fillerSpaces| |wid|
-                                      (MAKESTRING "."))
-                                     (MAKESTRING " ") |prefix| |comm|))))))
-              (|sayBrightly| (MAKESTRING ""))))))))
-
 ;whatCommands(patterns) ==
 ;  label := STRCONC("System Commands for User Level: ",
 ;    STRINGIMAGE $UserLevel)
