diff --git a/books/bookvol5.pamphlet b/books/bookvol5.pamphlet
index 7e34eb5..7e867a0 100644
--- a/books/bookvol5.pamphlet
+++ b/books/bookvol5.pamphlet
@@ -39566,95 +39566,544 @@ See Steele Common Lisp 1990 pp305-307
 \end{chunk}
 
 \chapter{OpenMath stub functions}
-\section{Lisp conversion functions}
-The lisp conversion functions are:
+These stub functions will eventually be expanded to handle OpenMath.
+See the OpenMathDevice domain in Volume 10.3. Note that the argument
+list for the Spad functions does not always match the argument list
+specified in the OpenMath specification.
+
+There are 4 known OpenMath encodings which are set up in the OpenMathEncoding
+domain in Volume 10.3.
 \begin{itemize}
-\item (toDev LispObject) $->$ OMdev
-\item (fromDev OMdev) $->$ LispObject
-\item (toStatus LispObject) $->$ LispObject
-\item (fromStatus OMstatus) $->$ LispObject
-\item (toEncodingType LispObject) $->$ OMencodingType
-\item (fromEncodingType OMencodingType) $->$ LispObject
-\item (toBigNumStr LispObject) $->$ char *
-\item (fromBigNumStr(char *,int,int, OMbigIntType) $->$ LispObject
-\item (toConn LispObject) $->$ OMconn
-\item (fromConn OMconn) $->$ LispObject
-\item (toCString LispObject) $->$ char **
-\item (fromCString char **) $->$ LispObject
-\item (lispStringFromCString LispObject) $->$ LispObject
-\item (cStringFromLispString LispObject) $->$ LispObject
+\item Unknown 
+\item Binary
+\item XML
+\item SGML
 \end{itemize}
 
+\section{Axiom specific functions}
+This is used in OpenMathPackage in Volume 10.4.
+\begin{verbatim}
+(read OMdev)              -> LispObject
+(listCDs)                 -> List(String)
+(listSymbols)             -> List(String)
+(supportsCD cd)           -> Boolean
+(supportsSymbol cd name)  -> Boolean
+\end{verbatim}
+
+\defun{om-Read}{om-Read}
+Read an OpenMath object from dev.
+\begin{chunk}{defun om-Read}
+(defun om-Read (dev))
+
+\end{chunk}
+
+\defun{om-listCDs}{om-listCDs}
+Lists all of the CDs supported by Axiom.
+\begin{chunk}{defun om-listCDs}
+(defun om-listCDs ())
+
+\end{chunk}
+
+\defun{om-listSymbols}{om-listSymbols}
+Lists all the symbols in CD
+\begin{chunk}{defun om-listSymbols}
+(defun om-listSymbols ())
+
+\end{chunk}
+
+\defun{om-supportsCD}{om-supportsCD}
+Return true if Axiom supports this CD.
+\begin{chunk}{defun om-supportsCD}
+(defun om-supportsCD (cd))
+
+\end{chunk}
+
+\defun{om-supportsSymbol}{om-supportsSymbol}
+\begin{chunk}{defun om-supportsSymbol}
+(defun om-supportsSymbol (cd name))
+
+\end{chunk}
+
+\section{Lisp conversion functions}
+The lisp conversion functions are:
+\begin{verbatim}
+ (toDev                 LispObject)                   -> OMdev
+ (fromDev               OMdev)                        -> LispObject
+ (toStatus              LispObject)                   -> LispObject
+ (fromStatus            OMstatus)                     -> LispObject
+ (toEncodingType        LispObject)                   -> OMencodingType
+ (fromEncodingType      OMencodingType)               -> LispObject
+ (toBigNumStr           LispObject)                   -> char *
+ (fromBigNumStr         char *,int,int, OMbigIntType) -> LispObject
+ (toConn                LispObject)                   -> OMconn
+ (fromConn              OMconn)                       -> LispObject
+ (toCString             LispObject)                   -> char **
+ (fromCString           char **)                      -> LispObject
+ (lispStringFromCString LispObject)                   -> LispObject
+ (cStringFromLispString LispObject)                   -> LispObject
+\end{verbatim}
+
+\defun{om-setDevEncoding}{om-setDevEncoding}
+This sets the encoding used for reading or writeing OpenMath objects to
+or from dev to enc.
+\begin{chunk}{defun om-setDevEncoding}
+(defun om-setDevEncoding (dev enc))
+
+\end{chunk}
+
 \section{Device manipulation functions}
-\begin{itemize}
-\item openFileDev(LispObject, ints, ...) $->$ LispObject
-\item openStrDev(LispObject, LispObject, LispObject) $->$ LispObject
-\item closeDev(LispObject, LispObject) $->$ LispObject
-\end{itemize}
+\begin{verbatim}
+(openFileDev LispObject, ints, ...)              -> LispObject
+(openStrDev  LispObject, LispObject, LispObject) -> LispObject
+(closeDev    LispObject, LispObject)             -> LispObject
+\end{verbatim}
+
+\defun{om-openFileDev}{om-openFileDev}
+This opens file fname for reading or writing OpenMath objects.
+The mode can be ``r'' for read, ``w'' for write, or ''a'' for append.
+\begin{chunk}{defun om-openFileDev}
+(defun om-openFileDev (fname fmode enc))
+\end{chunk}
+
+\defun{om-openStringDev}{om-openStringDev}
+This opens the string str for reading and writing OpenMath objects in 
+encoding enc.
+\begin{chunk}{defun om-openStringDev}
+(defun om-openStringDev (str enc))
+
+\end{chunk}
+
+\defun{om-closeDev}{om-closeDev}
+This closes dev, flushing output if necessary.
+\begin{chunk}{defun om-closeDev}
+(defun om-closeDev (dev))
+
+\end{chunk}
 
 \section{Connection manipulation functions}
-\begin{itemize}
-\item makeConn(LispObject, LispObject) $->$ LispObject
-\item closeConn(LispObject, LispObject) $->$ LispObject
-\item getConnInDev(LispObject, LispObject) $->$ LispObject
-\item getConnOutDev(LispObject, LispObject) $->$ LispObject
-\end{itemize}
+These are covered in the OpenMathConnection domain in Volume 10.3.
+\begin{verbatim}
+ (makeConn      LispObject, LispObject) -> LispObject
+ (closeConn     LispObject, LispObject) -> LispObject
+ (getConnInDev  LispObject, LispObject) -> LispObject
+ (getConnOutDev LispObject, LispObject) -> LispObject
+\end{verbatim}
+
+\defun{om-makeConn}{om-makeConn}
+\begin{chunk}{defun om-makeConn}
+(defun om-makeConn (conn))
+
+\end{chunk}
+
+\defun{om-closeConn}{om-closeConn}
+\begin{chunk}{defun om-closeConn}
+(defun om-closeConn (conn))
+
+\end{chunk}
+
+\defun{om-getConnInDev}{om-getConnInDev}
+\begin{chunk}{defun om-getConnInDev}
+(defun om-getConnInDev (conn))
+
+\end{chunk}
+
+\defun{om-getConnOutDev}{om-getConnOutDev}
+\begin{chunk}{defun om-getConnOutDev}
+(defun om-getConnOutDev (conn))
+
+\end{chunk}
 
 \section{Client/Server functions}
+These are covered in the OpenMathConnection domain in Volume 10.3.
 See OMconn.h
-\begin{itemize}
-\item connectTCP(LispObject, int, ...) $->$ LispObject
-\item bindTCP(LispObject, LispObject, LispObject) $->$ LispObject
-\end{itemize}
+\begin{verbatim}
+(bindTCP    LispObject, LispObject, LispObject) -> LispObject
+(connectTCP LispObject, int, ...)               -> LispObject
+\end{verbatim}
+
+\defun{om-bindTCP}{om-bindTCP}
+\begin{chunk}{defun om-bindTCP}
+(defun om-bindTCP (conn port))
+
+\end{chunk}
+
+\defun{om-connectTCP}{om-connectTCP}
+\begin{chunk}{defun om-connectTCP}
+(defun om-connectTCP (conn host port))
+
+\end{chunk}
 
 \section{Device input/output functions}
+Most of these functions are in the OpenMathDevice domain in Volume 10.3.
+The only exception seems to be the om-stringPtrToString and 
+om-stringToStringPtr functions which are called in the domains that
+export primitives. Currently these are:
 \begin{itemize}
-\item putApp(LispObject, LispObject) $->$ LispObject
-\item putEndApp(LispObject, LispObject) $->$ LispObject
-\item putAtp(LispObject, LispObject) $->$ LispObject
-\item putEndAtp(LispObject, LispObject) $->$ LispObject
-\item putAttr(LispObject, LispObject) $->$ LispObject
-\item putEndAttr(LispObject, LispObject) $->$ LispObject
-\item putBind(LispObject, LispObject) $->$ LispObject
-\item putEndBind(LispObject, LispObject) $->$ LispObject
-\item putBVar(LispObject, LispObject) $->$ LispObject
-\item putEndBVar(LispObject, LispObject) $->$ LispObject
-\item putError(LispObject, LispObject) $->$ LispObject
-\item putEndError(LispObject, LispObject) $->$ LispObject
-\item putObject(LispObject, LispObject) $->$ LispObject
-\item putEndObject(LispObject, LispObject) $->$ LispObject
-\item putInt(LispObject, LispObject, LispObject) $->$ LispObject
-\item putFloat(LispObject, LispObject, LispObject) $->$ LispObject
-\item putByteArray(LispObject, LispObject, LispObject) $->$ LispObject
-\item putVar(LispObject, LispObject, LispObject) $->$ LispObject
-\item putString(LispObject, LispObject, LispObject) $->$ LispObject
-\item putSymbol(LispObject, LispObject, LispObject) $->$ LispObject
-\item putSymbol2(LispObject, int nargs, ...) $->$ LispObject
-\item getApp(LispObject, LispObject) $->$ LispObject
-\item getEndApp(LispObject, LispObject) $->$ LispObject
-\item getAtp(LispObject, LispObject) $->$ LispObject
-\item getEndAtp(LispObject, LispObject) $->$ LispObject
-\item getAttr(LispObject, LispObject) $->$ LispObject
-\item getEndAttr(LispObject, LispObject) $->$ LispObject
-\item getBind(LispObject, LispObject) $->$ LispObject
-\item getEndBind(LispObject, LispObject) $->$ LispObject
-\item getBVar(LispObject, LispObject) $->$ LispObject
-\item getEndBVar(LispObject, LispObject) $->$ LispObject
-\item getError(LispObject, LispObject) $->$ LispObject
-\item getEndError(LispObject, LispObject) $->$ LispObject
-\item getObject(LispObject, LispObject) $->$ LispObject
-\item getEndObject(LispObject, LispObject) $->$ LispObject
-\item getInt(LispObject, LispObject) $->$ LispObject
-\item getFloat(LispObject, LispObject) $->$ LispObject
-\item getByteArray(LispObject, LispObject) $->$ LispObject
-\item getVar(LispObject, LispObject) $->$ LispObject
-\item getString(LispObject, LispObject) $->$ LispObject
-\item getSymbol(LispObject, LispObject) $->$ LispObject
-\item getType(LispObject, LispObject) $->$ LispObject
-\item stringToStringPtr(LispObject, LispObject) $->$ LispObject
-\item stringPtrToString(LispObject, LispObject) $->$ LispObject
+\item Complex (10.3)
+\item DoubleFloat (10.3)
+\item Float (10.3)
+\item Fraction (10.3)
+\item Integer (10.3)
+\item List (10.3)
+\item SingleInteger (10.3)
+\item String (10.3)
+\item Symbol (10.3)
+\item ExpressionToOpenMath (10.4)
+\item OpenMathPackage (10.4)
 \end{itemize}
 
+Note that putSymbol2 is not implemented.
+\begin{verbatim}
+(getApp            LispObject, LispObject) -> LispObject
+(getAtp            LispObject, LispObject) -> LispObject
+(getAttr           LispObject, LispObject) -> LispObject
+(getBind           LispObject, LispObject) -> LispObject
+(getBVar           LispObject, LispObject) -> LispObject
+(getByteArray      LispObject, LispObject) -> LispObject
+(getEndApp         LispObject, LispObject) -> LispObject
+(getEndAtp         LispObject, LispObject) -> LispObject
+(getEndAttr        LispObject, LispObject) -> LispObject
+(getEndBind        LispObject, LispObject) -> LispObject
+(getEndBVar        LispObject, LispObject) -> LispObject
+(getEndError       LispObject, LispObject) -> LispObject
+(getEndObject      LispObject, LispObject) -> LispObject
+(getError          LispObject, LispObject) -> LispObject
+(getFloat          LispObject, LispObject) -> LispObject
+(getInt            LispObject, LispObject) -> LispObject
+(getObject         LispObject, LispObject) -> LispObject
+(getString         LispObject, LispObject) -> LispObject
+(getSymbol         LispObject, LispObject) -> LispObject
+(getType           LispObject, LispObject) -> LispObject
+(getVar            LispObject, LispObject) -> LispObject
+(putApp            LispObject, LispObject) -> LispObject
+(putAtp            LispObject, LispObject) -> LispObject
+(putAttr           LispObject, LispObject) -> LispObject
+(putBind           LispObject, LispObject) -> LispObject
+(putBVar           LispObject, LispObject) -> LispObject
+(putByteArray      LispObject, LispObject, LispObject) -> LispObject
+(putEndApp         LispObject, LispObject) -> LispObject
+(putEndAtp         LispObject, LispObject) -> LispObject
+(putEndAttr        LispObject, LispObject) -> LispObject
+(putEndBind        LispObject, LispObject) -> LispObject
+(putEndBVar        LispObject, LispObject) -> LispObject
+(putEndError       LispObject, LispObject) -> LispObject
+(putEndObject      LispObject, LispObject) -> LispObject
+(putError          LispObject, LispObject) -> LispObject
+(putFloat          LispObject, LispObject, LispObject) -> LispObject
+(putInt            LispObject, LispObject, LispObject) -> LispObject
+(putObject         LispObject, LispObject) -> LispObject
+(putString         LispObject, LispObject, LispObject) -> LispObject
+(putSymbol         LispObject, LispObject, LispObject) -> LispObject
+(putSymbol2        LispObject, int nargs, ...) -> LispObject
+(putVar            LispObject, LispObject, LispObject) -> LispObject
+(stringPtrToString LispObject, LispObject) -> LispObject
+(stringToStringPtr LispObject, LispObject) -> LispObject
+\end{verbatim}
+
+\defun{om-getApp}{om-getApp}
+Reads a begin application token from dev.
+\begin{chunk}{defun om-getApp}
+(defun om-getApp (dev))
+
+\end{chunk}
+
+\defun{om-getAtp}{om-getAtp}
+Reads a begin attribute pair token from dev.
+\begin{chunk}{defun om-getAtp}
+(defun om-getAtp (dev))
+
+\end{chunk}
+
+\defun{om-getAttr}{om-getAttr}
+Reads a begin attribute token from dev
+\begin{chunk}{defun om-getAttr}
+(defun om-getAttr (dev))
+
+\end{chunk}
+
+\defun{om-getBind}{om-getBind}
+Reads a begin binder token from dev.
+\begin{chunk}{defun om-getBind}
+(defun om-getBind (dev))
+
+\end{chunk}
+
+\defun{om-getBVar}{om-getBVar}
+Reads a begin bound variable list token from dev.
+\begin{chunk}{defun om-getBVar}
+(defun om-getBVar (dev))
+
+\end{chunk}
+
+\defun{om-getByteArray}{om-getByteArray}
+Reads a byte array from dev.
+\begin{chunk}{defun om-getByteArray}
+(defun om-getByteArray (dev))
+
+\end{chunk}
+
+\defun{om-getEndApp}{om-getEndApp}
+Reads an end application token from dev
+\begin{chunk}{defun om-getEndApp}
+(defun om-getEndApp (dev))
+
+\end{chunk}
+
+\defun{om-getEndAtp}{om-getEndAtp}
+Reads an end attribute pair token from dev.
+\begin{chunk}{defun om-getEndAtp}
+(defun om-getEndAtp (dev))
+
+\end{chunk}
+
+\defun{om-getEndAttr}{om-getEndAttr}
+Reads an end attribute token from dev.
+\begin{chunk}{defun om-getEndAttr}
+(defun om-getEndAttr (dev))
+
+\end{chunk}
+
+\defun{om-getEndBind}{om-getEndBind}
+Reads an end binder token from dev.
+\begin{chunk}{defun om-getEndBind}
+(defun om-getEndBind (dev))
+
+\end{chunk}
+
+\defun{om-getEndBVar}{om-getEndBVar}
+Reads an end bound variable list token from dev.
+\begin{chunk}{defun om-getEndBVar}
+(defun om-getEndBVar (dev))
+
+\end{chunk}
+
+\defun{om-getEndError}{om-getEndError}
+Reads an end error token from dev.
+\begin{chunk}{defun om-getEndError}
+(defun om-getEndError (dev))
+
+\end{chunk}
+
+\defun{om-getEndObject}{om-getEndObject}
+Reads an end object token from dev.
+\begin{chunk}{defun om-getEndObject}
+(defun om-getEndObject (dev))
+
+\end{chunk}
+
+\defun{om-getError}{om-getError}
+Reads a begin error token from dev.
+\begin{chunk}{defun om-getError}
+(defun om-getError (dev))
+
+\end{chunk}
+
+\defun{om-getFloat}{om-getFloat}
+Reads a float from dev.
+\begin{chunk}{defun om-getFloat}
+(defun om-getFloat (dev))
+
+\end{chunk}
+
+\defun{om-getInt}{om-getInt}
+Reads an integer from dev.
+\begin{chunk}{defun om-getInt}
+(defun om-getInt (dev))
+
+\end{chunk}
+
+\defun{om-getObject}{om-getObject}
+Reads a begin object token from dev.
+\begin{chunk}{defun om-getObject}
+(defun om-getObject (dev))
+
+\end{chunk}
+
+\defun{om-getString}{om-getString}
+Reads a string from dev.
+\begin{chunk}{defun om-getString}
+(defun om-getString (dev))
+
+\end{chunk}
+
+\defun{om-getSymbol}{om-getSymbol}
+Reads a symbol from dev.
+\begin{chunk}{defun om-getSymbol}
+(defun om-getSymbol (dev))
+
+\end{chunk}
+
+\defun{om-getType}{om-getType}
+Returns the type of the next object on dev.
+\begin{chunk}{defun om-getType}
+(defun om-getType (dev))
+
+\end{chunk}
+
+\defun{om-getVar}{om-getVar}
+Reads a variable from dev.
+\begin{chunk}{defun om-getVar}
+(defun om-getVar (dev))
+
+\end{chunk}
+
+\defun{om-putApp}{om-putApp}
+Writes a begin application token to dev.
+\begin{chunk}{defun om-putApp}
+(defun om-putApp (dev))
+\end{chunk}
+
+\defun{om-putAtp}{om-putAtp}
+This writea a begin application pair token to dev.
+\begin{chunk}{defun om-putAtp}
+(defun om-putAtp (dev))
+
+\end{chunk}
+
+\defun{om-putAttr}{om-putAttr}
+This writes a begin attribute token to dev.
+\begin{chunk}{defun om-putAttr}
+(defun om-putAttr (dev))
+
+\end{chunk}
+
+\defun{om-putBind}{om-putBind}
+This writes a begin binder token to dev.
+\begin{chunk}{defun om-putBind}
+(defun om-putBind (dev))
+
+\end{chunk}
+
+\defun{om-putBVar}{om-putBVar}
+This writes a begin bound variable list token to dev.
+\begin{chunk}{defun om-putBVar}
+(defun om-putBVar (dev))
+
+\end{chunk}
+
+\defun{om-putByteArray}{om-putByteArray}
+This writes a byte array to dev.
+\begin{chunk}{defun om-putByteArray}
+(defun om-putByteArray (dev b))
+
+\end{chunk}
+
+\defun{om-putEndApp}{om-putEndApp}
+This writes an end application token to dev.
+\begin{chunk}{defun om-putEndApp}
+(defun om-putEndApp (dev))
+
+\end{chunk}
+
+\defun{om-putEndAtp}{om-putEndAtp}
+This writes an end attribute pair to dev.
+\begin{chunk}{defun om-putEndAtp}
+(defun om-putEndAtp (dev))
+
+\end{chunk}
+
+\defun{om-putEndAttr}{om-putEndAttr}
+This writes an end attribute token to dev.
+\begin{chunk}{defun om-putEndAttr}
+(defun om-putEndAttr (dev))
+
+\end{chunk}
+
+\defun{om-putEndBind}{om-putEndBind}
+This writes an end binder token to dev.
+\begin{chunk}{defun om-putEndBind}
+(defun om-putEndBind (dev))
+
+\end{chunk}
+
+\defun{om-putEndBVar}{om-putEndBVar}
+This writes and end bound variable list token to dev
+\begin{chunk}{defun om-putEndBVar}
+(defun om-putEndBVar (dev))
+
+\end{chunk}
+
+\defun{om-putEndError}{om-putEndError}
+This writes an end error token to dev
+\begin{chunk}{defun om-putEndError}
+(defun om-putEndError (dev))
+
+\end{chunk}
+
+\defun{om-putEndObject}{om-putEndObject}
+This writes an end object token to dev.
+\begin{chunk}{defun om-putEndObject}
+(defun om-putEndObject (dev))
+
+\end{chunk}
+
+\defun{om-putError}{om-putError}
+This writes a begin error token to dev.
+\begin{chunk}{defun om-putError}
+(defun om-putError (dev))
+
+\end{chunk}
+
+\defun{om-putFloat}{om-putFloat}
+This writes the float f to dev.
+\begin{chunk}{defun om-putFloat}
+(defun om-putFloat (dev f))
+
+\end{chunk}
+
+\defun{om-putInt}{om-putInt}
+This writes the integer i to dev
+\begin{chunk}{defun om-putInt}
+(defun om-putInt (dev i))
+
+\end{chunk}
+
+\defun{om-putObject}{om-putObject}
+This writes a begin object token to dev.
+\begin{chunk}{defun om-putObject}
+(defun om-putObject (dev))
+
+\end{chunk}
+
+\defun{om-putString}{om-putString}
+This writes the string s to dev.
+\begin{chunk}{defun om-putString}
+(defun om-putString (dev s))
+
+\end{chunk}
+
+\defun{om-putSymbol}{om-putSymbol}
+This writes the symbol nm using semantics from cd to dev.
+\begin{chunk}{defun om-putSymbol}
+(defun om-putSymbol (dev cd nm))
+
+\end{chunk}
+
+\defun{om-putVar}{om-putVar}
+This writes the variable v to dev.
+\begin{chunk}{defun om-putVar}
+(defun om-putVar (dev v))
+
+\end{chunk}
+
+\defun{om-stringToStringPtr}{om-stringToStringPtr}
+This is used in the SingleInteger domain in Volume 10.3.
+This is supposed to return the string from its address?
+It would appear to be a nop in lisp.
+\begin{chunk}{defun om-stringToStringPtr}
+(defun om-stringToStringPtr (str))
+
+\end{chunk}
+
+\defun{om-stringPtrToString}{om-stringPtrToString}
+This is used in the SingleInteger domain in Volume 10.3.
+This is supposed to return the string address from a string?
+It would appear to be a nop in lisp.
+\begin{chunk}{defun om-stringPtrToString}
+(defun om-stringPtrToString (str))
+
+\end{chunk}
+
 \chapter{NRLIB code.lisp support code}
 
 \defun{makeByteWordVec2}{makeByteWordVec2}
@@ -41590,6 +42039,63 @@ This needs to work off the internal exposure list, not the file.
 
 \getchunk{defun oldCompLookup}
 \getchunk{defun oldHistFileName}
+\getchunk{defun om-bindTCP}
+\getchunk{defun om-closeConn}
+\getchunk{defun om-closeDev}
+\getchunk{defun om-connectTCP}
+\getchunk{defun om-getApp}
+\getchunk{defun om-getAtp}
+\getchunk{defun om-getAttr}
+\getchunk{defun om-getBind}
+\getchunk{defun om-getBVar}
+\getchunk{defun om-getConnInDev}
+\getchunk{defun om-getConnOutDev}
+\getchunk{defun om-getEndApp}
+\getchunk{defun om-getEndAtp}
+\getchunk{defun om-getEndAttr}
+\getchunk{defun om-getEndBind}
+\getchunk{defun om-getEndBVar}
+\getchunk{defun om-getEndError}
+\getchunk{defun om-getEndObject}
+\getchunk{defun om-getError}
+\getchunk{defun om-getFloat}
+\getchunk{defun om-getInt}
+\getchunk{defun om-getObject}
+\getchunk{defun om-getString}
+\getchunk{defun om-getSymbol}
+\getchunk{defun om-getType}
+\getchunk{defun om-getVar}
+\getchunk{defun om-listCDs}
+\getchunk{defun om-listSymbols}
+\getchunk{defun om-makeConn}
+\getchunk{defun om-openFileDev}
+\getchunk{defun om-openStringDev}
+\getchunk{defun om-putApp}
+\getchunk{defun om-putAtp}
+\getchunk{defun om-putAttr}
+\getchunk{defun om-putBind}
+\getchunk{defun om-putBVar}
+\getchunk{defun om-putByteArray}
+\getchunk{defun om-putEndApp}
+\getchunk{defun om-putEndAtp}
+\getchunk{defun om-putEndAttr}
+\getchunk{defun om-putEndBind}
+\getchunk{defun om-putEndBVar}
+\getchunk{defun om-putEndError}
+\getchunk{defun om-putEndObject}
+\getchunk{defun om-putError}
+\getchunk{defun om-putFloat}
+\getchunk{defun om-putInt}
+\getchunk{defun om-putObject}
+\getchunk{defun om-putString}
+\getchunk{defun om-putSymbol}
+\getchunk{defun om-putVar}
+\getchunk{defun om-Read}
+\getchunk{defun om-setDevEncoding}
+\getchunk{defun om-stringPtrToString}
+\getchunk{defun om-stringToStringPtr}
+\getchunk{defun om-supportsCD}
+\getchunk{defun om-supportsSymbol}
 \getchunk{defun openOutputLibrary}
 \getchunk{defun openserver}
 \getchunk{defun operationOpen}
diff --git a/changelog b/changelog
index 2775e1c..acc0d84 100644
--- a/changelog
+++ b/changelog
@@ -1,3 +1,5 @@
+20111106 tpd src/axiom-website/patches.html 20111106.02.tpd.patch
+20111106 tpd books/bookvol5 add OpenMath stubs
 20111106 tpd src/axiom-website/patches.html 20111106.01.tpd.patch
 20111106 tpd src/interp/vmlisp.lisp missing/unused function cleanup
 20111106 tpd src/interp/sys-pkg.lisp missing/unused function cleanup
diff --git a/src/axiom-website/patches.html b/src/axiom-website/patches.html
index c7714a9..d31898f 100644
--- a/src/axiom-website/patches.html
+++ b/src/axiom-website/patches.html
@@ -3664,5 +3664,7 @@ books/bookvol9 treeshake compiler<br/>
 src/interp/vmlisp.lisp remove makeprop<br/>
 <a href="patches/20111106.01.tpd.patch">20111106.01.tpd.patch</a>
 src/interp/vmlisp.lisp missing/unused function cleanup<br/>
+<a href="patches/20111106.02.tpd.patch">20111106.02.tpd.patch</a>
+books/bookvol5 add OpenMath stubs<br/>
  </body>
 </html>