diff --git a/Doc/lib/libmd5.tex b/Doc/lib/libmd5.tex
index 946d00d..d1e7367 100644
--- a/Doc/lib/libmd5.tex
+++ b/Doc/lib/libmd5.tex
@@ -1,18 +1,20 @@
-\section{Built-in Module \sectcode{md5}}
+\section{Built-in Module \module{md5}}
 \label{module-md5}
 \bimodindex{md5}
 
 This module implements the interface to RSA's MD5 message digest
+\index{message digest, MD5}
 algorithm (see also Internet \rfc{1321}).  Its use is quite
-straightforward:\ use the \code{md5.new()} to create an md5 object.
+straightforward:\ use the \function{new()} to create an md5 object.
 You can now feed this object with arbitrary strings using the
-\code{update()} method, and at any point you can ask it for the
+\method{update()} method, and at any point you can ask it for the
 \dfn{digest} (a strong kind of 128-bit checksum,
 a.k.a. ``fingerprint'') of the contatenation of the strings fed to it
-so far using the \code{digest()} method.
+so far using the \method{digest()} method.
+\index{checksum!MD5}
 
-For example, to obtain the digest of the string {\tt"Nobody inspects
-the spammish repetition"}:
+For example, to obtain the digest of the string \code{'Nobody inspects
+the spammish repetition'}:
 
 \begin{verbatim}
 >>> import md5
@@ -22,15 +24,13 @@
 >>> m.digest()
 '\273d\234\203\335\036\245\311\331\336\311\241\215\360\377\351'
 \end{verbatim}
-%
+
 More condensed:
 
 \begin{verbatim}
 >>> md5.new("Nobody inspects the spammish repetition").digest()
 '\273d\234\203\335\036\245\311\331\336\311\241\215\360\377\351'
 \end{verbatim}
-%
-\setindexsubitem{(in module md5)}
 
 \begin{funcdesc}{new}{\optional{arg}}
 Return a new md5 object.  If \var{arg} is present, the method call
@@ -39,27 +39,26 @@
 
 \begin{funcdesc}{md5}{\optional{arg}}
 For backward compatibility reasons, this is an alternative name for the
-\code{new()} function.
+\function{new()} function.
 \end{funcdesc}
 
 An md5 object has the following methods:
 
-\setindexsubitem{(md5 method)}
-\begin{funcdesc}{update}{arg}
+\begin{methoddesc}[md5]{update}{arg}
 Update the md5 object with the string \var{arg}.  Repeated calls are
 equivalent to a single call with the concatenation of all the
 arguments, i.e.\ \code{m.update(a); m.update(b)} is equivalent to
 \code{m.update(a+b)}.
-\end{funcdesc}
+\end{methoddesc}
 
-\begin{funcdesc}{digest}{}
-Return the digest of the strings passed to the \code{update()}
+\begin{methoddesc}[md5]{digest}{}
+Return the digest of the strings passed to the \method{update()}
 method so far.  This is an 16-byte string which may contain
 non-\ASCII{} characters, including null bytes.
-\end{funcdesc}
+\end{methoddesc}
 
-\begin{funcdesc}{copy}{}
+\begin{methoddesc}[md5]{copy}{}
 Return a copy (``clone'') of the md5 object.  This can be used to
 efficiently compute the digests of strings that share a common initial
 substring.
-\end{funcdesc}
+\end{methoddesc}
diff --git a/Doc/libmd5.tex b/Doc/libmd5.tex
index 946d00d..d1e7367 100644
--- a/Doc/libmd5.tex
+++ b/Doc/libmd5.tex
@@ -1,18 +1,20 @@
-\section{Built-in Module \sectcode{md5}}
+\section{Built-in Module \module{md5}}
 \label{module-md5}
 \bimodindex{md5}
 
 This module implements the interface to RSA's MD5 message digest
+\index{message digest, MD5}
 algorithm (see also Internet \rfc{1321}).  Its use is quite
-straightforward:\ use the \code{md5.new()} to create an md5 object.
+straightforward:\ use the \function{new()} to create an md5 object.
 You can now feed this object with arbitrary strings using the
-\code{update()} method, and at any point you can ask it for the
+\method{update()} method, and at any point you can ask it for the
 \dfn{digest} (a strong kind of 128-bit checksum,
 a.k.a. ``fingerprint'') of the contatenation of the strings fed to it
-so far using the \code{digest()} method.
+so far using the \method{digest()} method.
+\index{checksum!MD5}
 
-For example, to obtain the digest of the string {\tt"Nobody inspects
-the spammish repetition"}:
+For example, to obtain the digest of the string \code{'Nobody inspects
+the spammish repetition'}:
 
 \begin{verbatim}
 >>> import md5
@@ -22,15 +24,13 @@
 >>> m.digest()
 '\273d\234\203\335\036\245\311\331\336\311\241\215\360\377\351'
 \end{verbatim}
-%
+
 More condensed:
 
 \begin{verbatim}
 >>> md5.new("Nobody inspects the spammish repetition").digest()
 '\273d\234\203\335\036\245\311\331\336\311\241\215\360\377\351'
 \end{verbatim}
-%
-\setindexsubitem{(in module md5)}
 
 \begin{funcdesc}{new}{\optional{arg}}
 Return a new md5 object.  If \var{arg} is present, the method call
@@ -39,27 +39,26 @@
 
 \begin{funcdesc}{md5}{\optional{arg}}
 For backward compatibility reasons, this is an alternative name for the
-\code{new()} function.
+\function{new()} function.
 \end{funcdesc}
 
 An md5 object has the following methods:
 
-\setindexsubitem{(md5 method)}
-\begin{funcdesc}{update}{arg}
+\begin{methoddesc}[md5]{update}{arg}
 Update the md5 object with the string \var{arg}.  Repeated calls are
 equivalent to a single call with the concatenation of all the
 arguments, i.e.\ \code{m.update(a); m.update(b)} is equivalent to
 \code{m.update(a+b)}.
-\end{funcdesc}
+\end{methoddesc}
 
-\begin{funcdesc}{digest}{}
-Return the digest of the strings passed to the \code{update()}
+\begin{methoddesc}[md5]{digest}{}
+Return the digest of the strings passed to the \method{update()}
 method so far.  This is an 16-byte string which may contain
 non-\ASCII{} characters, including null bytes.
-\end{funcdesc}
+\end{methoddesc}
 
-\begin{funcdesc}{copy}{}
+\begin{methoddesc}[md5]{copy}{}
 Return a copy (``clone'') of the md5 object.  This can be used to
 efficiently compute the digests of strings that share a common initial
 substring.
-\end{funcdesc}
+\end{methoddesc}
