diff --git a/docs/ReleaseNotes.html b/docs/ReleaseNotes.html
index d75a6f3..16066c2 100644
--- a/docs/ReleaseNotes.html
+++ b/docs/ReleaseNotes.html
@@ -73,7 +73,7 @@
 
 <p>This is the fifth public release of the LLVM compiler infrastructure.</p>
 
-<p> At this time, LLVM is known to correctly compile and a broad range of
+<p> At this time, LLVM is known to correctly compile on a broad range of
 C and C++ programs, including the SPEC CPU95 &amp; 2000 suite.  This release
 includes several major enhancements to the LLVM system, including a new 
 PowerPC JIT, enhancements to the C/C++ front-end to provide source line number
@@ -97,8 +97,9 @@
 <ol>
   <li>LLVM now includes a Just-In-Time compiler for the PowerPC target.</li>
   <li>llvmgcc and llvmg++ now emit source line number information when '-g' is
-  passed in.  This information can be used with llvm-db or other tools and 
-  passes.</li>
+  passed in, making it possible to map from LLVM code back to source.
+  This information is currently used by llvm-db and can be used with other 
+  tools and passes.</li>
   <li>The test/Programs hierarchy <a href="http://llvm.cs.uiuc.edu/PR257">has
     been moved out of the main LLVM tree</a> into a separate CVS repository and
     tarball. This shrinks the distribution size of LLVM itself significantly.
@@ -128,8 +129,8 @@
   <li>The <a href="http://llvm.cs.uiuc.edu/PR263">dependent libraries</a> 
   feature has been implemented. This allows front end compilers to indicate in
   the bytecode which libraries the bytecode needs to be linked with. Both the
-  C/C++ front end and Stacker support generating the required libraries. The 
-  linker now supports using this information to ensure required libaries are
+  C/C++ and Stacker front ends support generating the required dependencies. 
+  The linker now supports using this information to ensure required libaries are
   linked into the module. This minimizes the need to use the <tt>-l</tt> option
   when using <a href="CommandGuide/html/llvmc.html"><tt>llvmc</tt></a>
   </li>
@@ -154,10 +155,7 @@
   <li>The LLVM code generator now automatically generates assembly code writers
       from an abstract target descriptions, eliminating the need to write
       assembly printers manually.</li>
-  <li>LLVM regression and feature tests can now be run with DejaGNU.</li>
-  <li>llvmgcc and llvmg++ now emit source-level line number information, making
-      it possible to map from LLVM code back to source.  This is currently used
-      by llvm-db.</li>
+  <li>LLVM regression and feature tests now use DejaGNU instead of QMTest.</li>
 </ol>
 
 </div>
@@ -195,11 +193,11 @@
 
 <ol>
   <li>The linker no longer <a href="http://llvm.cs.uiuc.edu/PR426">emits many
-      useless warnings</a> when linking C++ programs.</a>
+      useless warnings</a> when linking C++ programs.
   </li>
   <li>The LLVM <a href="http://llvm.cs.uiuc.edu/PR352">#include namespace</a>
       has been made consistent.  Files in <tt>llvm/include/{Support,Config}</tt>
-      are now located in <tt>llvm/include/llvm/{Support,Config}</tt>.</a>
+      are now located in <tt>llvm/include/llvm/{Support,Config}</tt>.
   </li>
   <li>The names of the libraries generated by compiling LLVM source have been 
   changed to ensure they do not conflict with other packages upon installation.
@@ -565,7 +563,7 @@
 
 <div class="doc_text">
 
-<p>For this release, the C++ front-end is considered to be fully.  It has been
+<p>For this release, the C++ front-end is considered to be fully
 tested and works for a number of non-trivial programs, including LLVM
 itself.</p>
 
