diff --git a/v2/util/assert.jam b/v2/util/assert.jam
index 3fa52dfe2..a4577f6f9 100644
--- a/v2/util/assert.jam
+++ b/v2/util/assert.jam
@@ -7,7 +7,9 @@
 import errors : error-skip-frames lol->list ;
 import modules ;
 
-# assert the equality of A and B 
+
+# Assert the equality of A and B 
+#
 rule equal ( a * : b * )
 {
     if $(a) != $(b)
@@ -16,8 +18,10 @@ rule equal ( a * : b * )
     }
 }
 
-# assert that EXPECTED is the result of calling RULE-NAME with the
-# given arguments
+
+# Assert that EXPECTED is the result of calling RULE-NAME with the given
+# arguments.
+#
 rule result ( expected * : rule-name args * : * )
 {
     local result ;
@@ -37,6 +41,7 @@ rule result ( expected * : rule-name args * : * )
     }
 }
 
+
 rule .set.equal ( set1 * : set2 * )
 {
     if ( $(set1) in $(set2) ) && ( $(set2) in $(set1) )
@@ -45,8 +50,10 @@ rule .set.equal ( set1 * : set2 * )
     }
 }
 
-# assert that EXPECTED is equal to the result of calling RULE-NAME with the
-# given arguments
+
+# Assert that EXPECTED is equal to the result of calling RULE-NAME with the
+# given arguments.
+#
 rule result-equal ( expected * : rule-name args * : * )
 {
     local result ;
@@ -66,7 +73,9 @@ rule result-equal ( expected * : rule-name args * : * )
     }
 }
 
-# assert that the given variable is nonempty.
+
+# Assert that the given variable is nonempty.
+#
 rule nonempty-variable ( name )
 {
     local value = [ modules.peek [ CALLER_MODULE ] : $(name) ] ;
@@ -77,9 +86,10 @@ rule nonempty-variable ( name )
     }
 }
 
-# assert that the result of calling RULE-NAME on the given arguments
-# has a true logical value (is neither an empty list nor all empty
-# strings).
+
+# Assert that the result of calling RULE-NAME on the given arguments has a true
+# logical value (is neither an empty list nor all empty strings).
+#
 rule true ( rule-name args * : * )
 {
     local result ;
@@ -99,29 +109,31 @@ rule true ( rule-name args * : * )
     }
 }
 
-# assert that the result of calling RULE-NAME on the given arguments
-# has a false logical value (is either an empty list or all empty
-# strings).
+
+# Assert that the result of calling RULE-NAME on the given arguments has a false
+# logical value (is either an empty list or all empty strings).
+#
 rule false ( rule-name args * : * )
 {
     local result ;
     module [ CALLER_MODULE ]
     {
-        modules.poke assert : result
-          : [ $(1) : $(2) : $(3) : $(4)
-            : $(5) : $(6) : $(7) : $(8) : $(9) ] ;
+        modules.poke assert : result : [ $(1) : $(2) : $(3) : $(4) : $(5) : $(6)
+            : $(7) : $(8) : $(9) ] ;
     }
 
     if $(result)
     {
         error-skip-frames 3 assertion failure: expecting false result from
-          "[" $(rule-name) 
-          [ lol->list $(args) : $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ]
-            "]" : got [ lol->list $(result) ] instead  ;
+            "[" $(rule-name) [ lol->list $(args) : $(2) : $(3) : $(4) : $(5) :
+            $(6) : $(7) : $(8) : $(9) ] "]" : got [ lol->list $(result) ]
+            instead ;
     }
 }
 
-# assert that 'element' is present in 'list'.
+
+# Assert that 'element' is present in 'list'.
+#
 rule "in" ( element : list * )
 {
     if ! $(element) in $(list)
@@ -131,7 +143,9 @@ rule "in" ( element : list * )
     }
 }
 
