diff --git a/books/bookvol9.pamphlet b/books/bookvol9.pamphlet
index 3e71eeb..92a2528 100644
--- a/books/bookvol9.pamphlet
+++ b/books/bookvol9.pamphlet
@@ -1761,6 +1761,80 @@ of the symbol being parsed. The original list read:
 
 @
 
+\defplist{dollargreaterthan}{parseDollarGreaterthan}
+<<postvars>>=
+(eval-when (eval load)
+ (setf (get '|$>| '|parseTran|) '|parseDollarGreaterThan|))
+
+@
+
+\defun{parseDollarGreaterThan}{parseDollarGreaterThan}
+\calls{parseDollarGreaterThan}{msubst}
+\calls{parseDollarGreaterThan}{parseTran}
+\usesdollar{parseDollarGreaterThan}{op}
+<<defun parseDollarGreaterThan>>=
+(defun |parseDollarGreaterThan| (arg)
+ (declare (special |$op|))
+  (list (msubst '$< '$> |$op|)
+        (|parseTran| (second arg))
+        (|parseTran| (first arg))))
+
+@
+
+\defplist{dollargreaterequal}{parseDollarGreaterEqual}
+<<postvars>>=
+(eval-when (eval load)
+ (setf (get '|$>=| '|parseTran|) '|parseDollarGreaterEqual|))
+
+@
+
+\defun{parseDollarGreaterEqual}{parseDollarGreaterEqual}
+\calls{parseDollarGreaterEqual}{msubst}
+\calls{parseDollarGreaterEqual}{parseTran}
+\usesdollar{parseDollarGreaterEqual}{op}
+<<defun parseDollarGreaterEqual>>=
+(defun |parseDollarGreaterEqual| (arg)
+ (declare (special |$op|))
+  (|parseTran| (list '|not| (cons (msubst '$< '$>= |$op|) arg))))
+
+@
+
+\defplist{dollarlessequal}{parseDollarLessEqual}
+<<postvars>>=
+(eval-when (eval load)
+ (setf (get '|$<=| '|parseTran|) '|parseDollarLessEqual|))
+
+@
+
+\defun{parseDollarLessEqual}{parseDollarLessEqual}
+\calls{parseDollarLessEqual}{msubst}
+\calls{parseDollarLessEqual}{parseTran}
+\usesdollar{parseDollarLessEqual}{op}
+<<defun parseDollarLessEqual>>=
+(defun |parseDollarLessEqual| (arg)
+ (declare (special |$op|))
+  (|parseTran| (list '|not| (cons (msubst '$> '$<= |$op|) arg))))
+
+@
+
+\defplist{dollarnotequal}{parseDollarNotEqual}
+<<postvars>>=
+(eval-when (eval load)
+ (setf (get '|$^=| '|parseTran|) '|parseDollarNotEqual|))
+
+@
+
+\defun{parseDollarNotEqual}{parseDollarNotEqual}
+\calls{parseDollarNotEqual}{parseTran}
+\calls{parseDollarNotEqual}{msubst}
+\usesdollar{parseDollarNotEqual}{op}
+<<defun parseDollarNotEqual>>=
+(defun |parseDollarNotEqual| (arg)
+ (declare (special |$op|))
+ (|parseTran| (list '|not| (cons (msubst '$= '$^= |$op|) arg))))
+
+@
+
 \defplist{eqv}{parseEquivalence}
 <<postvars>>=
 (eval-when (eval load)
@@ -1830,8 +1904,10 @@ of the symbol being parsed. The original list read:
 
 \defun{parseGreaterThan}{parseGreaterThan}
 \calls{parseGreaterThan}{parseTran}
+\usesdollar{parseGreaterThan}{op}
 <<defun parseGreaterThan>>=
 (defun |parseGreaterThan| (arg)
+ (declare (special |$op|))
  (list (msubst '< '> |$op|)
   (|parseTran| (second arg)) (|parseTran| (first arg))))
 
@@ -2000,6 +2076,13 @@ of the symbol being parsed. The original list read:
 
 @
 
+\defplist{if}{parseIf}
+<<postvars>>=
+(eval-when (eval load)
+ (setf (get 'if '|parseTran|) '|parseIf|))
+
+@
+
 \defun{parseIf}{parseIf}
 \calls{parseIf}{parseIf,ifTran}
 \calls{parseIf}{parseTran}
@@ -2031,6 +2114,150 @@ of the symbol being parsed. The original list read:
 
 @
 
+\defplist{in}{parseIn}
+<<postvars>>=
+(eval-when (eval load)
+ (setf (get 'in '|parseTran|) '|parseIn|))
+
+@
+
+\defun{parseIn}{parseIn}
+\calls{parseIn}{parseTran}
+\calls{parseIn}{postError}
+<<defun parseIn>>=
+(defun |parseIn| (arg)
+ (let (i n)
+  (setq i (|parseTran| (first arg)))
+  (setq n (|parseTran| (second arg)))
+  (cond
+   ((and (pairp n) (eq (qcar n) 'segment)
+         (pairp (qcdr n)) (eq (qcdr (qcdr n)) nil))
+    (list 'step i (second n) 1))
+   ((and (pairp n) (eq (qcar n) '|reverse|)
+         (pairp (qcdr n)) (eq (qcdr (qcdr n)) nil)
+         (pairp (qcar (qcdr n))) (eq (qcar (qcar (qcdr n))) 'segment)
+         (pairp (qcdr (qcar (qcdr n))))
+         (eq (qcdr (qcdr (qcar (qcdr n)))) nil))
+    (|postError| (list "  You cannot reverse an infinite sequence." )))
+   ((and (pairp n) (eq (qcar n) 'segment)
+         (pairp (qcdr n)) (pairp (qcdr (qcdr n)))
+         (eq (qcdr (qcdr (qcdr n))) nil))
+    (if (third n)
+     (list 'step i (second n) 1 (third n))
+     (list 'step i (second n) 1)))
+   ((and (pairp n) (eq (qcar n) '|reverse|)
+         (pairp (qcdr n)) (eq (qcdr (qcdr n)) nil)
+         (pairp (qcar (qcdr n))) (eq (qcar (qcar (qcdr n))) 'segment)
+         (pairp (qcdr (qcar (qcdr n))))
+         (pairp (qcdr (qcdr (qcar (qcdr n)))))
+         (eq (qcdr (qcdr (qcdr (qcar (qcdr n))))) nil))
+    (if (third (second n))
+     (list 'step i (third (second n)) -1 (second (second n)))
+     (|postError| (list "  You cannot reverse an infinite sequence."))))
+   ((and (pairp n) (eq (qcar n) '|tails|)
+         (pairp (qcdr n)) (eq (qcdr (qcdr n)) nil))
+    (list 'on i (second n)))
+   (t
+    (list 'in i n)))))
+
+@
+
+\defplist{inby}{parseInBy}
+<<postvars>>=
+(eval-when (eval load)
+ (setf (get 'inby '|parseTran|) '|parseInBy|))
+
+@
+
+\defun{parseInBy}{parseInBy}
+\calls{parseInBy}{postError}
+\calls{parseInBy}{parseTran}
+\calls{parseInBy}{bright}
+\calls{parseInBy}{parseIn}
+<<defun parseInBy>>=
+(defun |parseInBy| (arg)
+ (let (i n inc u)
+  (setq i (first arg))
+  (setq n (second arg))
+  (setq inc (third arg))
+  (setq u (|parseIn| (list i n)))
+  (cond
+   ((null (and (pairp u) (eq (qcar u) 'step)
+               (pairp (qcdr u))
+               (pairp (qcdr (qcdr u)))
+               (pairp (qcdr (qcdr (qcdr u))))))
+    (|postError|
+     (cons '|   You cannot use|
+      (append (|bright| "by")
+       (list "except for an explicitly indexed sequence.")))))
+   (t 
+    (setq inc (|parseTran| inc))
+    (cons 'step
+     (cons (second u)
+      (cons (third u) 
+       (cons (|parseTran| inc) (cddddr u)))))))))
+
+@
+
+\defplist{is}{parseIs}
+<<postvars>>=
+(eval-when (eval load)
+ (setf (get '|is| '|parseTran|) '|parseIs|))
+
+@
+
+\defun{parseIs}{parseIs}
+\calls{parseIs}{parseTran}
+\calls{parseIs}{transIs}
+<<defun parseIs>>=
+(defun |parseIs| (arg)
+ (list '|is| (|parseTran| (first arg)) (|transIs| (|parseTran| (second arg)))))
+
+@
+
+\defplist{isnt}{parseIsnt}
+<<postvars>>=
+(eval-when (eval load)
+ (setf (get '|isnt| '|parseTran|) '|parseIsnt|))
+
+@
+
+\defun{parseIsnt}{parseIsnt}
+\calls{parseIsnt}{parseTran}
+\calls{parseIsnt}{transIs}
+<<defun parseIsnt>>=
+(defun |parseIsnt| (arg)
+ (list '|isnt|
+   (|parseTran| (first arg))
+   (|transIs| (|parseTran| (second arg)))))
+
+@
+
+\defplist{Join}{parseJoin}
+<<postvars>>=
+(eval-when (eval load)
+ (setf (get '|Join| '|parseTran|) '|parseJoin|))
+
+@
+
+\defun{parseJoin}{parseJoin}
+\calls{parseJoin}{parseTranList}
+<<defun parseJoin>>=
+(defun |parseJoin| (thejoin)
+ (labels (
+  (fn (arg)
+   (cond
+    ((null arg)
+      nil)
+    ((and (pairp arg) (pairp (qcar arg)) (eq (qcar (qcar arg)) '|Join|))
+     (append (cdar arg) (fn (rest arg))))
+    (t
+     (cons (first arg) (fn (rest arg))))))
+ )
+ (cons '|Join| (fn (|parseTranList| thejoin)))))
+
+@
+
 \defplist{leave}{parseLeave}
 <<postvars>>=
 (eval-when (eval load)
@@ -2073,6 +2300,262 @@ of the symbol being parsed. The original list read:
 
 @
 
+\defplist{let}{parseLET}
+<<postvars>>=
+(eval-when (eval load)
+ (setf (get 'let '|parseTran|) '|parseLET|))
+
+@
+
+\defun{parseLET}{parseLET}
+\calls{parseLET}{parseTran}
+\calls{parseLET}{parseTranCheckForRecord}
+\calls{parseLET}{opOf}
+\calls{parseLET}{transIs}
+<<defun parseLET>>=
+(defun |parseLET| (arg)
+ (let (p)
+  (setq p
+   (list 'let (|parseTran| (first arg))
+     (|parseTranCheckForRecord| (second arg) (|opOf| (first arg)))))
+  (if (eq (|opOf| (first arg)) '|cons|)
+    (list 'let (|transIs| (second p)) (third p))
+    p)))
+
+@
+
+\defplist{letd}{parseLETD}
+<<postvars>>=
+(eval-when (eval load)
+ (setf (get 'letd '|parseTran|) '|parseLETD|))
+
+@
+
+\defun{parseLETD}{parseLETD}
+\calls{parseLETD}{parseTran}
+\calls{parseLETD}{parseType}
+<<defun parseLETD>>=
+(defun |parseLETD| (arg)
+ (list 'letd
+   (|parseTran| (first arg))
+   (|parseTran| (|parseType| (second arg)))))
+
+@
+
+\defplist{mdef}{parseMDEF}
+<<postvars>>=
+(eval-when (eval load)
+ (setf (get 'mdef '|parseTran|) '|parseMDEF|))
+
+@
+
+\defun{parseMDEF}{parseMDEF}
+\calls{parseMDEF}{parseTran}
+\calls{parseMDEF}{parseTranList}
+\calls{parseMDEF}{parseTranCheckForRecord}
+\calls{parseMDEF}{opOf}
+\usesdollar{parseMDEF}{lhs}
+<<defun parseMDEF>>=
+(defun |parseMDEF| (arg)
+ (let (|$lhs|)
+ (declare (special |$lhs|))
+  (setq |$lhs| (first arg))
+  (list 'mdef
+    (|parseTran| |$lhs|)
+    (|parseTranList| (second arg)) 
+    (|parseTranList| (third arg)) 
+    (|parseTranCheckForRecord| (fourth arg) (|opOf| |$lhs|)))))
+
+@
+
+\defplist{not}{parseNot}
+<<postvars>>=
+(eval-when (eval load)
+ (setf (get '|not| '|parseTran|) '|parseNot|))
+
+@
+
+\defplist{not}{parseNot}
+<<postvars>>=
+(eval-when (eval load)
+ (setf (get '|^| '|parseTran|) '|parseNot|))
+
+@
+
+\defun{parseNot}{parseNot}
+\calls{parseNot}{parseTran}
+\usesdollar{parseNot}{InteractiveMode}
+<<defun parseNot>>=
+(defun |parseNot| (arg)
+ (declare (special |$InteractiveMode|))
+ (if |$InteractiveMode|
+  (list '|not| (|parseTran| (car arg)))
+  (|parseTran| (cons 'if (cons (car arg) '(|false| |true|))))))
+
+@
+
+\defplist{notequal}{parseNotEqual}
+<<postvars>>=
+(eval-when (eval load)
+ (setf (get '|^=| '|parseTran|) '|parseNotEqual|))
+
+@
+
+\defun{parseNotEqual}{parseNotEqual}
+\calls{parseNotEqual}{parseTran}
+\calls{parseNotEqual}{msubst}
+\usesdollar{parseNotEqual}{op}
+<<defun parseNotEqual>>=
+(defun |parseNotEqual| (arg)
+  (|parseTran| (list '|not| (cons (msubst '= '^= |$op|) arg))))
+
+@
+
+\defplist{or}{parseOr}
+<<postvars>>=
+(eval-when (eval load)
+ (setf (get '|or| '|parseTran|) '|parseOr|))
+
+@
+
+\defun{parseOr}{parseOr}
+\calls{parseOr}{parseTran}
+\calls{parseOr}{parseTranList}
+\calls{parseOr}{parseIf}
+\calls{parseOr}{parseOr}
+<<defun parseOr>>=
+(defun |parseOr| (arg)
+ (let (x)
+  (setq x (|parseTran| (car arg)))
+  (cond
+   (|$InteractiveMode| (cons '|or| (|parseTranList| arg)))
+   ((null arg) '|false|)
+   ((null (cdr arg)) (car arg))
+   ((and (pairp x) (eq (qcar x) '|not|)
+         (pairp (qcdr x)) (eq (qcdr (qcdr x)) nil))
+     (|parseIf| (list (second x) (|parseOr| (cdr arg)) '|true|)))
+   (t
+     (|parseIf| (list x '|true| (|parseOr| (cdr arg))))))))
+
+@
+
+\defplist{pretend}{parsePretend}
+<<postvars>>=
+(eval-when (eval load)
+ (setf (get '|pretend| '|parseTran|) '|parsePretend|))
+
+@
+
+\defun{parsePretend}{parsePretend}
+\calls{parsePretend}{parseTran}
+\calls{parsePretend}{parseType}
+<<defun parsePretend>>=
+(defun |parsePretend| (arg)
+ (if |$InteractiveMode|
+  (list '|pretend|
+         (|parseTran| (first arg))
+         (|parseTran| (|parseType| (second arg))))
+  (list '|pretend|
+          (|parseTran| (first arg))
+          (|parseTran| (second arg)))))
+
+@
+
+\defplist{return}{parseReturn}
+<<postvars>>=
+(eval-when (eval load)
+ (setf (get '|return| '|parseTran|) '|parseReturn|))
+
+@
+
+\defun{parseReturn}{parseReturn}
+\calls{parseReturn}{parseTran}
+\calls{parseReturn}{moan}
+<<defun parseReturn>>=
+(defun |parseReturn| (arg)
+ (let (a b)
+  (setq a (|parseTran| (car arg)))
+  (setq b (|parseTran| (cdr arg)))
+  (cond
+   (b 
+    (when (nequal a 1) (moan "multiple-level 'return' not allowed"))
+    (cons '|return| (cons 1 b)))
+   (t (list '|return| 1 a)))))
+
+@
+
+\defplist{segment}{parseSegment}
+<<postvars>>=
+(eval-when (eval load)
+ (setf (get 'segment '|parseTran|) '|parseSegment|))
+
+@
+
+\defun{parseSegment}{parseSegment}
+\calls{parseSegment}{parseTran}
+<<defun parseSegment>>=
+(defun |parseSegment| (arg)
+  (if (and (pairp arg) (pairp (qcdr arg)) (eq (qcdr (qcdr arg)) nil))
+   (if (second arg)
+    (list 'segment (|parseTran| (first arg)) (|parseTran| (second arg)))
+    (list 'segment (|parseTran| (first arg))))
+   (cons 'segment arg)))
+
+@
+
+\defplist{segment}{parseSeq}
+<<postvars>>=
+(eval-when (eval load)
+ (setf (get 'seq '|parseTran|) '|parseSeq|))
+
+@
+
+\defun{parseSeq}{parseSeq}
+\calls{parseSeq}{postError}
+\calls{parseSeq}{transSeq}
+\calls{parseSeq}{mapInto}
+\calls{parseSeq}{last}
+<<defun parseSeq>>=
+(defun |parseSeq| (arg)
+ (let (tmp1)
+  (when (pairp arg) (setq tmp1 (reverse arg)))
+  (if (null (and (pairp arg) (pairp tmp1)
+                 (pairp (qcar tmp1)) (eq (qcar (qcar tmp1)) '|exit|)))
+    (|postError| (list "   Invalid ending to block: " (|last| arg)))
+    (|transSeq| (|mapInto| arg '|parseTran|)))))
+
+@
+
+\defplist{vcons}{parseVCONS}
+<<postvars>>=
+(eval-when (eval load)
+ (setf (get 'vcons '|parseTran|) '|parseVCONS|))
+
+@
+
+\defun{parseVCONS}{parseVCONS}
+\calls{parseVCONS}{parseTranList}
+<<defun parseVCONS>>=
+(defun |parseVCONS| (arg)
+ (cons 'vector (|parseTranList| arg)))
+
+@
+
+\defplist{where}{parseWhere}
+<<postvars>>=
+(eval-when (eval load)
+ (setf (get '|where| '|parseTran|) '|parseWhere|))
+
+@
+
+\defun{parseWhere}{parseWhere}
+\calls{parseWhere}{mapInto}
+<<defun parseWhere>>=
+(defun |parseWhere| (arg)
+  (cons '|where| (|mapInto| arg '|parseTran|)))
+
+@
+
 \chapter{Post Transformers}
 \section{Direct called postparse routines}
 \defun{postTransform}{postTransform}
@@ -9761,6 +10244,10 @@ if \verb|$InteractiveMode| then use a null outputstream
 <<defun parseColon>>
 <<defun parseConstruct>>
 <<defun parseDEF>>
+<<defun parseDollarGreaterEqual>>
+<<defun parseDollarGreaterThan>>
+<<defun parseDollarLessEqual>>
+<<defun parseDollarNotEqual>>
 <<defun parseEquivalence>>
 <<defun parseExit>>
 <<defun postForm>>
@@ -9770,11 +10257,28 @@ if \verb|$InteractiveMode| then use a null outputstream
 <<defun parseIf>>
 <<defun parseIf,ifTran>>
 <<defun parseImplies>>
+<<defun parseIn>>
+<<defun parseInBy>>
+<<defun parseIs>>
+<<defun parseIsnt>>
+<<defun parseJoin>>
 <<defun parseLeave>>
 <<defun parseLessEqual>>
+<<defun parseLET>>
+<<defun parseLETD>>
+<<defun parseMDEF>>
+<<defun parseNot>>
+<<defun parseNotEqual>>
+<<defun parseOr>>
+<<defun parsePretend>>
+<<defun parseReturn>>
+<<defun parseSegment>>
+<<defun parseSeq>>
 <<defun parseTran>>
 <<defun parseTranList>>
 <<defun parseTransform>>
+<<defun parseVCONS>>
+<<defun parseWhere>>
 <<defun postAdd>>
 <<defun postAtom>>
 <<defun postAtSign>>
diff --git a/changelog b/changelog
index f8366da..1d60fed 100644
--- a/changelog
+++ b/changelog
@@ -1,3 +1,8 @@
+20101119 tpd src/axiom-website/patches.html 20101119.01.tpd.patch
+20101119 tpd src/interp/vmlisp.lisp treeshake compiler
+20101119 tpd src/interp/postprop.lisp treeshake compiler
+20101119 tpd src/interp/parsing.lisp treeshake compiler
+20101119 tpd books/bookvol9 treeshake compiler
 20101112 tpd src/axiom-website/patches.html 20101112.01.tpd.patch
 20101112 tpd src/interp/vmlisp.lisp treeshake compiler
 20101112 tpd src/interp/parsing.lisp treeshake compiler
diff --git a/src/axiom-website/patches.html b/src/axiom-website/patches.html
index 11558c3..8f57cae 100644
--- a/src/axiom-website/patches.html
+++ b/src/axiom-website/patches.html
@@ -3262,6 +3262,8 @@ books/bookvol9 treeshake compiler<br/>
 books/bookvol9 treeshake compiler<br/>
 <a href="patches/20101112.01.tpd.patch">20101112.01.tpd.patch</a>
 books/bookvol9 treeshake compiler<br/>
+<a href="patches/20101119.01.tpd.patch">20101119.01.tpd.patch</a>
+books/bookvol9 treeshake compiler<br/>
 
  </body>
 </html>
diff --git a/src/interp/parsing.lisp.pamphlet b/src/interp/parsing.lisp.pamphlet
index 0e1e64f..af0fd5d 100644
--- a/src/interp/parsing.lisp.pamphlet
+++ b/src/interp/parsing.lisp.pamphlet
@@ -1634,17 +1634,6 @@ parse
 
 (DEFUN |parseLeftArrow| (|u|) (|parseTran| (CONS (QUOTE LET) |u|))) 
 ;
-;parseIs [a,b] == ['is,parseTran a,transIs parseTran b]
-
-;;;     ***       |parseIs| REDEFINED
-
-(DEFUN |parseIs| (#0=#:G166160) (PROG (|a| |b|) (RETURN (PROGN (SPADLET |a| (CAR #0#)) (SPADLET |b| (CADR #0#)) (CONS (QUOTE |is|) (CONS (|parseTran| |a|) (CONS (|transIs| (|parseTran| |b|)) NIL))))))) 
-;
-;parseIsnt [a,b] == ['isnt,parseTran a,transIs parseTran b]
-
-;;;     ***       |parseIsnt| REDEFINED
-
-(DEFUN |parseIsnt| (#0=#:G166174) (PROG (|a| |b|) (RETURN (PROGN (SPADLET |a| (CAR #0#)) (SPADLET |b| (CADR #0#)) (CONS (QUOTE |isnt|) (CONS (|parseTran| |a|) (CONS (|transIs| (|parseTran| |b|)) NIL))))))) 
 ;
 ;transIs u ==
 ;  isListConstructor u => ['construct,:transIs1 u]
@@ -1680,20 +1669,6 @@ parse
 
 (DEFUN |transIs1| (|u|) (PROG (|l| |x| |y| |h| |v| |ISTMP#1| |ISTMP#2| |z|) (RETURN (SEQ (COND ((AND (PAIRP |u|) (EQ (QCAR |u|) (QUOTE |construct|)) (PROGN (SPADLET |l| (QCDR |u|)) (QUOTE T))) (PROG (#0=#:G166255) (SPADLET #0# NIL) (RETURN (DO ((#1=#:G166260 |l| (CDR #1#)) (|x| NIL)) ((OR (ATOM #1#) (PROGN (SETQ |x| (CAR #1#)) NIL)) (NREVERSE0 #0#)) (SEQ (EXIT (SETQ #0# (CONS (|transIs| |x|) #0#)))))))) ((AND (PAIRP |u|) (EQ (QCAR |u|) (QUOTE |append|)) (PROGN (SPADLET |ISTMP#1| (QCDR |u|)) (AND (PAIRP |ISTMP#1|) (PROGN (SPADLET |x| (QCAR |ISTMP#1|)) (SPADLET |ISTMP#2| (QCDR |ISTMP#1|)) (AND (PAIRP |ISTMP#2|) (EQ (QCDR |ISTMP#2|) NIL) (PROGN (SPADLET |y| (QCAR |ISTMP#2|)) (QUOTE T))))))) (SPADLET |h| (CONS (QUOTE |:|) (CONS (|transIs| |x|) NIL))) (COND ((PROGN (SPADLET |ISTMP#1| (SPADLET |v| (|transIs1| |y|))) (AND (PAIRP |ISTMP#1|) (EQ (QCAR |ISTMP#1|) (QUOTE |:|)) (PROGN (SPADLET |ISTMP#2| (QCDR |ISTMP#1|)) (AND (PAIRP |ISTMP#2|) (EQ (QCDR |ISTMP#2|) NIL) (PROGN (SPADLET |z| (QCAR |ISTMP#2|)) (QUOTE T)))))) (CONS |h| (CONS |z| NIL))) ((BOOT-EQUAL |v| (QUOTE |nil|)) (CAR (CDR |h|))) ((ATOM |v|) (CONS |h| (CONS (CONS (QUOTE |:|) (CONS |v| NIL)) NIL))) ((QUOTE T) (CONS |h| |v|)))) ((AND (PAIRP |u|) (EQ (QCAR |u|) (QUOTE |cons|)) (PROGN (SPADLET |ISTMP#1| (QCDR |u|)) (AND (PAIRP |ISTMP#1|) (PROGN (SPADLET |x| (QCAR |ISTMP#1|)) (SPADLET |ISTMP#2| (QCDR |ISTMP#1|)) (AND (PAIRP |ISTMP#2|) (EQ (QCDR |ISTMP#2|) NIL) (PROGN (SPADLET |y| (QCAR |ISTMP#2|)) (QUOTE T))))))) (SPADLET |h| (|transIs| |x|)) (COND ((PROGN (SPADLET |ISTMP#1| (SPADLET |v| (|transIs1| |y|))) (AND (PAIRP |ISTMP#1|) (EQ (QCAR |ISTMP#1|) (QUOTE |:|)) (PROGN (SPADLET |ISTMP#2| (QCDR |ISTMP#1|)) (AND (PAIRP |ISTMP#2|) (EQ (QCDR |ISTMP#2|) NIL) (PROGN (SPADLET |z| (QCAR |ISTMP#2|)) (QUOTE T)))))) (CONS |h| (CONS |z| NIL))) ((BOOT-EQUAL |v| (QUOTE |nil|)) (CONS |h| NIL)) ((ATOM |v|) (CONS |h| (CONS (CONS (QUOTE |:|) (CONS |v| NIL)) NIL))) ((QUOTE T) (CONS |h| |v|)))) ((QUOTE T) |u|)))))) 
 ;
-;parseLET [x,y] ==
-;  p := ['LET,parseTran x,parseTranCheckForRecord(y,opOf x)]
-;  opOf x = 'cons => ['LET,transIs p.1,p.2]
-;  p
-
-;;;     ***       |parseLET| REDEFINED
-
-(DEFUN |parseLET| (#0=#:G166290) (PROG (|x| |y| |p|) (RETURN (PROGN (SPADLET |x| (CAR #0#)) (SPADLET |y| (CADR #0#)) (SPADLET |p| (CONS (QUOTE LET) (CONS (|parseTran| |x|) (CONS (|parseTranCheckForRecord| |y| (|opOf| |x|)) NIL)))) (COND ((BOOT-EQUAL (|opOf| |x|) (QUOTE |cons|)) (CONS (QUOTE LET) (CONS (|transIs| (ELT |p| 1)) (CONS (ELT |p| 2) NIL)))) ((QUOTE T) |p|)))))) 
-;
-;parseLETD [x,y] == ['LETD,parseTran x,parseTran parseType y]
-
-;;;     ***       |parseLETD| REDEFINED
-
-(DEFUN |parseLETD| (#0=#:G166305) (PROG (|x| |y|) (RETURN (PROGN (SPADLET |x| (CAR #0#)) (SPADLET |y| (CADR #0#)) (CONS (QUOTE LETD) (CONS (|parseTran| |x|) (CONS (|parseTran| (|parseType| |y|)) NIL))))))) 
 ;
 ;
 ;parseBigelt [typ,consForm] ==
@@ -1718,13 +1693,6 @@ parse
 ;
 ;
 ;
-;parsePretend [x,typ] ==
-;  $InteractiveMode => ['pretend,parseTran x,parseTran parseType typ]
-;  ['pretend,parseTran x,parseTran typ]
-
-;;;     ***       |parsePretend| REDEFINED
-
-(DEFUN |parsePretend| (#0=#:G166429) (PROG (|x| |typ|) (RETURN (PROGN (SPADLET |x| (CAR #0#)) (SPADLET |typ| (CADR #0#)) (COND (|$InteractiveMode| (CONS (QUOTE |pretend|) (CONS (|parseTran| |x|) (CONS (|parseTran| (|parseType| |typ|)) NIL)))) ((QUOTE T) (CONS (QUOTE |pretend|) (CONS (|parseTran| |x|) (CONS (|parseTran| |typ|) NIL))))))))) 
 ;
 ;parseType x ==
 ;  x := substitute($EmptyMode,$quadSymbol,x)
@@ -1870,13 +1838,6 @@ parse
 
 (DEFUN |parseLhs| (|x|) (PROG NIL (RETURN (SEQ (COND ((ATOM |x|) (|parseTran| |x|)) ((ATOM (CAR |x|)) (CONS (|parseTran| (CAR |x|)) (PROG (#0=#:G166888) (SPADLET #0# NIL) (RETURN (DO ((#1=#:G166893 (CDR |x|) (CDR #1#)) (|y| NIL)) ((OR (ATOM #1#) (PROGN (SETQ |y| (CAR #1#)) NIL)) (NREVERSE0 #0#)) (SEQ (EXIT (SETQ #0# (CONS (|transIs| (|parseTran| |y|)) #0#))))))))) ((QUOTE T) (|parseTran| |x|))))))) 
 ;
-;parseMDEF [$lhs,tList,specialList,body] ==
-;  ['MDEF,parseTran $lhs,parseTranList tList,parseTranList specialList,
-;    parseTranCheckForRecord(body,opOf $lhs)]
-
-;;;     ***       |parseMDEF| REDEFINED
-
-(DEFUN |parseMDEF| (#0=#:G166903) (PROG (|$lhs| |tList| |specialList| |body|) (DECLARE (SPECIAL |$lhs|)) (RETURN (PROGN (SPADLET |$lhs| (CAR #0#)) (SPADLET |tList| (CADR #0#)) (SPADLET |specialList| (CADDR #0#)) (SPADLET |body| (CADDDR #0#)) (CONS (QUOTE MDEF) (CONS (|parseTran| |$lhs|) (CONS (|parseTranList| |tList|) (CONS (|parseTranList| |specialList|) (CONS (|parseTranCheckForRecord| |body| (|opOf| |$lhs|)) NIL))))))))) 
 ;
 ;parseTranCheckForRecord(x,op) ==
 ;  (x:= parseTran x) is ['Record,:l] =>
@@ -1919,131 +1880,23 @@ parse
 ;
 
 ;
-;parseNotEqual u == parseTran ['not,[substitute("=","^=",$op),:u]]
-
-;;;     ***       |parseNotEqual| REDEFINED
-
-(DEFUN |parseNotEqual| (|u|) (|parseTran| (CONS (QUOTE |not|) (CONS (CONS (MSUBST (QUOTE =) (QUOTE ^=) |$op|) |u|) NIL)))) 
 ;
-;parseDollarGreaterThan [x,y] ==
-;  [substitute("$<","$>",$op),parseTran y,parseTran x]
-
-;;;     ***       |parseDollarGreaterThan| REDEFINED
-
-(DEFUN |parseDollarGreaterThan| (#0=#:G167063) (PROG (|x| |y|) (RETURN (PROGN (SPADLET |x| (CAR #0#)) (SPADLET |y| (CADR #0#)) (CONS (MSUBST (QUOTE $<) (QUOTE $>) |$op|) (CONS (|parseTran| |y|) (CONS (|parseTran| |x|) NIL))))))) 
 ;
-;parseDollarGreaterEqual u ==
-;  parseTran ['not,[substitute("$<","$>=",$op),:u]]
-
-;;;     ***       |parseDollarGreaterEqual| REDEFINED
-
-(DEFUN |parseDollarGreaterEqual| (|u|) (|parseTran| (CONS (QUOTE |not|) (CONS (CONS (MSUBST (QUOTE $<) (QUOTE $>=) |$op|) |u|) NIL)))) 
 ;
-;parseDollarLessEqual u ==
-;  parseTran ['not,[substitute("$>","$<=",$op),:u]]
-
-;;;     ***       |parseDollarLessEqual| REDEFINED
 
-(DEFUN |parseDollarLessEqual| (|u|) (|parseTran| (CONS (QUOTE |not|) (CONS (CONS (MSUBST (QUOTE $>) (QUOTE $<=) |$op|) |u|) NIL)))) 
-;
-;parseDollarNotEqual u ==
-;  parseTran ['not,[substitute("$=","$^=",$op),:u]]
-
-;;;     ***       |parseDollarNotEqual| REDEFINED
-
-(DEFUN |parseDollarNotEqual| (|u|) (|parseTran| (CONS (QUOTE |not|) (CONS (CONS (MSUBST (QUOTE $=) (QUOTE $^=) |$op|) |u|) NIL)))) 
-;
-;parseOr u ==
-;  $InteractiveMode => ['or,:parseTranList u]
-;  null u => 'false
-;  null rest u => first u
-;  (x:= parseTran first u) is ['not,y] => parseIf [y,parseOr rest u,'true]
-;  true => parseIf [x,'true,parseOr rest u]
-
-;;;     ***       |parseOr| REDEFINED
-
-(DEFUN |parseOr| (|u|) (PROG (|x| |ISTMP#1| |ISTMP#2| |y|) (RETURN (COND (|$InteractiveMode| (CONS (QUOTE |or|) (|parseTranList| |u|))) ((NULL |u|) (QUOTE |false|)) ((NULL (CDR |u|)) (CAR |u|)) ((PROGN (SPADLET |ISTMP#1| (SPADLET |x| (|parseTran| (CAR |u|)))) (AND (PAIRP |ISTMP#1|) (EQ (QCAR |ISTMP#1|) (QUOTE |not|)) (PROGN (SPADLET |ISTMP#2| (QCDR |ISTMP#1|)) (AND (PAIRP |ISTMP#2|) (EQ (QCDR |ISTMP#2|) NIL) (PROGN (SPADLET |y| (QCAR |ISTMP#2|)) (QUOTE T)))))) (|parseIf| (CONS |y| (CONS (|parseOr| (CDR |u|)) (CONS (QUOTE |true|) NIL))))) ((QUOTE T) (|parseIf| (CONS |x| (CONS (QUOTE |true|) (CONS (|parseOr| (CDR |u|)) NIL))))))))) 
-;
-;parseNot u ==
-;  $InteractiveMode => ['not,parseTran first u]
-;  parseTran ['IF,first u,:'(false true)]
-
-;;;     ***       |parseNot| REDEFINED
-
-(DEFUN |parseNot| (|u|) (COND (|$InteractiveMode| (CONS (QUOTE |not|) (CONS (|parseTran| (CAR |u|)) NIL))) ((QUOTE T) (|parseTran| (CONS (QUOTE IF) (CONS (CAR |u|) (QUOTE (|false| |true|)))))))) 
-;
 ;
 ;
 ;parseExclusiveOr [a,b] == parseIf [a,parseIf [b,:'(false true)],b]
 
 ;;;     ***       |parseExclusiveOr| REDEFINED
 
-(DEFUN |parseExclusiveOr| (#0=#:G167140) (PROG (|a| |b|) (RETURN (PROGN (SPADLET |a| (CAR #0#)) (SPADLET |b| (CADR #0#)) (|parseIf| (CONS |a| (CONS (|parseIf| (CONS |b| (QUOTE (|false| |true|)))) (CONS |b| NIL)))))))) 
+;(DEFUN |parseExclusiveOr| (#0=#:G167140) (PROG (|a| |b|) (RETURN (PROGN (SPADLET |a| (CAR #0#)) (SPADLET |b| (CADR #0#)) (|parseIf| (CONS |a| (CONS (|parseIf| (CONS |b| (QUOTE (|false| |true|)))) (CONS |b| NIL)))))))) 
 ;
 
-;parseReturn [a,:b] ==
-;  a:= parseTran a
-;  b:= parseTran b
-;  b =>
-;    (if a^=1 then MOAN '"multiple-level 'return' not allowed"; ["return",1,:b])
-;  ['return,1,a]
-
-;;;     ***       |parseReturn| REDEFINED
-
-(DEFUN |parseReturn| (#0=#:G167194) (PROG (|a| |b|) (RETURN (PROGN (SPADLET |a| (CAR #0#)) (SPADLET |b| (CDR #0#)) (SPADLET |a| (|parseTran| |a|)) (SPADLET |b| (|parseTran| |b|)) (COND (|b| (COND ((NEQUAL |a| 1) (MOAN "multiple-level 'return' not allowed"))) (CONS (QUOTE |return|) (CONS 1 |b|))) ((QUOTE T) (CONS (QUOTE |return|) (CONS 1 (CONS |a| NIL))))))))) 
 ;
-;parseJoin l ==
-;  ['Join,:fn parseTranList l] where
-;    fn l ==
-;      null l => nil
-;      l is [['Join,:x],:y] => [:x,:fn y]
-;      [first l,:fn rest l]
-
-;;;     ***       |parseJoin,fn| REDEFINED
-
-(DEFUN |parseJoin,fn| (|l|) (PROG (|ISTMP#1| |x| |y|) (RETURN (SEQ (IF (NULL |l|) (EXIT NIL)) (IF (AND (PAIRP |l|) (PROGN (SPADLET |ISTMP#1| (QCAR |l|)) (AND (PAIRP |ISTMP#1|) (EQ (QCAR |ISTMP#1|) (QUOTE |Join|)) (PROGN (SPADLET |x| (QCDR |ISTMP#1|)) (QUOTE T)))) (PROGN (SPADLET |y| (QCDR |l|)) (QUOTE T))) (EXIT (APPEND |x| (|parseJoin,fn| |y|)))) (EXIT (CONS (CAR |l|) (|parseJoin,fn| (CDR |l|)))))))) 
-
-;;;     ***       |parseJoin| REDEFINED
-
-(DEFUN |parseJoin| (|l|) (CONS (QUOTE |Join|) (|parseJoin,fn| (|parseTranList| |l|)))) 
 ;
-;parseInBy [i,n,inc] ==
-;  (u:= parseIn [i,n]) isnt ['STEP,i,a,j,:r] =>
-;    postError ["   You cannot use",:bright '"by",
-;      '"except for an explicitly indexed sequence."]
-;  inc:= parseTran inc
-;  ['STEP,i,a,parseTran inc,:r]
-
-;;;     ***       |parseInBy| REDEFINED
-
-(DEFUN |parseInBy| (#0=#:G167281) (PROG (|n| |u| |ISTMP#1| |ISTMP#2| |i| |ISTMP#3| |a| |ISTMP#4| |j| |r| |inc|) (RETURN (PROGN (SPADLET |i| (CAR #0#)) (SPADLET |n| (CADR #0#)) (SPADLET |inc| (CADDR #0#)) (COND ((NULL (PROGN (SPADLET |ISTMP#1| (SPADLET |u| (|parseIn| (CONS |i| (CONS |n| NIL))))) (AND (PAIRP |ISTMP#1|) (EQ (QCAR |ISTMP#1|) (QUOTE STEP)) (PROGN (SPADLET |ISTMP#2| (QCDR |ISTMP#1|)) (AND (PAIRP |ISTMP#2|) (PROGN (SPADLET |i| (QCAR |ISTMP#2|)) (SPADLET |ISTMP#3| (QCDR |ISTMP#2|)) (AND (PAIRP |ISTMP#3|) (PROGN (SPADLET |a| (QCAR |ISTMP#3|)) (SPADLET |ISTMP#4| (QCDR |ISTMP#3|)) (AND (PAIRP |ISTMP#4|) (PROGN (SPADLET |j| (QCAR |ISTMP#4|)) (SPADLET |r| (QCDR |ISTMP#4|)) (QUOTE T))))))))))) (|postError| (CONS (QUOTE |   You cannot use|) (APPEND (|bright| "by") (CONS "except for an explicitly indexed sequence." NIL))))) ((QUOTE T) (SPADLET |inc| (|parseTran| |inc|)) (CONS (QUOTE STEP) (CONS |i| (CONS |a| (CONS (|parseTran| |inc|) |r|)))))))))) 
 ;
-;parseSegment p ==
-;  p is [a,b] =>
-;    b => ['SEGMENT,parseTran a, parseTran b]
-;    ['SEGMENT,parseTran a]
-;  ['SEGMENT,:p]
-
-;;;     ***       |parseSegment| REDEFINED
-
-(DEFUN |parseSegment| (|p|) (PROG (|a| |ISTMP#1| |b|) (RETURN (COND ((AND (PAIRP |p|) (PROGN (SPADLET |a| (QCAR |p|)) (SPADLET |ISTMP#1| (QCDR |p|)) (AND (PAIRP |ISTMP#1|) (EQ (QCDR |ISTMP#1|) NIL) (PROGN (SPADLET |b| (QCAR |ISTMP#1|)) (QUOTE T))))) (COND (|b| (CONS (QUOTE SEGMENT) (CONS (|parseTran| |a|) (CONS (|parseTran| |b|) NIL)))) ((QUOTE T) (CONS (QUOTE SEGMENT) (CONS (|parseTran| |a|) NIL))))) ((QUOTE T) (CONS (QUOTE SEGMENT) |p|)))))) 
 ;
-;parseIn [i,n] ==
-;  i:= parseTran i
-;  n:= parseTran n
-;  n is ['SEGMENT,a] => ['STEP,i,a,1]
-;  n is ['reverse,['SEGMENT,a]] =>
-;    postError ['"  You cannot reverse an infinite sequence."]
-;  n is ['SEGMENT,a,b] => (b => ['STEP,i,a,1,b]; ['STEP,i,a,1])
-;  n is ['reverse,['SEGMENT,a,b]] =>
-;    b => ['STEP,i,b,-1,a]
-;    postError ['"  You cannot reverse an infinite sequence."]
-;  n is ['tails,s] => ['ON,i,s]
-;  ['IN,i,n]
-
-;;;     ***       |parseIn| REDEFINED
-
-(DEFUN |parseIn| (#0=#:G167419) (PROG (|i| |n| |ISTMP#2| |ISTMP#3| |a| |ISTMP#4| |b| |ISTMP#1| |s|) (RETURN (PROGN (SPADLET |i| (CAR #0#)) (SPADLET |n| (CADR #0#)) (SPADLET |i| (|parseTran| |i|)) (SPADLET |n| (|parseTran| |n|)) (COND ((AND (PAIRP |n|) (EQ (QCAR |n|) (QUOTE SEGMENT)) (PROGN (SPADLET |ISTMP#1| (QCDR |n|)) (AND (PAIRP |ISTMP#1|) (EQ (QCDR |ISTMP#1|) NIL) (PROGN (SPADLET |a| (QCAR |ISTMP#1|)) (QUOTE T))))) (CONS (QUOTE STEP) (CONS |i| (CONS |a| (CONS 1 NIL))))) ((AND (PAIRP |n|) (EQ (QCAR |n|) (QUOTE |reverse|)) (PROGN (SPADLET |ISTMP#1| (QCDR |n|)) (AND (PAIRP |ISTMP#1|) (EQ (QCDR |ISTMP#1|) NIL) (PROGN (SPADLET |ISTMP#2| (QCAR |ISTMP#1|)) (AND (PAIRP |ISTMP#2|) (EQ (QCAR |ISTMP#2|) (QUOTE SEGMENT)) (PROGN (SPADLET |ISTMP#3| (QCDR |ISTMP#2|)) (AND (PAIRP |ISTMP#3|) (EQ (QCDR |ISTMP#3|) NIL) (PROGN (SPADLET |a| (QCAR |ISTMP#3|)) (QUOTE T))))))))) (|postError| (CONS "  You cannot reverse an infinite sequence." NIL))) ((AND (PAIRP |n|) (EQ (QCAR |n|) (QUOTE SEGMENT)) (PROGN (SPADLET |ISTMP#1| (QCDR |n|)) (AND (PAIRP |ISTMP#1|) (PROGN (SPADLET |a| (QCAR |ISTMP#1|)) (SPADLET |ISTMP#2| (QCDR |ISTMP#1|)) (AND (PAIRP |ISTMP#2|) (EQ (QCDR |ISTMP#2|) NIL) (PROGN (SPADLET |b| (QCAR |ISTMP#2|)) (QUOTE T))))))) (COND (|b| (CONS (QUOTE STEP) (CONS |i| (CONS |a| (CONS 1 (CONS |b| NIL)))))) ((QUOTE T) (CONS (QUOTE STEP) (CONS |i| (CONS |a| (CONS 1 NIL))))))) ((AND (PAIRP |n|) (EQ (QCAR |n|) (QUOTE |reverse|)) (PROGN (SPADLET |ISTMP#1| (QCDR |n|)) (AND (PAIRP |ISTMP#1|) (EQ (QCDR |ISTMP#1|) NIL) (PROGN (SPADLET |ISTMP#2| (QCAR |ISTMP#1|)) (AND (PAIRP |ISTMP#2|) (EQ (QCAR |ISTMP#2|) (QUOTE SEGMENT)) (PROGN (SPADLET |ISTMP#3| (QCDR |ISTMP#2|)) (AND (PAIRP |ISTMP#3|) (PROGN (SPADLET |a| (QCAR |ISTMP#3|)) (SPADLET |ISTMP#4| (QCDR |ISTMP#3|)) (AND (PAIRP |ISTMP#4|) (EQ (QCDR |ISTMP#4|) NIL) (PROGN (SPADLET |b| (QCAR |ISTMP#4|)) (QUOTE T))))))))))) (COND (|b| (CONS (QUOTE STEP) (CONS |i| (CONS |b| (CONS (SPADDIFFERENCE 1) (CONS |a| NIL)))))) ((QUOTE T) (|postError| (CONS "  You cannot reverse an infinite sequence." NIL))))) ((AND (PAIRP |n|) (EQ (QCAR |n|) (QUOTE |tails|)) (PROGN (SPADLET |ISTMP#1| (QCDR |n|)) (AND (PAIRP |ISTMP#1|) (EQ (QCDR |ISTMP#1|) NIL) (PROGN (SPADLET |s| (QCAR |ISTMP#1|)) (QUOTE T))))) (CONS (QUOTE ON) (CONS |i| (CONS |s| NIL)))) ((QUOTE T) (CONS (QUOTE IN) (CONS |i| (CONS |n| NIL))))))))) 
 ;
 ;
 ;makeSimplePredicateOrNil p ==
@@ -2055,21 +1908,8 @@ parse
 
 (DEFUN |makeSimplePredicateOrNil| (|p|) (PROG (|u| |g|) (RETURN (COND ((|isSimple| |p|) NIL) ((SPADLET |u| (|isAlmostSimple| |p|)) |u|) ((QUOTE T) (|wrapSEQExit| (CONS (CONS (QUOTE LET) (CONS (SPADLET |g| (GENSYM)) (CONS |p| NIL))) (CONS |g| NIL)))))))) 
 ;
-;parseWhere l == ['where,:mapInto(l,'parseTran)]
-
-;;;     ***       |parseWhere| REDEFINED
-
-(DEFUN |parseWhere| (|l|) (CONS (QUOTE |where|) (|mapInto| |l| (QUOTE |parseTran|)))) 
 ;
 ;
-;parseSeq l ==
-;  not l is [:.,['exit,:.]] =>
-;    postError ['"   Invalid ending to block: ",last l]
-;  transSeq mapInto(l,'parseTran)
-
-;;;     ***       |parseSeq| REDEFINED
-
-(DEFUN |parseSeq| (|l|) (PROG (|ISTMP#1| |ISTMP#2|) (RETURN (COND ((NULL (AND (PAIRP |l|) (PROGN (SPADLET |ISTMP#1| (REVERSE |l|)) (QUOTE T)) (PAIRP |ISTMP#1|) (PROGN (SPADLET |ISTMP#2| (QCAR |ISTMP#1|)) (AND (PAIRP |ISTMP#2|) (EQ (QCAR |ISTMP#2|) (QUOTE |exit|)))))) (|postError| (CONS "   Invalid ending to block: " (CONS (|last| |l|) NIL)))) ((QUOTE T) (|transSeq| (|mapInto| |l| (QUOTE |parseTran|)))))))) 
 ;
 ;transSeq l ==
 ;  null l => nil
@@ -2149,11 +1989,6 @@ parse
 
 (DEFUN |scriptTranRow1| (|x|) (COND ((NULL |x|) (QUOTE ||)) ((QUOTE T) (STRCONC (QUOTE |,|) |$quadSymbol| (|scriptTranRow1| (CDR |x|)))))) 
 ;
-;parseVCONS l == ["VECTOR",:parseTranList l]
-
-;;;     ***       |parseVCONS| REDEFINED
-
-(DEFUN |parseVCONS| (|l|) (CONS (QUOTE VECTOR) (|parseTranList| |l|))) 
 ;;;Boot translation finished for parse.boot
 
 ;displayPreCompilationErrors() ==
diff --git a/src/interp/postprop.lisp.pamphlet b/src/interp/postprop.lisp.pamphlet
index 8d7a3a9..f529d46 100644
--- a/src/interp/postprop.lisp.pamphlet
+++ b/src/interp/postprop.lisp.pamphlet
@@ -105,45 +105,47 @@
           (=> |postExit|)
           (|@Tuple| |postTuple|)))
 
-(mapcar #'(lambda (x) (MAKEPROP (CAR X) '|parseTran| (CADR X)))
-        '((\<= |parseLessEqual|)
-          (\> |parseGreaterThan|)
-          (\>= |parseGreaterEqual|)
-          ($\<= |parseDollarLessEqual|)
-          ($\> |parseDollarGreaterThan|)
-          ($\>= |parseDollarGreaterEqual|)
-          ($^= |parseDollarNotEqual|)
-          (^ |parseNot|)
-          (^= |parseNotEqual|)
-          (\: |parseColon|)
-          (\:\: |parseCoerce|)
-          (\@ |parseAtSign|)
-          (|and| |parseAnd|)
-          (CATEGORY |parseCategory|)
-          (|construct| |parseConstruct|)
-          (DEF |parseDEF|)
-          (|eqv| |parseEquivalence|)
-          (|exit| |parseExit|)
-          (|has| |parseHas|)
-          (IF |parseIf|)
-          (|implies| |parseImplies|)
-          (IN |parseIn|)
-          (INBY |parseInBy|)
-          (|is| |parseIs|)
-          (|isnt| |parseIsnt|)
-          (|Join| |parseJoin|)
-          (|leave| |parseLeave|)
-          (LET |parseLET|)
-          (LETD |parseLETD|)
-          (MDEF |parseMDEF|)
-          (|not| |parseNot|)
-          (|or| |parseOr|)
-          (|pretend| |parsePretend|)
-          (|return| |parseReturn|)
-          (SEQ |parseSeq|)
-          (VCONS |parseVCONS|)
-          (|where| |parseWhere|)
-          (|xor| |parseExclusiveOr|)))
+;(mapcar #'(lambda (x) (MAKEPROP (CAR X) '|parseTran| (CADR X)))
+;        '(
+;          (\<= |parseLessEqual|)
+;          (\> |parseGreaterThan|)
+;          (\>= |parseGreaterEqual|)
+;          ($\<= |parseDollarLessEqual|)
+;          ($\> |parseDollarGreaterThan|)
+;          ($\>= |parseDollarGreaterEqual|)
+;          ($^= |parseDollarNotEqual|)
+;          (^ |parseNot|)
+;          (^= |parseNotEqual|)
+;          (\: |parseColon|)
+;          (\:\: |parseCoerce|)
+;          (\@ |parseAtSign|)
+;          (|and| |parseAnd|)
+;          (CATEGORY |parseCategory|)
+;          (|construct| |parseConstruct|)
+;          (DEF |parseDEF|)
+;          (|eqv| |parseEquivalence|)
+;          (|exit| |parseExit|)
+;          (|has| |parseHas|)
+;          (IF |parseIf|)
+;          (|implies| |parseImplies|)
+;          (IN |parseIn|)
+;          (INBY |parseInBy|)
+;          (|is| |parseIs|)
+;          (|isnt| |parseIsnt|)
+;;          (|Join| |parseJoin|)
+;          (|leave| |parseLeave|)
+;          (LET |parseLET|)
+;          (LETD |parseLETD|)
+;          (MDEF |parseMDEF|)
+;          (|not| |parseNot|)
+;          (|or| |parseOr|)
+;          (|pretend| |parsePretend|)
+;          (|return| |parseReturn|)
+;          (SEQ |parseSeq|)
+;          (VCONS |parseVCONS|)
+;          (|where| |parseWhere|)
+;;          (|xor| |parseExclusiveOr|)
+;))
 @
 \eject
 \begin{thebibliography}{99}
diff --git a/src/interp/vmlisp.lisp.pamphlet b/src/interp/vmlisp.lisp.pamphlet
index a87f103..0122098 100644
--- a/src/interp/vmlisp.lisp.pamphlet
+++ b/src/interp/vmlisp.lisp.pamphlet
@@ -6786,53 +6786,8 @@ o  there is some code at the end of SPECEVAL BOOT that puts "up"
   (|Enumeration| |mkEnumerationFunList|)
 )) (MAKEPROP (CAR X) '|makeFunctionList|  (CADR X)))
 
-(REPEAT (IN X '(
-;  (|<=| |parseLessEqual|)
-;  (|>| |parseGreaterThan|)
-;  (|>=| |parseGreaterEqual|)
-  (|$<=| |parseDollarLessEqual|)
-  (|$>| |parseDollarGreaterThan|)
-  (|$>=| |parseDollarGreaterEqual|)
-  ($^= |parseDollarNotEqual|)
-  (^ |parseNot|)
-  (^= |parseNotEqual|)
-;  (\: |parseColon|)
-;  (|::| |parseCoerce|)
-;  (@ |parseAtSign|)
-;;These two lines were commented out in the original sources.
-;;However both of these lines involved control characters that
-;;latex cannot handle. control-V and control-H should be the
-;;actual control characters, not the text replacement shown here.
-;;(control-V |parseUpArrow|) 
-;;(|control-H| |parseLeftArrow|) 
-;  (|and| |parseAnd|)
-;  (CATEGORY |parseCategory|)
-;  (|construct| |parseConstruct|)
-;  (DEF |parseDEF|)
-;  (|eqv| |parseEquivalence|)
-;  (|exit| |parseExit|)
-;  (|has| |parseHas|)
-;  (IF |parseIf|)
-;  (|implies| |parseImplies|)
-  (IN |parseIn|)
-  (INBY |parseInBy|)
-  (|is| |parseIs|)
-  (|isnt| |parseIsnt|)
-  (|Join| |parseJoin|)
-;  (|leave| |parseLeave|)
-  (LET |parseLET|)
-  (LETD |parseLETD|)
-  (MDEF |parseMDEF|)
-  (|not| |parseNot|)
-  (|or| |parseOr|)
-  (|pretend| |parsePretend|)
-  (|return| |parseReturn|)
-  (SEGMENT |parseSegment|)
-  (SEQ |parseSeq|)
-  (VCONS |parseVCONS|)
-  (|where| |parseWhere|)
+;  (SEGMENT |parseSegment|)
 ;;  (|xor| |parseExclusiveOr|)
-)) (MAKEPROP (CAR X) '|parseTran| (CADR X)))
 
 (MAKEPROP 'INTEGER 'ISFUNCTION 'INTEGERP)
 (MAKEPROP '|Integer| '|isFunction| '|IsInteger|)