diff --git a/docs/TableGenFundamentals.html b/docs/TableGenFundamentals.html
index 89509c6..ca327ce 100644
--- a/docs/TableGenFundamentals.html
+++ b/docs/TableGenFundamentals.html
@@ -310,8 +310,8 @@
 <li><tt>value{15-17}</tt> - access to multiple bits of a value</li>
 <li><tt>DEF</tt> - reference to a record definition</li>
 <li><tt>X.Y</tt> - reference to the subfield of a value</li>
-<li>list[4-7,17,2-3] - A slice of the 'list' list, including elements 
-     4,5,6,7,17,2, and 3 from it.  Elements may be included multiple times.</li>
+<li><tt>list[4-7,17,2-3]</tt> - A slice of the 'list' list, including elements 
+4,5,6,7,17,2, and 3 from it.  Elements may be included multiple times.</li>
 <li><tt>(DEF a, b)</tt> - a dag value.  The first element is required to be a
 record definition, the remaining elements in the list may be arbitrary other
 values, including nested `<tt>dag</tt>' values.</li>