-# assert that 'element' is not present in 'list'.
+
+# Assert that 'element' is not present in 'list'.
+#
 rule not-in ( element : list * )
 {
     if $(element) in $(list)
diff --git a/v2/util/numbers.jam b/v2/util/numbers.jam
index 1d3d68692..7bb2c58f0 100644
--- a/v2/util/numbers.jam
+++ b/v2/util/numbers.jam
@@ -1,7 +1,10 @@
-# Copyright 2001, 2002 Dave Abrahams 
-# Copyright 2002, 2003 Vladimir Prus 
-# Distributed under the Boost Software License, Version 1.0. 
-# (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt) 
+# Copyright 2001, 2002 Dave Abrahams
+# Copyright 2002, 2003 Vladimir Prus
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+
+import errors ;
+
 
 digits = 0 1 2 3 4 5 6 7 8 9 ;
 powers = 1 ;
@@ -10,9 +13,8 @@ natural = $(digits) ;
 positive = $(digits[2-]) ;
 incr = $(positive[2-]) ;
 znatural = $(digits) ;
-zero-test = is zero ; # if $(zero-test[$(n)]) == "is" "zero", n == 0
+zero-test = is zero ;  # if $(zero-test[$(n)]) == "is" "zero", n == 0
 
-import errors : * ;
 
 local rule extend ( )
 {
@@ -23,6 +25,7 @@ local rule extend ( )
     znatural = $(digits)$(znatural) ;
 }
 
+
 rule check ( numbers * )
 {
     for local n in $(numbers)
@@ -30,23 +33,24 @@ rule check ( numbers * )
         switch $(n)
         {
             case *[^0-9]* :
-              error $(n) "in" $(numbers) : is not a number ;
+                errors.error $(n) "in" $(numbers) : is not a number ;
         }
     }
 }
 
+
 rule increment ( number )
 {
     return [ CALC $(number) + 1 ] ;
 }
 
+
 rule decrement ( number )
 {
-    # Previous rule did not allow decrementing zero. 
-    # Is that what we want?
     return [ CALC $(number) - 1 ] ;
 }
 
+
 rule range ( start finish ? : step ? )
 {
     if ! $(finish)
@@ -55,7 +59,7 @@ rule range ( start finish ? : step ? )
         start = 1 ;
     }
     step ?= 1 ;
-    
+
     check $(start) $(finish) $(step) ;
 
     if $(finish) != 0
@@ -64,7 +68,7 @@ rule range ( start finish ? : step ? )
         {
             extend ;
         }
-        
+
         if $(step) = 1
         {
             return $(positive[$(start)-$(finish)]) ;
@@ -84,26 +88,28 @@ rule range ( start finish ? : step ? )
     }
 }
 
+
 rule less ( n1 n2 )
 {
     check $(n1) $(n2) ;
-    # avoid messy 0 case by appending 1
+    # Avoid messy 0 case by appending 1.
     local l1 = [ range 2 [ log10 $(n1)1 ] ] ;
     local l2 = [ range 2 [ log10 $(n2)1 ] ] ;
-    
-    # number of digits mismatch?
+
+    # Number of digits mismatch?
     if ( $(l1) < $(l2) ) || ( ( $(l1) = $(l2) ) && $(n1) < $(n2) )
     {
         return true ;
     }
 }
 
