diff --git a/books/bookvol5.pamphlet b/books/bookvol5.pamphlet
index 1e8bbac..bc6bc63 100644
--- a/books/bookvol5.pamphlet
+++ b/books/bookvol5.pamphlet
@@ -51419,6 +51419,478 @@ There are 8 parts of an htPage:
\end{chunk}
+\defun{kcdePage}{kcdePage}
+\calls{kcdePage}{htpProperty}
+\calls{kcdePage}{concat}
+\calls{kcdePage}{nequal}
+\calls{kcdePage}{ncParseFromString}
+\calls{kcdePage}{opOf}
+\calls{kcdePage}{getDependentsOfConstructor}
+\calls{kcdePage}{getConstructorForm}
+\calls{kcdePage}{htpSetProperty}
+\calls{kcdePage}{dbShowCons}
+\begin{chunk}{defun kcdePage}
+(defun |kcdePage| (htPage junk)
+ (declare (ignore junk))
+ (let (lt1 kind name args conname constring conform pakname domlist cAlist)
+ (setq lt1 (|htpProperty| htPage '|parts|))
+ (setq kind (first lt1))
+ (setq name (second lt1))
+ (setq args (sixth lt1))
+ (setq conname (intern name))
+ (setq constring (concat name args))
+ (setq conform
+ (if (nequal kind "default package")
+ (|ncParseFromString| constring)
+ (cons (intern name) (cdr (|ncParseFromString| (concat #\d args))))))
+ (setq pakname (|opOf| conform))
+ (setq domlist (|getDependentsOfConstructor| pakname))
+ (setq cAlist
+ (loop for x in domList collect (cons (|getConstructorForm| x) t)))
+ (|htpSetProperty| htPage '|cAlist| cAlist)
+ (|htpSetProperty| htPage '|thing| "dependent")
+ (|dbShowCons| htPage '|names|)))
+
+\end{chunk}
+
+\defun{getDependentsOfConstructor}{getDependentsOfConstructor}
+\calls{getDependentsOfConstructor}{readLibPathFast}
+\calls{getDependentsOfConstructor}{pathname}
+\calls{getDependentsOfConstructor}{rread}
+\calls{getDependentsOfConstructor}{rshut}
+\begin{chunk}{defun getDependentsOfConstructor}
+(defun |getDependentsOfConstructor| (con)
+ (let (stream val)
+ (setq stream
+ (|readLibPathFast| (|pathname| (list '|dependents| 'database '|a|))))
+ (setq val (|rread| con stream nil))
+ (rshut stream)
+ val))
+
+\end{chunk}
+
+\defun{kcuPage}{kcuPage}
+\calls{kcuPage}{htpProperty}
+\calls{kcuPage}{concat}
+\calls{kcuPage}{nequal}
+\calls{kcuPage}{ncParseFromString}
+\calls{kcuPage}{opOf}
+\calls{kcuPage}{getUsersOfConstructor}
+\calls{kcuPage}{getConstructorForm}
+\calls{kcuPage}{htpSetProperty}
+\calls{kcuPage}{dbShowCons}
+\begin{chunk}{defun kcuPage}
+(defun |kcuPage| (htPage junk)
+ (declare (ignore junk))
+ (let (lt1 kind name args conname constring conform pakname domlist cAlist)
+ (setq lt1 (|htpProperty| htPage '|parts|))
+ (setq kind (first lt1))
+ (setq name (second lt1))
+ (setq args (sixth lt1))
+ (setq conname (intern name))
+ (setq constring (concat name args))
+ (setq conform
+ (if (nequal kind "default package")
+ (|ncParseFromString| constring)
+ (cons (intern name)
+ (cdr (|ncParseFromString| (concat #\d args))))))
+ (setq pakname
+ (if (string= kind "category")
+ (intern (concat name #\&))
+ (|opOf| conform)))
+ (setq domlist (|getUsersOfConstructor| pakname))
+ (setq cAlist
+ (loop for x in domlist collect (cons (|getConstructorForm| x) t)))
+ (|htpSetProperty| htPage '|cAlist| cAlist)
+ (|htpSetProperty| htPage '|thing| "user")
+ (|dbShowCons| htPage '|names|)))
+
+\end{chunk}
+
+\defun{getUsersOfConstructor}{getUsersOfConstructor}
+\calls{getUsersOfConstructor}{readLibPathFast}
+\calls{getUsersOfConstructor}{pathname}
+\calls{getUsersOfConstructor}{rread}
+\calls{getUsersOfConstructor}{rshut}
+\begin{chunk}{defun getUsersOfConstructor}
+(defun |getUsersOfConstructor| (con)
+ (let (stream val)
+ (setq stream (|readLibPathFast| (|pathname| (list '|users| 'database '|a|))))
+ (setq val (|rread| con stream nil))
+ (rshut stream)
+ val))
+
+\end{chunk}
+
+\defun{kcnPage}{kcnPage}
+\calls{kcnPage}{kDomainName}
+\calls{kcnPage}{qcar}
+\calls{kcnPage}{errorPage}
+\calls{kcnPage}{htpProperty}
+\calls{kcnPage}{form2HtString}
+\calls{kcnPage}{htpSetProperty}
+\calls{kcnPage}{concat}
+\calls{kcnPage}{pname}
+\calls{kcnPage}{opOf}
+\calls{kcnPage}{getImports}
+\calls{kcnPage}{sublislis}
+\calls{kcnPage}{dbShowCons}
+\begin{chunk}{defun kcnPage}
+(defun |kcnPage| (htPage junk)
+ (declare (ignore junk))
+ (let (lt1 kind name nargs domname heading conform pakname domlist cAlist)
+ (setq lt1 (|htpProperty| htPage '|parts|))
+ (setq kind (first lt1))
+ (setq name (second lt1))
+ (setq nargs (third lt1))
+ (setq domname (|kDomainName| htPage kind name nargs))
+ (cond
+ ((and (consp domname) (eq (qcar domname) '|error|))
+ (|errorPage| htPage domname))
+ (t
+ (setq heading
+ (if (null domname)
+ (|htpProperty| htPage '|heading|)
+ (list "{\\sf " (|form2HtString| domname nil t) "}")))
+ (if domname
+ (|htpSetProperty| htPage '|domname| domname)
+ (|htpSetProperty| htPage '|heading| heading))
+ (setq conform (|htpProperty| htPage '|conform|))
+ (setq pakname
+ (if (string= kind "category")
+ (intern (concat (pname conname) #\&))
+ (|opOf| conform)))
+ (setq domlist (|getImports| pakname))
+ (when domname
+ (setq domlist
+ (sublislis (cons domname (cdr domname))
+ (cons '$ (cdr conform)) domlist)))
+ (setq cAlist (loop for x in domList collect (cons x t)))
+ (|htpSetProperty| htPage '|cAlist| cAlist)
+ (|htpSetProperty| htPage '|thing| "benefactor")
+ (|dbShowCons| htPage '|names|)))))
+
+\end{chunk}
+
+\defun{koPageInputAreaUnchanged?}{koPageInputAreaUnchanged?}
+\calls{koPageInputAreaUnchanged?}{htpLabelInputString}
+\calls{koPageInputAreaUnchanged?}{concat}
+\calls{koPageInputAreaUnchanged?}{stringimage}
+\calls{koPageInputAreaUnchanged?}{htpProperty}
+\begin{chunk}{defun koPageInputAreaUnchanged?}
+(defun |koPageInputAreaUnchanged?| (htPage nargs)
+ (equal
+ (loop for i from 1 to nargs
+ collect
+ (|htpLabelInputString| htPage (intern (concat "*" (stringimage i)))))
+ (|htpProperty| htPage '|inputAreaList|)))
+
+\end{chunk}
+
+\defun{kDomainName}{kDomainName}
+\calls{kDomainName}{htpSetProperty}
+\calls{kDomainName}{htpLabelInputString}
+\calls{kDomainName}{getdatabase}
+\calls{kDomainName}{kArgumentCheck}
+\calls{kDomainName}{kdr}
+\calls{kDomainName}{concat}
+\calls{kDomainName}{unabbrev}
+\calls{kDomainName}{mkConform}
+\calls{kDomainName}{kisValidType}
+\calls{kDomainName}{dbMkEvalable}
+\catches{kDomainName}{spad-reader}
+\usesdollar{kDomainName}{PatternVariableList}
+\begin{chunk}{defun kDomainName}
+(defun |kDomainName| (htPage kind name nargs)
+ (let (inputAreaList conname args n argTailPart argString typeForm
+ evaluatedTypeForm)
+ (|htpSetProperty| htPage '|domname| nil)
+ (setq inputAreaList
+ (loop for i from 1 to nargs for var in |$PatternVariableList| do
+ collect (|htpLabelInputString| htPage var)))
+ (|htpSetProperty| htPage '|inputAreaList| inputAreaList)
+ (setq conname (intern name))
+ (setq args
+ (loop for x in inputAreaList
+ for domain? in (cdr (getdatabase conname 'cosig))
+ collect (or (|kArgumentCheck| domain? x) nil)))
+ (when (some #'identity (loop for x in args collect (null x)))
+ (cond
+ ((> (setq n (apply #'+ (loop for x in args collect (if x 1 0)))) 0)
+ (list '|error| nil "\\centerline{You gave values for only {\\em "
+ n " } of the {\\em " (|#| args) "}}"
+ "\\centerline{parameters of {\\sf " name
+ "}}\\vspace{1}\\centerline{Please enter either {\\em all} or "
+ "{\\em none} of the type parameters}")
+ nil)
+ (t
+ (setq argString
+ (cond
+ ((null args) "()")
+ (t
+ (setq argTailPart
+ (apply #'concat
+ (loop for x in (kdr args) collect (concat (cons "," x)))))
+ (apply #'concat (list "(" (car args) argTailPart ")")))))
+ (setq typeForm
+ (or (catch 'spad_reader (|unabbrev| (|mkConform| kind name argString)))
+ (list '|error| '|invalidType| (concat name argString))))
+ (if (null (setq evaluatedTypeForm (|kisValidType| typeForm)))
+ (list '|error| '|invalidType| (concat name argString))
+ (|dbMkEvalable| evaluatedTypeForm)))))))
+
+\end{chunk}
+
+\defun{kArgumentCheck}{kArgumentCheck}
+\calls{kArgumentCheck}{conSpecialString?}
+\calls{kArgumentCheck}{kdr}
+\calls{kArgumentCheck}{stringimage}
+\calls{kArgumentCheck}{opOf}
+\calls{kArgumentCheck}{form2String}
+\begin{chunk}{defun kArgumentCheck}
+(defun |kArgumentCheck| (domain? s)
+ (let (form)
+ (cond
+ ((string= s "") nil)
+ ((and domain? (setq form (|conSpecialString?| s)))
+ (if (null (kdr form))
+ (list (stringimage (|opOf| form)))
+ (|form2String| form)))
+ (t (list s)))))
+
+\end{chunk}
+
+\defun{dbMkEvalable}{dbMkEvalable}
+\calls{dbMkEvalable}{getdatabase}
+\calls{dbMkEvalable}{mkEvalable}
+\begin{chunk}{defun dbMkEvalable}
+(defun |dbMkEvalable| (form)
+ (let (op kind)
+ (setq op (car form))
+ (setq kind (getdatabase op 'constructorkind))
+ (if (eq kind '|category|)
+ form
+ (|mkEvalable| form))))
+
+\end{chunk}
+
+\defun{topLevelInterpEval}{topLevelInterpEval}
+\calls{topLevelInterpEval}{processInteractive}
+\usesdollar{topLevelInterpEval}{ProcessInteractiveValue}
+\usesdollar{topLevelInterpEval}{noEvalTypeMsg}
+\begin{chunk}{defun topLevelInterpEval}
+(defun |topLevelInterpEval| (x)
+ (let (|$ProcessInteractiveValue| |$noEvalTypeMsg|)
+ (declare (special |$ProcessInteractiveValue| |$noEvalTypeMsg|))
+ (setq |$ProcessInteractiveValue| t)
+ (setq |$noEvalTypeMsg| t)
+ (|processInteractive| x nil)))
+
+\end{chunk}
+
+\defun{kisValidType}{kisValidType}
+\calls{kisValidType}{processInteractive}
+\calls{kisValidType}{member}
+\calls{kisValidType}{kCheckArgumentNumbers}
+\usesdollar{kisValidType}{ProcessInteractiveValue}
+\usesdollar{kisValidType}{noEvalTypeMsg}
+\catches{kisValidType}{spad-reader}
+\begin{chunk}{defun kisValidType}
+(defun |kisValidType| (typeForm)
+ (let (|$ProcessInteractiveValue| |$noEvalTypeMsg| it1)
+ (declare (special |$ProcessInteractiveValue| |$noEvalTypeMsg|))
+ (setq |$ProcessInteractiveValue| t)
+ (setq |$noEvalTypeMsg| t)
+ (setq it1 (catch 'spad_reader (|processInteractive| typeForm nil)))
+ (when (and (consp it1) (consp (qcar it1)))
+ (|member| (caar it1) '(domain |SubDomain|)))
+ (and (|kCheckArgumentNumbers| (qcdr it1)) (qcdr it1))))
+
+\end{chunk}
+
+\defun{kCheckArgumentNumbers}{kCheckArgumentNumbers}
+\calls{kCheckArgumentNumbers}{kdr}
+\calls{kCheckArgumentNumbers}{getdatabase}
+\calls{kCheckArgumentNumbers}{kCheckArgumentNumber}
+\begin{chunk}{defun kCheckArgumentNumbers}
+(defun |kCheckArgumentNumbers| (tt)
+ (let (conname args cosig)
+ (setq conname (car tt))
+ (setq args (cdr tt))
+ (setq cosig (kdr (getdatabase conname 'cosig)))
+ (every #'identity
+ (loop for domain? in cosig for x in args
+ collect (if domain? (|kCheckArgumentNumbers| x) t)))))
+
+\end{chunk}
+
+\defun{parseNoMacroFromString}{parseNoMacroFromString}
+\calls{parseNoMacroFromString}{next}
+\calls{parseNoMacroFromString}{function}
+\calls{parseNoMacroFromString}{ncloopParse}
+\calls{parseNoMacroFromString}{lineoftoks}
+\calls{parseNoMacroFromString}{incString}
+\calls{parseNoMacroFromString}{StreamNull}
+\calls{parseNoMacroFromString}{pf2Sex}
+\begin{chunk}{defun parseNoMacroFromString}
+(defun |parseNoMacroFromString| (s)
+ (setq s
+ (|next| (|function| |ncloopParse|)
+ (|next| (|function| |lineoftoks|)
+ (|incString| s))))
+ (if (|StreamNull| s)
+ nil
+ (|pf2Sex| (cadar s))))
+
+\end{chunk}
+
+\defun{mkConform}{mkConform}
+\calls{mkConform}{nequal}
+\calls{mkConform}{parseNoMacroFromString}
+\calls{mkConform}{sayBrightlyNT}
+\calls{mkConform}{pp}
+\calls{mkConform}{systemError}
+\calls{mkConform}{ncParseFromString}
+\calls{mkConform}{concat}
+\begin{chunk}{defun mkConform}
+(defun |mkConform| (kind name argString)
+ (let (form parse)
+ (cond
+ ((nequal kind "default package")
+ (setq form (concat name argString))
+ (setq parse (|parseNoMacroFromString| form))
+ (cond
+ ((null parse)
+ (|sayBrightlyNT| "Won't parse: ")
+ (|pp| form)
+ (|systemError| "Keywords in argument list?"))
+ ((atom parse) (cons parse nil))
+ (t parse)))
+ (t
+ (cons (intern name) (cdr (|ncParseFromString| (concat #\d argString))))))))
+
+\end{chunk}
+
+\defun{conOpPage}{conOpPage}
+\calls{conOpPage}{dbCompositeWithMap}
+\calls{conOpPage}{htpProperty}
+\calls{conOpPage}{conOpPage1}
+\calls{conOpPage}{dbExtractUnderlyingDomain}
+\begin{chunk}{defun conOpPage}
+(defun |conOpPage| (htPage conform)
+ (declare (ignore conform))
+ (let (updown domname)
+ (setq updown (|dbCompositeWithMap| htPage))
+ (cond
+ ((string= updown "DOWN")
+ (setq domname (|htpProperty| htPage '|domname|))
+ (|conOpPage1| (|dbExtractUnderlyingDomain| domname)
+ (list (cons '|updomain| domname))))
+ (t
+ (setq domname (|htpProperty| htPage '|updomain|))
+ (|conOpPage1| domname nil)))))
+
+\end{chunk}
+
+\defun{conOpPage1}{conOpPage1}
+\calls{conOpPage1}{ifcar}
+\calls{conOpPage1}{opOf}
+\calls{conOpPage1}{dbSpecialOperations}
+\calls{conOpPage1}{conPageFastPath}
+\calls{conOpPage1}{dbXParts}
+\calls{conOpPage1}{concat}
+\calls{conOpPage1}{mkConform}
+\calls{conOpPage1}{captialize}
+\calls{conOpPage1}{ncParseFromString}
+\calls{conOpPage1}{dbSourceFile}
+\calls{conOpPage1}{isExposedConstructor}
+\calls{conOpPage1}{htInitPage}
+\calls{conOpPage1}{htpSetProperty}
+\calls{conOpPage1}{lassoc}
+\calls{conOpPage1}{ifcdr}
+\calls{conOpPage1}{koPage}
+\usesdollar{conOpPage1}{Primitives}
+\begin{chunk}{defun conOpPage1}
+(defun |conOpPage1| (&rest args)
+ (let (bindingsAlist conname domname line parts name sig args isFile kind
+ constring capitalKind signature sourceFileName emString heading page
+ selectedOperation a b options conform)
+ (declare (special |$Primitives|))
+ (setq conform (car args))
+ (setq options (cdr args))
+ (setq bindingsAlist (ifcar options))
+ (setq conname (|opOf| conform))
+ (cond
+ ((member conname |$Primitives|) (|dbSpecialOperations| conname))
+ (t
+ (setq domname (unless (atom conform) conform))
+ (setq line (|conPageFastPath| conname))
+ (setq parts (|dbXParts| line 7 1))
+ (setq kind (first parts))
+ (setq name (second parts))
+ (setq sig (fifth parts))
+ (setq args (sixth parts))
+ (setq isFile (null kind))
+ (setq kind (or kind "package"))
+ (rplaca parts kind)
+ (setq constring (concat name args))
+ (setq conform (|mkConform| kind name args))
+ (setq capitalKind (|capitalize| kind))
+ (setq signature (|ncParseFromString| sig))
+ (setq sourceFileName (|dbSourceFile| (intern name)))
+ (setq emString (list "{\\sf " constring "}"))
+ (setq heading (cons capitalKind (cons " " emString)))
+ (unless (|isExposedConstructor| conname)
+ (setq heading (cons "Unexposed " heading)))
+ (setq page (|htInitPage| heading nil))
+ (|htpSetProperty| page '|isFile| t)
+ (|htpSetProperty| page '|fromConOpPage1| t)
+ (|htpSetProperty| page '|parts| parts)
+ (|htpSetProperty| page '|heading| heading)
+ (|htpSetProperty| page '|kind| kind)
+ (|htpSetProperty| page '|domname| domname)
+ (|htpSetProperty| page '|conform| conform)
+ (|htpSetProperty| page '|signature| signature)
+ (when
+ (setq selectedOperation (lassoc '|selectedOperation| (ifcdr options)))
+ (|htpSetProperty| page '|selectedOperation| selectedOperation))
+ (loop for item in bindingsAlist
+ collect (|htpSetProperty| page (car item) (cdr item)))
+ (|koPage| page "operation")))))
+
+\end{chunk}
+
+\defun{dbCompositeWithMap}{dbCompositeWithMap}
+\calls{dbCompositeWithMap}{htpProperty}
+\calls{dbCompositeWithMap}{dbExtractUnderlyingDomain}
+\begin{chunk}{defun dbCompositeWithMap}
+(defun |dbCompositeWithMap| (htPage)
+ (let (domain opAlist)
+ (cond
+ ((|htpProperty| htPage '|updomain|) "UP")
+ (t
+ (setq domain (|htpProperty| htPage '|domname|))
+ (cond
+ ((null domain) nil)
+ (t
+ (setq opAlist (|htpProperty| htPage '|opAlist|))
+ (when
+ (|dbExtractUnderlyingDomain| (|htpProperty| htPage '|domname|))
+ "DOWN")))))))
+
+\end{chunk}
+
+\defun{dbExtractUnderlyingDomain}{dbExtractUnderlyingDomain}
+\calls{dbExtractUnderlyingDomain}{kdr}
+\calls{dbExtractUnderlyingDomain}{isValidType}
+\begin{chunk}{defun dbExtractUnderlyingDomain}
+(defun |dbExtractUnderlyingDomain| (domain)
+ (some #'identity
+ (loop for x in (kdr domain) when (|isValidType| x) collect x)))
+
+\end{chunk}
+
+
\chapter{The Interpreter}
\begin{chunk}{Interpreter}
(setq *print-array* nil)
@@ -52004,6 +52476,8 @@ There are 8 parts of an htPage:
\getchunk{defun compressOpen}
\getchunk{defun computeDomainVariableAlist}
\getchunk{defun condErrorMsg}
+\getchunk{defun conOpPage}
+\getchunk{defun conOpPage1}
\getchunk{defun conPage}
\getchunk{defun conPageConEntry}
\getchunk{defun conPageFastPath}
@@ -52015,6 +52489,8 @@ There are 8 parts of an htPage:
\getchunk{defun countCache}
\getchunk{defun DaaseName}
+\getchunk{defun dbCompositeWithMap}
+\getchunk{defun dbExtractUnderlyingDomain}
\getchunk{defun dbNonEmptyPattern}
\getchunk{defun dbSearchOrder}
\getchunk{defun decideHowMuch}
@@ -52130,6 +52606,7 @@ There are 8 parts of an htPage:
\getchunk{defun getBpiNameIfTracedMap}
\getchunk{defun getBrowseDatabase}
\getchunk{defun getdatabase}
+\getchunk{defun getDependentsOfConstructor}
\getchunk{defun getDirectoryList}
\getchunk{defun getFirstWord}
\getchunk{defun getKeyedMsg}
@@ -52156,6 +52633,7 @@ There are 8 parts of an htPage:
\getchunk{defun getTraceOption}
\getchunk{defun getTraceOption,hn}
\getchunk{defun getTraceOptions}
+\getchunk{defun getUsersOfConstructor}
\getchunk{defun getWorkspaceNames}
\getchunk{defun handleNoParseCommands}
@@ -52387,20 +52865,28 @@ There are 8 parts of an htPage:
\getchunk{defun justifyMyType}
\getchunk{defun kArgPage}
+\getchunk{defun kArgumentCheck}
\getchunk{defun kcaPage}
\getchunk{defun kcaPage1}
\getchunk{defun kccPage}
+\getchunk{defun kcdePage}
\getchunk{defun kcdPage}
\getchunk{defun kcdoPage}
+\getchunk{defun kCheckArgumentNumbers}
+\getchunk{defun kcnPage}
\getchunk{defun kcPage}
\getchunk{defun kcpPage}
+\getchunk{defun kDomainName}
\getchunk{defun kdPageInfo}
\getchunk{defun KeepPart?}
\getchunk{defun kePage}
\getchunk{defun kePageDisplay}
\getchunk{defun kePageOpAlist}
\getchunk{defun kiPage}
+\getchunk{defun kisValidType}
+\getchunk{defun koPageInputAreaUnchanged?}
\getchunk{defun ksPage}
+\getchunk{defun kcuPage}
\getchunk{defun lassocSub}
\getchunk{defun lastTokPosn}
@@ -52468,6 +52954,7 @@ There are 8 parts of an htPage:
\getchunk{defun messageprint}
\getchunk{defun messageprint-1}
\getchunk{defun messageprint-2}
+\getchunk{defun mkConform}
\getchunk{defun mkCurryFun}
\getchunk{defun mkDomPvar}
\getchunk{defun mkDomTypeForm}
@@ -52771,6 +53258,7 @@ There are 8 parts of an htPage:
\getchunk{defun parseAndEval1}
\getchunk{defun parseAndInterpret}
\getchunk{defun parseFromString}
+\getchunk{defun parseNoMacroFromString}
\getchunk{defun parseSystemCmd}
\getchunk{defun parseWord}
\getchunk{defun pathname}
@@ -53235,6 +53723,7 @@ There are 8 parts of an htPage:
\getchunk{defun tokPosn}
\getchunk{defun tokTran}
\getchunk{defun tokType}
+\getchunk{defun topLevelInterpEval}
\getchunk{defun toScreen?}
\getchunk{defun trace}
\getchunk{defun trace1}
diff --git a/changelog b/changelog
index fd73f38..ec8b45f 100644
--- a/changelog
+++ b/changelog
@@ -1,3 +1,6 @@
+20130607 tpd src/axiom-website/patches.html 20130607.03.tpd.patch
+20130607 tpd src/interp/br-con.lisp move functions to bookvol5
+20130607 tpd books/bookvol5 move functions from br-con.lisp
20130607 tpd src/axiom-website/patches.html 20130607.02.tpd.patch
20130607 tpd books/bookvol0 fix typos
20130607 tpd books/bookvol1 fix typos
diff --git a/src/axiom-website/patches.html b/src/axiom-website/patches.html
index dd689e8..ae49d5f 100644
--- a/src/axiom-website/patches.html
+++ b/src/axiom-website/patches.html
@@ -4195,6 +4195,8 @@ books/bookvol5 rewrite code from br-con
books/bookvol8.1 add crc test cases
20130607.02.tpd.patch
books/bookvol{0,1,2,4} fix typos
+20130607.03.tpd.patch
+books/bookvol5 move functions from br-con.lisp