+
 rule log10 ( number )
 {
     switch $(number)
     {
-        case *[^0-9]* : error $(number) is not a number ;
-        case 0 : error can't take log of zero ;
+        case *[^0-9]* : errors.error $(number) is not a number ;
+        case 0 : errors.error can't take log of zero ;
         case [1-9] : return 0 ;
         case [1-9]? : return 1 ;
         case [1-9]?? : return 2 ;
@@ -123,10 +129,10 @@ rule log10 ( number )
             {
                 chars = $(chars[2-]) ;
             }
-            
+
             if ! $(chars)
             {
-                error can't take log of zero ;
+                errors.error can't take log of zero ;
             }
             else
             {
@@ -136,10 +142,11 @@ rule log10 ( number )
     }
 }
 
+
 rule __test__ ( )
 {
     import assert ;
-    
+
     assert.result 1 : increment 0 ;
     assert.result 2 : increment 1 ;
     assert.result 1 : decrement 2 ;
@@ -149,10 +156,9 @@ rule __test__ ( )
     assert.result 99 : increment 98 ;
     assert.result 99 : decrement 100 ;
     assert.result 100 : increment 99 ;
-    # This just makes debugging output too large
-    # assert.result 1000 : increment 999 ;
-    # assert.result 999 : decrement 1000 ;
-    
+    assert.result 999 : decrement 1000 ;
+    assert.result 1000 : increment 999 ;
+
     assert.result 1 2 3 : range 3 ;
     assert.result 1 2 3 4 5 6 7 8 9 10 11 12 : range 12 ;
     assert.result 3 4 5 6 7 8 9 10 11 : range 3 11 ;
@@ -160,40 +166,43 @@ rule __test__ ( )
     assert.result 1 4 7 10 : range 10 : 3 ;
     assert.result 2 4 6 8 10 : range 2 10 : 2 ;
     assert.result 25 50 75 100 : range 25 100 : 25 ;
-    
+
     assert.true less 1 2 ;
     assert.true less 1 12 ;
+    assert.true less 005 217 ;
+    assert.true less 0005 217 ;
+    assert.true less 5 00217 ;
     assert.true less 1 21 ;
     assert.false less 0 0 ;
-      
-    # TEMPORARY disabled, because nested "try"/"catch" do not work, I don't the
-    # time to fix that right now.
-    if $(0) 
-    {        
+
+    # TEMPORARY disabled, because nested "try"/"catch" do not work and I do no
+    # have the time to fix that right now.
+    if $(0)
+    {
     try ;
     {
         decrement 0 ;
     }
     catch can't decrement zero! ;
-    
+
     try ;
     {
         check foo ;
     }
     catch : not a number ;
-    
+
     try ;
     {
         increment foo ;
     }
     catch : not a number ;
-        
+
     try ;
     {
         log10 0 ;
     }
     catch can't take log of zero ;
-    
+
     try ;
     {
         log10 000 ;
@@ -201,14 +210,14 @@ rule __test__ ( )
     catch can't take log of zero ;
 
     }
-        
+
     assert.result 0 : log10 1 ;
     assert.result 0 : log10 9 ;
     assert.result 1 : log10 10 ;
     assert.result 1 : log10 99 ;
     assert.result 2 : log10 125 ;
     assert.result 11 : log10 12345678901 ;
-    
+
     for local x in [ range 75 110 : 5 ]
     {
         for local y in [ range $(x) 111 : 3 ]
@@ -219,7 +228,7 @@ rule __test__ ( )
             }
         }
     }
-    
+
     for local x in [ range 90 110 : 2 ]
     {
         for local y in [ range 80 $(x) : 4 ]
diff --git a/v2/util/sequence.jam b/v2/util/sequence.jam
index 8cbd1e8fb..0882b9cbf 100644
--- a/v2/util/sequence.jam
+++ b/v2/util/sequence.jam
@@ -8,15 +8,17 @@ import assert ;
 import numbers ; 
 import modules ;
 
-# Note that algorithms in this module execute largely in the caller's
-# module namespace, so that local rules can be used as function
-# objects. Also note that most predicates can be multi-element
-# lists. In that case, all but the first element are prepended to the
-# first argument which is passed to the rule named by the first
-# element.
 
-# Return the elements e of $(sequence) for which [ $(predicate) e ]
-# has a non-null value.
+# Note that algorithms in this module execute largely in the caller's module
+# namespace, so that local rules can be used as function objects. Also note that
+# most predicates can be multi-element lists. In that case, all but the first
+# element are prepended to the first argument which is passed to the rule named
+# by the first element.
+
+
+# Return the elements e of $(sequence) for which [ $(predicate) e ] has a
+# non-null value.
+#
 rule filter ( predicate + : sequence * )
 {
     local caller = [ CALLER_MODULE ] ;
@@ -32,8 +34,10 @@ rule filter ( predicate + : sequence * )
     return $(result) ;
 }
 
-# return a new sequence consisting of [ $(function) $(e) ] for each
-# element e of $(sequence).
+
+# Return a new sequence consisting of [ $(function) $(e) ] for each element e of
+# $(sequence).
+#
 rule transform ( function + : sequence * )
 {
     local caller = [ CALLER_MODULE ] ;
@@ -46,6 +50,7 @@ rule transform ( function + : sequence * )
     return $(result) ;
 }
 
+
 rule reverse ( s * )
 {
     local r ;
@@ -65,7 +70,9 @@ rule less ( a b )
     }
 }
 
-# insertion-sort s using the BinaryPredicate ordered.
+
+# Insertion-sort s using the BinaryPredicate ordered.
+#
 rule insertion-sort ( s * : ordered * )
 {
     if ! $(ordered)
@@ -111,14 +118,17 @@ rule insertion-sort ( s * : ordered * )
     }    
 }
 
-# merge two ordered sequences using the BinaryPredicate ordered.
+
+# Merge two ordered sequences using the BinaryPredicate ordered.
+#
 rule merge ( s1 * : s2 * : ordered * )
 {
     ordered ?= sequence.less ;
     local result__ ;
     local caller = [ CALLER_MODULE ] ;
 
-    while $(s1) && $(s2) {
+    while $(s1) && $(s2)
+    {
         if [ modules.call-in $(caller) : $(ordered) $(s1[1]) $(s2[1]) ]
         {
             result__ += $(s1[1]) ;
@@ -141,15 +151,19 @@ rule merge ( s1 * : s2 * : ordered * )
     return $(result__) ;
 }
 
-# join the elements of s into one long string. If joint is supplied,
-# it is used as a separator.
+
+# Join the elements of s into one long string. If joint is supplied, it is used
+# as a separator.
+#
 rule join ( s * : joint ? )
 {
     joint ?= "" ;
     return $(s:J=$(joint)) ;
 }
 
+
 # Find the length of any sequence.
+#
 rule length ( s * )
 {
     local result = 0 ;
@@ -160,6 +174,7 @@ rule length ( s * )
     return $(result) ;
 }
 
+
 rule unique ( list * : stable ? )
 {
     local result ;
@@ -188,8 +203,10 @@ rule unique ( list * : stable ? )
     return $(result) ;
 }
 
-# Returns the maximum number in 'elements'. Uses 'ordered' for comparisons,
-# or 'numbers.less' is none is provided.
+
+# Returns the maximum number in 'elements'. Uses 'ordered' for comparisons, or
+# 'numbers.less' is none is provided.
+#
 rule max-element ( elements + : ordered ? )
 {
     ordered ?= numbers.less ;
@@ -205,8 +222,10 @@ rule max-element ( elements + : ordered ? )
     return $(max) ;           
 }
 
-# Returns all of 'elements' for which corresponding element in parallel
-# list 'rank' is equal to the maximum value in 'rank'.
+
+# Returns all of 'elements' for which corresponding element in parallel list
+# 'rank' is equal to the maximum value in 'rank'.
+#
 rule select-highest-ranked ( elements * : ranks * )
 {
     if $(elements)
@@ -230,7 +249,7 @@ NATIVE_RULE sequence : select-highest-ranked ;
 
 local rule __test__ ( )
 {
-    # use a unique module so we can test the use of local rules.
+    # Use a unique module so we can test the use of local rules.
     module sequence.__test__
     {
         import assert ;
@@ -244,10 +263,9 @@ local rule __test__ ( )
             }
         }
 
-        assert.result 4 6 4 2 8
-          : sequence.filter is-even : 1 4 6 3 4 7 2 3 8 ;
+        assert.result 4 6 4 2 8 : sequence.filter is-even : 1 4 6 3 4 7 2 3 8 ;
 
-        # test that argument binding works
+        # Test that argument binding works.
         local rule is-equal-test ( x y )
         {
             if $(x) = $(y)
@@ -302,18 +320,15 @@ local rule __test__ ( )
         local p2 = x ;
         for local i in 1 2 3 4 5 6 7 8
         {
-          p2 = $(p2) $(p2) ;
+            p2 = $(p2) $(p2) ;
         }
         assert.result 256 : sequence.length $(p2) ;
 
-        assert.result 1 2 3 4 5
-          : sequence.unique 1 2 3 2 4 3 3 5 5 5 ;
+        assert.result 1 2 3 4 5 : sequence.unique 1 2 3 2 4 3 3 5 5 5 ;
                 
-        assert.result 5 
-          : sequence.max-element 1 3 5 0 4 ;
+        assert.result 5 : sequence.max-element 1 3 5 0 4 ;
         
-        assert.result e-3 h-3 
-          : sequence.select-highest-ranked e-1 e-3 h-3 m-2 : 1 3 3 2 ;
+        assert.result e-3 h-3 : sequence.select-highest-ranked e-1 e-3 h-3 m-2 : 1 3 3 2 ;
         
         assert.result 7 6 5 4 3 2 1 : sequence.reverse 1 2 3 4 5 6 7 ;
     }