diff --git a/build/Jamfile.v2 b/build/Jamfile.v2
index 19cb65f19..6bf7f5bde 100644
--- a/build/Jamfile.v2
+++ b/build/Jamfile.v2
@@ -21,6 +21,7 @@ lib boost_graph
     # Without these flags, MSVC 7.1 and 8.0 crash
     # User reports that VC++ 8.0 does not fail anymore, so that is removed
     <toolset>msvc-7.1:<cxxflags>-GR-
+    <toolset>sun:<build>no
     :
     :
     ;
diff --git a/doc/AStarHeuristic.html b/doc/AStarHeuristic.html
index 5d0c1aeb3..62257be8b 100644
--- a/doc/AStarHeuristic.html
+++ b/doc/AStarHeuristic.html
@@ -116,7 +116,7 @@ <h3>Concept Checking Class</h3>
   struct AStarHeuristicConcept {
     void constraints()
     {
-      function_requires&lt; CopyConstructibleConcept&lt;Heuristic&gt; &gt;();
+      BOOST_CONCEPT_ASSERT(( CopyConstructibleConcept&lt;Heuristic&gt; ));
       h(u);
     }
     Heuristic h;
diff --git a/doc/AdjacencyGraph.html b/doc/AdjacencyGraph.html
index 0764b29bf..b72031b13 100644
--- a/doc/AdjacencyGraph.html
+++ b/doc/AdjacencyGraph.html
@@ -112,8 +112,8 @@ <H3>Concept Checking Class</H3>
     typedef typename boost::graph_traits&lt;G&gt;::adjacency_iterator
       adjacency_iterator;
     void constraints() {
-      function_requires&lt; IncidenceGraphConcept&lt;G&gt; &gt;();
-      function_requires&lt; MultiPassInputIteratorConcept&lt;adjacency_iterator&gt; &gt;();
+      BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept&lt;G&gt; ));
+      BOOST_CONCEPT_ASSERT(( MultiPassInputIteratorConcept&lt;adjacency_iterator&gt; ));
 
       p = adjacent_vertices(v, g);
       v = *p.first;
diff --git a/doc/BidirectionalGraph.html b/doc/BidirectionalGraph.html
index f67a92a48..e5a922158 100644
--- a/doc/BidirectionalGraph.html
+++ b/doc/BidirectionalGraph.html
@@ -145,8 +145,8 @@ <H3>Concept Checking Class</H3>
     typedef typename boost::graph_traits&lt;G&gt;::in_edge_iterator
       in_edge_iterator;
     void constraints() {
-      function_requires&lt; IncidenceGraphConcept&lt;G&gt; &gt;();
-      function_requires&lt; MultiPassInputIteratorConcept&lt;in_edge_iterator&gt; &gt;();
+      BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept&lt;G&gt; ));
+      BOOST_CONCEPT_ASSERT(( MultiPassInputIteratorConcept&lt;in_edge_iterator&gt; ));
 
       p = in_edges(v, g);
       e = *p.first;
diff --git a/doc/DFSVisitor.html b/doc/DFSVisitor.html
index f81f616fb..a018257b2 100644
--- a/doc/DFSVisitor.html
+++ b/doc/DFSVisitor.html
@@ -150,6 +150,15 @@ <h3>Valid Expressions</h3>
 </tr>
 
 <tr>
+<td>Finish Edge</td> 
+<td><tt>vis.finish_edge(e, g)</tt></td> 
+<td><tt>void</tt></td> 
+<td> 
+This is invoked on each non-tree edge as well as on each tree edge after 
+<tt>finish_vertex</tt> has been called on its target vertex.</td> 
+</tr> 
+ 
+<tr> 
 <td>Finish Vertex</td>
 <td><tt>vis.finish_vertex(u, g)</tt></td>
 <td><tt>void</tt></td>
diff --git a/doc/DijkstraVisitor.html b/doc/DijkstraVisitor.html
index e8c8c6c90..1f25bc84b 100644
--- a/doc/DijkstraVisitor.html
+++ b/doc/DijkstraVisitor.html
@@ -80,7 +80,7 @@ <h3>Notation</h3>
 
 <TR>
 <TD><tt>w</tt></TD>
-<TD>An object of type <tt>DistanceMap</tt>.</TD>
+<TD>An object of type <tt>WeightMap</tt>.</TD>
 </TR>
 
 </table>
diff --git a/doc/EdgeListGraph.html b/doc/EdgeListGraph.html
index cb87cdb06..fc62539c0 100644
--- a/doc/EdgeListGraph.html
+++ b/doc/EdgeListGraph.html
@@ -146,8 +146,8 @@ <H3>Concept Checking Class</H3>
     typedef typename boost::graph_traits&lt;G&gt;::edge_iterator 
       edge_iterator;
     void constraints() {
-      function_requires&lt; GraphConcept&lt;G&gt; &gt;();
-      function_requires&lt; MultiPassInputIteratorConcept&lt;edge_iterator&gt; &gt;();
+      BOOST_CONCEPT_ASSERT(( GraphConcept&lt;G&gt; ));
+      BOOST_CONCEPT_ASSERT(( MultiPassInputIteratorConcept&lt;edge_iterator&gt; ));
 
       p = edges(g);
       E = num_edges(g);
diff --git a/doc/Graph.html b/doc/Graph.html
index 08423b10c..fabae1a49 100644
--- a/doc/Graph.html
+++ b/doc/Graph.html
@@ -121,12 +121,12 @@ <H3>Concept Checking Class</H3>
     typedef typename boost::graph_traits&lt;G&gt;::traversal_category traversal_category;
 
     void constraints() {
-      function_requires&lt; DefaultConstructibleConcept&lt;vertex_descriptor&gt; &gt;();
-      function_requires&lt; EqualityComparableConcept&lt;vertex_descriptor&gt; &gt;();
-      function_requires&lt; AssignableConcept&lt;vertex_descriptor&gt; &gt;();
-      function_requires&lt; DefaultConstructibleConcept&lt;edge_descriptor&gt; &gt;();
-      function_requires&lt; EqualityComparableConcept&lt;edge_descriptor&gt; &gt;();
-      function_requires&lt; AssignableConcept&lt;edge_descriptor&gt; &gt;();
+      BOOST_CONCEPT_ASSERT(( DefaultConstructibleConcept&lt;vertex_descriptor&gt; ));
+      BOOST_CONCEPT_ASSERT(( EqualityComparableConcept&lt;vertex_descriptor&gt; ));
+      BOOST_CONCEPT_ASSERT(( AssignableConcept&lt;vertex_descriptor&gt; ));
+      BOOST_CONCEPT_ASSERT(( DefaultConstructibleConcept&lt;edge_descriptor&gt; ));
+      BOOST_CONCEPT_ASSERT(( EqualityComparableConcept&lt;edge_descriptor&gt; ));
+      BOOST_CONCEPT_ASSERT(( AssignableConcept&lt;edge_descriptor&gt; ));
     }
     G g;
   };
diff --git a/doc/IncidenceGraph.html b/doc/IncidenceGraph.html
index 29db19460..228cbfc81 100644
--- a/doc/IncidenceGraph.html
+++ b/doc/IncidenceGraph.html
@@ -162,8 +162,8 @@ <H3>Concept Checking Class</H3>
   {
     typedef typename boost::graph_traits&lt;G&gt;::out_edge_iterator out_edge_iterator;
     void constraints() {
-      function_requires&lt; GraphConcept&lt;G&gt; &gt;();
-      function_requires&lt; MultiPassInputIteratorConcept&lt;out_edge_iterator&gt; &gt;();
+      BOOST_CONCEPT_ASSERT(( GraphConcept&lt;G&gt; ));
+      BOOST_CONCEPT_ASSERT(( MultiPassInputIteratorConcept&lt;out_edge_iterator&gt; ));
 
       p = out_edges(u, g);
       e = *p.first;
diff --git a/doc/KeyedUpdatableQueue.html b/doc/KeyedUpdatableQueue.html
index 6d5ecaf0b..81141a728 100644
--- a/doc/KeyedUpdatableQueue.html
+++ b/doc/KeyedUpdatableQueue.html
@@ -63,8 +63,8 @@ <h3>Concept Checking Class</h3>
     typedef typename Q::key_map key_map;
     
     void constraints() {
-      function_requires&lt; UpdatableQueue&lt;Q&gt; &gt;();
-      function_requires&lt; ReadWritePropertyMap&lt; key_map, typename Buffer&lt;Q&gt;::value_type &gt; &gt;();
+      BOOST_CONCEPT_ASSERT(( UpdatableQueue&lt;Q&gt; ));
+      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMap&lt; key_map, typename Buffer&lt;Q&gt;::value_type &gt; ));
     }
     
     void const_constraints(const Q&amp; cq) {
diff --git a/doc/MutableGraph.html b/doc/MutableGraph.html
index edc4e64a0..323ba2e0e 100644
--- a/doc/MutableGraph.html
+++ b/doc/MutableGraph.html
@@ -250,7 +250,7 @@ <H3>Concept Checking Class</H3>
   struct MutableIncidenceGraphConcept
   {
     void constraints() {
-      function_requires&lt; MutableGraph&lt;G&gt; &gt;();
+      BOOST_CONCEPT_ASSERT(( MutableGraph&lt;G&gt; ));
       remove_edge(iter, g);
       remove_out_edge_if(u, p, g);
     }
@@ -265,7 +265,7 @@ <H3>Concept Checking Class</H3>
   struct MutableBidirectionalGraphConcept
   {
     void constraints() {
-      function_requires&lt; MutableIncidenceGraph&lt;G&gt; &gt;();
+      BOOST_CONCEPT_ASSERT(( MutableIncidenceGraph&lt;G&gt; ));
       remove_in_edge_if(u, p, g);
     }
     G g;
@@ -278,7 +278,7 @@ <H3>Concept Checking Class</H3>
   struct MutableEdgeListGraphConcept
   {
     void constraints() {
-      function_requires&lt; MutableGraph&lt;G&gt; &gt;();
+      BOOST_CONCEPT_ASSERT(( MutableGraph&lt;G&gt; ));
       remove_edge_if(p, g);
     }
     G g;
diff --git a/doc/MutablePropertyGraph.html b/doc/MutablePropertyGraph.html
index 8275bbbcd..0a10fff60 100644
--- a/doc/MutablePropertyGraph.html
+++ b/doc/MutablePropertyGraph.html
@@ -125,7 +125,7 @@ <H3>Concept Checking Class</H3>
   {
     typedef typename boost::graph_traits&lt;G&gt;::edge_descriptor edge_descriptor;
     void constraints() {
-      function_requires&lt; MutableGraphConcept&lt;G&gt; &gt;();
+      BOOST_CONCEPT_ASSERT(( MutableGraphConcept&lt;G&gt; ));
       v = add_vertex(vp, g);
       p = add_edge(u, v, ep, g);
     }
diff --git a/doc/PropertyGraph.html b/doc/PropertyGraph.html
index 9d30dc2ed..48c4ad80e 100644
--- a/doc/PropertyGraph.html
+++ b/doc/PropertyGraph.html
@@ -173,9 +173,9 @@ <H3>Concept Checking Class</H3>
     typedef typename property_map&lt;G, PropertyTag&gt;::type Map;
     typedef typename property_map&lt;G, PropertyTag&gt;::const_type const_Map;
     void constraints() {
-      function_requires&lt; GraphConcept&lt;G&gt; &gt;();
-      function_requires&lt; ReadWritePropertyMapConcept&lt;Map, X&gt; &gt;();
-      function_requires&lt; ReadablePropertyMapConcept&lt;const_Map, X&gt; &gt;();
+      BOOST_CONCEPT_ASSERT(( GraphConcept&lt;G&gt; ));
+      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept&lt;Map, X&gt; ));
+      BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept&lt;const_Map, X&gt; ));
 
       Map pmap = get(PropertyTag(), g);
       pval = get(PropertyTag(), g, x);
diff --git a/doc/UpdatableQueue.html b/doc/UpdatableQueue.html
index a91c69cf1..eb65bf756 100644
--- a/doc/UpdatableQueue.html
+++ b/doc/UpdatableQueue.html
@@ -58,7 +58,7 @@ <h3>Concept Checking Class</h3>
   struct UpdatableQueueConcept
   {
     void constraints() {
-      function_requires&lt; Buffer&lt;Q&gt; &gt;();
+      BOOST_CONCEPT_ASSERT(( Buffer&lt;Q&gt; ));
       
       q.update(g_ct);
     }
diff --git a/doc/VertexAndEdgeListGraph.html b/doc/VertexAndEdgeListGraph.html
index 5aabebdad..9685c8f01 100644
--- a/doc/VertexAndEdgeListGraph.html
+++ b/doc/VertexAndEdgeListGraph.html
@@ -51,8 +51,8 @@ <H3>Concept Checking Class</H3>
   struct VertexAndEdgeListGraphConcept
   {
     void constraints() {
-      function_requires&lt; VertexListGraphConcept&lt;G&gt; &gt;();
-      function_requires&lt; EdgeListGraphConcept&lt;G&gt; &gt;();
+      BOOST_CONCEPT_ASSERT(( VertexListGraphConcept&lt;G&gt; ));
+      BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept&lt;G&gt; ));
     }
   };
 </PRE>
diff --git a/doc/VertexListGraph.html b/doc/VertexListGraph.html
index ee546feaf..b108353aa 100644
--- a/doc/VertexListGraph.html
+++ b/doc/VertexListGraph.html
@@ -121,9 +121,9 @@ <H3>Concept Checking Class</H3>
     typedef typename boost::graph_traits&lt;G&gt;::vertex_iterator 
       vertex_iterator;
     void constraints() {
-      function_requires&lt; IncidenceGraphConcept&lt;G&gt; &gt;();
-      function_requires&lt; AdjacencyGraphConcept&lt;G&gt; &gt;();
-      function_requires&lt; MultiPassInputIteratorConcept&lt;vertex_iterator&gt; &gt;();
+      BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept&lt;G&gt; ));
+      BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept&lt;G&gt; ));
+      BOOST_CONCEPT_ASSERT(( MultiPassInputIteratorConcept&lt;vertex_iterator&gt; ));
 
       p = vertices(g);
       V = num_vertices(g);
diff --git a/doc/adjacency_list.html b/doc/adjacency_list.html
index 3e53f9f75..10cc75f13 100644
--- a/doc/adjacency_list.html
+++ b/doc/adjacency_list.html
@@ -214,12 +214,12 @@ <h2>Iterator and Descriptor Stability/Invalidation</h2>
 
   <b>// Attempt to remove all the vertices. Wrong!</b>
   graph_traits&lt;Graph&gt;::vertex_iterator vi, vi_end;
-  for (tie(vi, vi_end) = vertices(G); vi != vi_end; ++vi)
+  for (boost::tie(vi, vi_end) = vertices(G); vi != vi_end; ++vi)
     remove_vertex(*vi, G);
 
   <b>// Remove all the vertices. This is still wrong!</b>
   graph_traits&lt;Graph&gt;::vertex_iterator vi, vi_end, next;
-  tie(vi, vi_end) = vertices(G);
+  boost::tie(vi, vi_end) = vertices(G);
   for (next = vi; vi != vi_end; vi = next) {
     ++next;
     remove_vertex(*vi, G);
@@ -247,12 +247,12 @@ <h2>Iterator and Descriptor Stability/Invalidation</h2>
 
   <b>// Attempt to remove all the vertices. Wrong!</b>
   graph_traits&lt;Graph&gt;::vertex_iterator vi, vi_end;
-  for (tie(vi, vi_end) = vertices(G); vi != vi_end; ++vi)
+  for (boost::tie(vi, vi_end) = vertices(G); vi != vi_end; ++vi)
     remove_vertex(*vi, G);
 
   <b>// Remove all the vertices. This is OK.</b>
   graph_traits&lt;Graph&gt;::vertex_iterator vi, vi_end, next;
-  tie(vi, vi_end) = vertices(G);
+  boost::tie(vi, vi_end) = vertices(G);
   for (next = vi; vi != vi_end; vi = next) {
     ++next;
     remove_vertex(*vi, G);
@@ -281,7 +281,7 @@ <h2>Iterator and Descriptor Stability/Invalidation</h2>
   remove_vertex(s, G); <b>// Bad idea! Invalidates vertex descriptors in parent vector.</b>
 
   <b>// The following will produce incorrect results</b>
-  for(tie(vi, vend) = vertices(G); vi != vend; ++vi)
+  for(boost::tie(vi, vend) = vertices(G); vi != vend; ++vi)
     std::cout << p[*vi] << " is the parent of " << *vi << std::endl;
 </pre>
 
diff --git a/doc/adjacency_matrix.html b/doc/adjacency_matrix.html
index f074f5b44..7bcd1c9ec 100644
--- a/doc/adjacency_matrix.html
+++ b/doc/adjacency_matrix.html
@@ -74,7 +74,7 @@ <H1><A NAME="sec:adjacency-matrix-class"></A>
 <P></P>
 <DIV ALIGN="center"><A NAME="fig:undir-adj-matrix-graph"></A>
 <TABLE>
-<CAPTION ALIGN="BOTTOM"><STRONG>Figure 1:</STRONG> Adjacency Matrix Representation of an Undirected Graph.</CAPTION>
+<CAPTION ALIGN="BOTTOM"><STRONG>Figure 2:</STRONG> Adjacency Matrix Representation of an Undirected Graph.</CAPTION>
 <TR><TD><IMG SRC="./figs/undir-adj-matrix-graph3.gif" width="260" height="240"></TD>
 <TD><IMG SRC="./figs/undir-adj-matrix2.gif" width="135" height="136"></TD></TR>
 </TABLE>
diff --git a/doc/astar_search.html b/doc/astar_search.html
index 22b17d7d7..e1828ff5f 100644
--- a/doc/astar_search.html
+++ b/doc/astar_search.html
@@ -37,10 +37,28 @@ <H1><A NAME="sec:astar"></A>
           typename P, typename T, typename R&gt;
 void
 astar_search_no_init
+  (const IncidenceGraph &amp;g,
+   typename graph_traits&lt;VertexListGraph&gt;::vertex_descriptor s,
+   <a href="AStarHeuristic.html">AStarHeuristic</a> h, const bgl_named_params&lt;P, T, R&gt;&amp; params);
+
+template &lt;typename VertexListGraph,
+          typename AStarHeuristic,
+          typename P, typename T, typename R&gt;
+void
+astar_search_tree
   (const VertexListGraph &amp;g,
    typename graph_traits&lt;VertexListGraph&gt;::vertex_descriptor s,
    <a href="AStarHeuristic.html">AStarHeuristic</a> h, const bgl_named_params&lt;P, T, R&gt;&amp; params);
 
+template &lt;typename VertexListGraph,
+          typename AStarHeuristic,
+          typename P, typename T, typename R&gt;
+void
+astar_search_no_init_tree
+  (const IncidenceGraph &amp;g,
+   typename graph_traits&lt;VertexListGraph&gt;::vertex_descriptor s,
+   <a href="AStarHeuristic.html">AStarHeuristic</a> h, const bgl_named_params&lt;P, T, R&gt;&amp; params);
+
 <i>// Non-named parameter interface</i>
 template &lt;typename VertexListGraph, typename AStarHeuristic,
           typename <a href="AStarVisitor.html">AStarVisitor</a>, typename PredecessorMap,
@@ -60,7 +78,23 @@ <H1><A NAME="sec:astar"></A>
    CompareFunction compare, CombineFunction combine,
    CostInf inf, CostZero zero);
 
-<i>// Version that does not initialize property maps (used for implicit graphs)</i>
+template &lt;typename VertexListGraph, typename AStarHeuristic,
+          typename <a href="AStarVisitor.html">AStarVisitor</a>, typename PredecessorMap,
+          typename CostMap, typename DistanceMap,
+          typename WeightMap,
+          typename <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">CompareFunction</a>, typename <a href="http://www.sgi.com/tech/stl/BinaryFunction.html">CombineFunction</a>,
+          typename CostInf, typename CostZero&gt;
+inline void
+astar_search_tree
+  (const VertexListGraph &amp;g,
+   typename graph_traits&lt;VertexListGraph&gt;::vertex_descriptor s,
+   AStarHeuristic h, AStarVisitor vis,
+   PredecessorMap predecessor, CostMap cost,
+   DistanceMap distance, WeightMap weight,
+   CompareFunction compare, CombineFunction combine,
+   CostInf inf, CostZero zero);
+
+<i>// Versions that do not initialize property maps (used for implicit graphs)</i>
 template &lt;typename IncidenceGraph, typename AStarHeuristic,
           typename <a href="AStarVisitor.html">AStarVisitor</a>, typename PredecessorMap,
           typename CostMap, typename DistanceMap,
@@ -82,6 +116,22 @@ <H1><A NAME="sec:astar"></A>
 <b>Note that the index_map and color parameters are swapped in
 astar_search_no_init() relative to astar_search(); the named parameter
 interfaces are not affected.</b>
+
+template &lt;typename IncidenceGraph, typename AStarHeuristic,
+          typename <a href="AStarVisitor.html">AStarVisitor</a>, typename PredecessorMap,
+          typename CostMap, typename DistanceMap,
+          typename WeightMap,
+          typename <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">CompareFunction</a>, typename <a href="http://www.sgi.com/tech/stl/BinaryFunction.html">CombineFunction</a>,
+          typename CostInf, typename CostZero&gt;
+inline void
+astar_search_no_init_tree
+  (const IncidenceGraph &amp;g,
+   typename graph_traits&lt;IncidenceGraph&gt;::vertex_descriptor s,
+   AStarHeuristic h, AStarVisitor vis,
+   PredecessorMap predecessor, CostMap cost,
+   DistanceMap distance, WeightMap weight,
+   CompareFunction compare, CombineFunction combine,
+   CostInf inf, CostZero zero);
 </PRE>
 
 <P>
@@ -125,7 +175,8 @@ <H1><A NAME="sec:astar"></A>
 the entire graph.  Implicit searches can be performed with this
 implementation of A* by creating special visitors that generate
 neighbors of newly-expanded vertices.  Please note that
-<tt>astar_search_no_init()</tt> must be used for implicit graphs; the basic
+<tt>astar_search_no_init()</tt> or <tt>astar_search_no_init_tree()</tt> must be
+used for implicit graphs; the basic
 <tt>astar_search()</tt> function requires a graph that models
 the <a href="VertexListGraph.html">Vertex List Graph</a> concept.  Both
 versions
@@ -134,8 +185,9 @@ <H1><A NAME="sec:astar"></A>
 </P>
 
 <P>
-This implementation of A* is based on an OPEN/CLOSED list formulation
-of the algorithm.  Vertices on the OPEN list have been ``discovered''
+For the non-tree versions of the algorithm,
+this implementation of A* is based on an OPEN/CLOSED list formulation.
+Vertices on the OPEN list have been ``discovered''
 by the algorithm, but not ``expanded'' (we have not discovered their
 adjacent vertices).  Vertices on the CLOSED list have been completely
 examined by our search (we have expanded them and added their children
@@ -146,7 +198,11 @@ <H1><A NAME="sec:astar"></A>
 trapped by loops in the graph.  The OPEN/CLOSED lists are implemented
 using BGL's vertex coloring mechanisms.  Vertices in OPEN are colored
 gray, vertices in CLOSED are colored black, and undiscovered vertices
-are colored white.
+are colored white.  For the versions of the algorithm whose names end in
+<tt>_tree</tt>, all vertices are assumed to always be white, leading to
+checking for repeated vertices being done using the distance map.  If a dummy
+value is used for the distance map and the graph contains cycles, the algorithm
+will probably enter an infinite loop.
 </P>
 
 <P>
@@ -292,7 +348,8 @@ <h3>Named Parameters</h3>
 IN: <tt>vertex_index_map(VertexIndexMap i_map)</tt>
 <blockquote>
   This maps each vertex to an integer in the range <tt>[0,
-  num_vertices(g))</tt>.  This is necessary for efficient updates of
+  num_vertices(g))</tt>.  This is necessary in non-tree versions of the
+  algorithm for efficient updates of
   the heap data structure when an edge is relaxed.  The type
   <tt>VertexIndexMap</tt> must be a model of <a
   href="../../property_map/doc/ReadablePropertyMap.html"><tt>Readable
@@ -338,7 +395,10 @@ <h3>Named Parameters</h3>
   <tt>combine</tt> function object and the zero object for the
   identity element.  Also the distance value type must have a <a
   href="http://www.sgi.com/tech/stl/StrictWeakOrdering.html"><tt>StrictWeakOrdering</tt></a>
-  provided by the <tt>compare</tt> function object.<br>
+  provided by the <tt>compare</tt> function object.  A
+  <tt>constant_writable_property_map</tt> returning the infinity value can be
+  used for this parameter in tree versions of the algorithm when the graph does
+  not contain a directed cycle.<br>
 
   <b>Default:</b> <tt>shared_array_property_map</tt>
   with the same value type as the
@@ -355,7 +415,10 @@ <h3>Named Parameters</h3>
   <tt>h</tt>) from the vertex to a goal.  The type <tt>CostMap</tt>
   must be a model of <a
   href="../../property_map/doc/ReadWritePropertyMap.html"><tt>Read/Write
-  Property Map</tt></a>.  The vertex descriptor type of the graph
+  Property Map</tt></a> in non-tree versions of the algorithm, and <a
+  href="../../property_map/doc/WritablePropertyMap.html"><tt>Writable Property
+  Map</tt></a> in tree versions of the algorithm.  The vertex descriptor type
+  of the graph
   needs to be usable as the key type of the distance map.  The value
   type of the distance map is the element type of a <a
   href="./Monoid.html"><tt>Monoid</tt></a> formed with the
@@ -364,7 +427,8 @@ <h3>Named Parameters</h3>
   href="http://www.sgi.com/tech/stl/StrictWeakOrdering.html"><tt>StrictWeakOrdering</tt></a>
   provided by the <tt>compare</tt> function object.  The value type
   for this map must be the same as the value type for the distance
-  map.<br>
+  map.  In tree versions of the algorithm, <tt>null_property_map</tt> can be
+  used for this parameter.<br>
 
   <b>Default:</b> <tt>shared_array_property_map</tt>
   with the same value type as the
@@ -375,7 +439,8 @@ <h3>Named Parameters</h3>
 UTIL/OUT: <tt>color_map(ColorMap c_map)</tt>
 <blockquote>
 
-  This is used during the execution of the algorithm to mark the
+  This is used during the execution of non-tree versions of the algorithm to
+  mark the
   vertices, indicating whether they are on the OPEN or CLOSED lists.
   The vertices start out white and become gray when they are inserted
   into the OPEN list.  They then turn black when they are examined and
diff --git a/doc/bandwidth.html b/doc/bandwidth.html
index b02f770d9..93c2d20b2 100644
--- a/doc/bandwidth.html
+++ b/doc/bandwidth.html
@@ -31,10 +31,10 @@ <H1><A NAME="sec:bandwidth">
   bandwidth(const Graph& g, VertexIndexMap index_map)
 </pre>
 
-The <b><i>bandwidth</i></b> of an undirected graph is the maximum
+The <b><i>bandwidth</i></b> of a graph is the maximum
 distance between two adjacent vertices, with distance measured on a
 line upon which the vertices have been placed at unit intervals. To
-put it another way, if the vertices of an undirected graph
+put it another way, if the vertices of a graph
 <i>G=(V,E)</i> are each assigned an index from zero to <i>|V| - 1</i>
 given by <i>index[v]</i>, then the bandwidth of <i>G</i> is<br>
 <br>
diff --git a/doc/biconnected_components.w b/doc/biconnected_components.w
index 97ba5dc85..d2eb21ffd 100644
--- a/doc/biconnected_components.w
+++ b/doc/biconnected_components.w
@@ -156,11 +156,11 @@ template.
 
 @d Concept checking of type parameters
 @{
-function_requires< VertexListGraphConcept<Graph> >();
-function_requires< IncidenceGraphConcept<Graph> >();
-function_requires< WritablePropertyMapConcept<ComponentMap, edge_t> >();
-function_requires< ReadWritePropertyMapConcept<DiscoverTimeMap, vertex_t> >();
-function_requires< ReadWritePropertyMapConcept<LowPointMap, vertex_t> >();
+BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+BOOST_CONCEPT_ASSERT(( WritablePropertyMapConcept<ComponentMap, edge_t> ));
+BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<DiscoverTimeMap, vertex_t> ));
+BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<LowPointMap, vertex_t> ));
 @}
 
 The first step of the algorithm is to initialize the discover times of
@@ -286,6 +286,7 @@ S.pop();
 #include <boost/graph/graph_traits.hpp>
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/property_map/property_map.hpp>
+#include <boost/concept/assert.hpp>
 
 namespace boost {
   @<Biconnected Components Algorithm@>
diff --git a/doc/boykov_kolmogorov_max_flow.html b/doc/boykov_kolmogorov_max_flow.html
index 1a5b0312c..ecaaf5ca3 100644
--- a/doc/boykov_kolmogorov_max_flow.html
+++ b/doc/boykov_kolmogorov_max_flow.html
@@ -338,8 +338,8 @@ <H3>Example</H3>
   std::cout &lt;&lt; "c flow values:" &lt;&lt; std::endl;
   graph_traits &lt; Graph &gt;::vertex_iterator u_iter, u_end;
   graph_traits &lt; Graph &gt;::out_edge_iterator ei, e_end;
-  for (tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter)
-    for (tie(ei, e_end) = out_edges(*u_iter, g); ei != e_end; ++ei)
+  for (boost::tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter)
+    for (boost::tie(ei, e_end) = out_edges(*u_iter, g); ei != e_end; ++ei)
       if (capacity[*ei] &gt; 0)
         std::cout &lt;&lt; "f " &lt;&lt; *u_iter &lt;&lt; " " &lt;&lt; target(*ei, g) &lt;&lt; " "
           &lt;&lt; (capacity[*ei] - residual_capacity[*ei]) &lt;&lt; std::endl;
diff --git a/doc/bundles.html b/doc/bundles.html
index 54e1fd35f..4b789b0a5 100644
--- a/doc/bundles.html
+++ b/doc/bundles.html
@@ -93,7 +93,7 @@ <h2>Example: Route planning</h2>
     boost::property&lt;zipcodes_t, std::vector&lt;int&gt; &gt; &gt; &gt;,
     // Edge properties
     boost::property&lt;boost::edge_name_t, std::string,
-    boost::property&lt;boost::edge_length_t, double,
+    boost::property&lt;boost::edge_weight_t, double,
     boost::property&lt;edge_speed_limit_t, int,
     boost::property&lt;edge_lanes_t, int,
     boost::property&lt;edge_divided, bool&gt; &gt; &gt; &gt; &gt; &gt;
@@ -143,7 +143,7 @@ <h2>Accessing bundled properties</h2>
 map[v].zipcodes.push_back(12180);
 Map::edge_descriptor e = *out_edges(v, map).first;
 map[e].name = "I-87";
-map[e].miles = 10;
+map[e].miles = 10.;
 map[e].speed_limit = 65;
 map[e].lanes = 4;
 map[e].divided = true;
@@ -186,8 +186,8 @@ <h2>Properties maps from bundled properties</h2>
                                                get(vertex_index, map))));
 </pre>
 
-<p>The type of the returned property map is <code>property_map&lt;Map, int Highway::*&gt;::type</code>
-or <code>property_map&lt;Map, int Highway::*&gt;::const_type</code>, depending on whether the graph
+<p>The type of the returned property map is <code>property_map&lt;Map, double Highway::*&gt;::type</code>
+or <code>property_map&lt;Map, double Highway::*&gt;::const_type</code>, depending on whether the graph
 <code>map</code> is non-constant or constant.
 
 <p> You may also access the entire vertex or edge bundle as a property map
diff --git a/doc/compressed_sparse_row.html b/doc/compressed_sparse_row.html
index 8850822de..976e76b90 100644
--- a/doc/compressed_sparse_row.html
+++ b/doc/compressed_sparse_row.html
@@ -101,8 +101,8 @@ <h1>Compressed Sparse Row Graph</h1>
     <pre>
 namespace boost {
 
-template&lt;typename <a href="#Directed">Directed</a> = directedS, typename <a href="#VertexProperty">VertexProperty</a> = void, 
-         typename <a href="#EdgeProperty">EdgeProperty</a> = void, typename <a href="#GraphProperty">GraphProperty</a> = no_property, 
+template&lt;typename <a href="#Directed">Directed</a> = directedS, typename <a href="#VertexProperty">VertexProperty</a> = no_property, 
+         typename <a href="#EdgeProperty">EdgeProperty</a> = no_property, typename <a href="#GraphProperty">GraphProperty</a> = no_property, 
          typename <a href="#Vertex">Vertex</a> = std::size_t, typename <a href="#EdgeIndex">EdgeIndex</a> = Vertex&gt;
 class compressed_sparse_row_graph
 {
diff --git a/doc/constructing_algorithms.html b/doc/constructing_algorithms.html
index 0067ee3e5..4c9e96e25 100644
--- a/doc/constructing_algorithms.html
+++ b/doc/constructing_algorithms.html
@@ -79,7 +79,7 @@ <H1>Constructing graph algorithms with BGL</H1>
 href="./VertexListGraph.html">VertexListGraph</a>. This is enforced by
 the use of those graph operations in the algorithm, and furthermore by
 our explicit requirement added as a concept check with
-<TT>function_requires()</TT> (see Section <A
+<TT>BOOST_CONCEPT_ASSERT()</TT> (see Section <A
 HREF="../../concept_check/concept_check.htm">Concept
 Checking</A> for more details about concept checking).
 
@@ -106,7 +106,7 @@ <H1>Constructing graph algorithms with BGL</H1>
 graph algorithm as a template function, the concept checks, and some
 typedefs. The implementation is straightforward, the only step not
 discussed above is the color initialization step, where we set the
-color of all the vertices to ``uncolored''.
+color of all the vertices to "uncolored."
 
 <P>
 <PRE>
@@ -122,11 +122,11 @@ <H1>Constructing graph algorithms with BGL</H1>
     typedef typename property_traits&lt;Color&gt;::value_type ColorType;
     typedef typename property_traits&lt;Order&gt;::value_type OrderType;
 
-    function_requires&lt; VertexListGraphConcept&lt;VertexListGraph&gt; &gt;();
-    function_requires&lt; ReadWritePropertyMapConcept&lt;Color, vertex_descriptor&gt; &gt;();
-    function_requires&lt; IntegerConcept&lt;ColorType&gt; &gt;();
-    function_requires&lt; size_type, ReadablePropertyMapConcept&lt;Order&gt; &gt;();
-    typedef typename same_type&lt;OrderType, vertex_descriptor&gt;::type req_same;
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept&lt;VertexListGraph&gt; ));
+    BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept&lt;Color, vertex_descriptor&gt; ));
+    BOOST_CONCEPT_ASSERT(( IntegerConcept&lt;ColorType&gt; ));
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept&lt;Order, size_type&gt; ));
+    BOOST_STATIC_ASSERT((is_same&lt;OrderType, vertex_descriptor&gt;::value));
     
     size_type max_color = 0;
     const size_type V = num_vertices(G);
@@ -134,7 +134,7 @@ <H1>Constructing graph algorithms with BGL</H1>
       mark(V, numeric_limits_max(max_color));
     
     typename GraphTraits::vertex_iterator v, vend;
-    for (tie(v, vend) = vertices(G); v != vend; ++v)
+    for (boost::tie(v, vend) = vertices(G); v != vend; ++v)
       color[*v] = V - 1; // which means "not colored"
     
     for (size_type i = 0; i &lt; V; i++) {
@@ -142,7 +142,7 @@ <H1>Constructing graph algorithms with BGL</H1>
 
       // mark all the colors of the adjacent vertices
       typename GraphTraits::adjacency_iterator ai, aend;
-      for (tie(ai, aend) = adjacent_vertices(current, G); ai != aend; ++ai)
+      for (boost::tie(ai, aend) = adjacent_vertices(current, G); ai != aend; ++ai)
         mark[color[*ai]] = i; 
 
       // find the smallest color unused by the adjacent vertices
diff --git a/doc/cycle_canceling.html b/doc/cycle_canceling.html
new file mode 100644
index 000000000..63cecf050
--- /dev/null
+++ b/doc/cycle_canceling.html
@@ -0,0 +1,223 @@
+<HTML>
+<!--
+     Copyright (c) Piotr Wygocki 2013
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Boost Graph Library: Cycle Canceling for  Min Cost Max Flow</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H1><A NAME="sec:cycle_canceling">
+<TT>cycle_canceling</TT>
+</H1>
+
+<PRE>
+<i>// named parameter version</i>
+template &lt;class <a href="./Graph.html">Graph</a>, class P, class T, class R&gt;
+void cycle_canceling(
+        Graph &amp;g, 
+        const bgl_named_params&lt;P, T, R&gt; &amp; params  = <i>all defaults</i>)
+
+<i>// non-named parameter version</i>
+template &lt;class <a href="./Graph.html">Graph</a>, class Pred, class Distance, class Reversed, class ResidualCapacity, class Weight&gt;
+void cycle_canceling(const Graph &amp; g, Weight weight, Reversed rev, ResidualCapacity residual_capacity, Pred pred, Distance distance) 
+</PRE>
+
+<P>
+The <tt>cycle_canceling()</tt> function calculates the minimum cost flow of a network with given flow. See Section <a
+href="./graph_theory_review.html#sec:network-flow-algorithms">Network
+Flow Algorithms</a> for a description of maximum flow. 
+For given flow values <i> f(u,v)</i>  function minimizes flow cost in such a way, that for each <i>v in V</i> the
+ <i> sum<sub> u in V</sub>  f(v,u) </i> is preserved. Particularly if the input flow was the maximum flow, the function produces min cost max flow.
+  
+
+ The function calculates the flow values <i>f(u,v)</i> for all <i>(u,v)</i> in
+<i>E</i>, which are returned in the form of the residual capacity
+<i>r(u,v) = c(u,v) - f(u,v)</i>. 
+
+<p>
+There are several special requirements on the input graph and property
+map parameters for this algorithm. First, the directed graph
+<i>G=(V,E)</i> that represents the network must be augmented to
+include the reverse edge for every edge in <i>E</i>.  That is, the
+input graph should be <i>G<sub>in</sub> = (V,{E U
+E<sup>T</sup>})</i>. The <tt>ReverseEdgeMap</tt> argument <tt>rev</tt>
+must map each edge in the original graph to its reverse edge, that is
+<i>(u,v) -> (v,u)</i> for all <i>(u,v)</i> in <i>E</i>. 
+The <tt>WeightMap</tt> has to map each edge from <i>E<sup>T</sup></i> to <i>-weight</i> of its reversed edge.
+Note that edges from <i>E</i> can have negative weights. 
+<p>
+If weights in the graph are nonnegative, the 
+<a href="./successive_shortest_path_nonnegative_weights.html"><tt>successive_shortest_path_nonnegative_weights()</tt></a> 
+might be better choice for min cost max flow.
+
+<p>
+The algorithm is described in <a
+href="./bibliography.html#ahuja93:_network_flows">Network Flows</a>.
+
+<p>
+In each round algorithm augments the negative cycle (in terms of weight) in the residual graph.
+If there is no negative cycle in the network, the cost is optimized.
+
+<p>
+Note that, although we mention capacity in the problem description, the actual algorithm doesn't have to now it.
+
+<p> 
+In order to find the cost of the result flow use:
+<a href="./find_flow_cost.html"><tt>find_flow_cost()</tt></a>.
+
+
+<H3>Where Defined</H3>
+
+<P>
+<a href="../../../boost/graph/successive_shortest_path_nonnegative_weights.hpp"><TT>boost/graph/successive_shortest_path_nonnegative_weights.hpp</TT></a>
+
+<P>
+
+<h3>Parameters</h3>
+
+IN: <tt>Graph&amp; g</tt>
+<blockquote>
+  A directed graph. The
+  graph's type must be a model of <a
+  href="./VertexListGraph.html">VertexListGraph</a> and <a href="./IncidenceGraph.html">IncidenceGraph</a> For each edge
+  <i>(u,v)</i> in the graph, the reverse edge <i>(v,u)</i> must also
+  be in the graph.
+</blockquote>
+  
+<h3>Named Parameters</h3>
+
+  
+IN/OUT: <tt>residual_capacity_map(ResidualCapacityEdgeMap res)</tt>
+<blockquote>
+  This maps edges to their residual capacity. The type must be a model
+  of a mutable <a
+  href="../../property_map/doc/LvaluePropertyMap.html">Lvalue Property
+  Map</a>. The key type of the map must be the graph's edge descriptor
+  type.<br>
+  <b>Default:</b> <tt>get(edge_residual_capacity, g)</tt>
+</blockquote>
+
+IN: <tt>reverse_edge_map(ReverseEdgeMap rev)</tt>
+<blockquote>
+  An edge property map that maps every edge <i>(u,v)</i> in the graph
+  to the reverse edge <i>(v,u)</i>. The map must be a model of
+  constant <a href="../../property_map/doc/LvaluePropertyMap.html">Lvalue
+  Property Map</a>. The key type of the map must be the graph's edge
+  descriptor type.<br>
+  <b>Default:</b> <tt>get(edge_reverse, g)</tt>
+</blockquote>
+
+IN: <tt>weight_map(WeightMap w)</tt>
+<blockquote>
+  The weight (also know as ``length'' or ``cost'') of each edge in the
+  graph.  The <tt>WeightMap</tt> type must be a model of <a
+  href="../../property_map/doc/ReadablePropertyMap.html">Readable Property
+  Map</a>.  The key type for this property map must be the edge
+  descriptor of the graph.  The value type for the weight map must be
+  <i>Addable</i> with the distance map's value type. <br>
+  <b>Default:</b> <tt>get(edge_weight, g)</tt><br>
+</blockquote>
+
+UTIL: <tt>predecessor_map(PredEdgeMap pred)</tt>
+<blockquote>
+  Use by the algorithm to store augmenting paths. The map must be a
+  model of mutable <a
+  href="../../property_map/doc/LvaluePropertyMap.html">Lvalue Property Map</a>.
+  The key type must be the graph's vertex descriptor type and the
+  value type must be the graph's edge descriptor type.<br>
+
+  <b>Default:</b> an <a
+  href="../../property_map/doc/iterator_property_map.html">
+  <tt>iterator_property_map</tt></a> created from a <tt>std::vector</tt>
+  of edge descriptors of size <tt>num_vertices(g)</tt> and
+  using the <tt>i_map</tt> for the index map.
+</blockquote>
+
+UTIL: <tt>distance_map(DistanceMap d_map)</tt> 
+<blockquote>
+  The shortest path weight from the source vertex <tt>s</tt> to each
+  vertex in the graph <tt>g</tt> is recorded in this property map. The
+  shortest path weight is the sum of the edge weights along the
+  shortest path.  The type <tt>DistanceMap</tt> must be a model of <a
+  href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write
+  Property Map</a>. The vertex descriptor type of the graph needs to
+  be usable as the key type of the distance map. 
+
+  <b>Default:</b> <a
+  href="../../property_map/doc/iterator_property_map.html">
+  <tt>iterator_property_map</tt></a> created from a
+  <tt>std::vector</tt> of the <tt>WeightMap</tt>'s value type of size
+  <tt>num_vertices(g)</tt> and using the <tt>i_map</tt> for the index
+  map.<br>
+
+</blockquote>
+
+IN: <tt>vertex_index_map(VertexIndexMap i_map)</tt>
+<blockquote>
+  Maps each vertex of the graph to a unique integer in the range
+  <tt>[0, num_vertices(g))</tt>. This property map is only needed
+  if the default for the distance or predecessor map is used.
+  The vertex index map must be a model of <a
+  href="../../property_map/doc/ReadablePropertyMap.html">Readable Property
+  Map</a>. The key type of the map must be the graph's vertex
+  descriptor type.<br>
+  <b>Default:</b> <tt>get(vertex_index, g)</tt>
+    Note: if you use this default, make sure your graph has
+    an internal <tt>vertex_index</tt> property. For example,
+    <tt>adjacenty_list</tt> with <tt>VertexList=listS</tt> does
+    not have an internal <tt>vertex_index</tt> property.
+</blockquote>
+
+<h3>Complexity</h3>
+In the integer capacity and weight case, if <i>C</i> is the initial cost of the flow, then the complexity is <i> O(C * |V| * |E|)</i>, 
+where <i>O(|E|* |V|)</i> is the complexity of the bellman ford shortest paths algorithm and <i>C</i> is upper bound on number of iteration. 
+In many real world cases number of iterations is much smaller than <i>C</i>.
+
+
+<h3>Example</h3>
+
+The program in <a
+href="../example/cycle_canceling_example.cpp"><tt>example/cycle_canceling_example.cpp</tt></a>.
+
+
+<h3>See Also</h3>
+
+<a href="./successive_shortest_path_nonnegative_weights.html"><tt>successive_shortest_path_nonnegative_weights()</tt></a><br>
+<a href="./find_flow_cost.html"><tt>find_flow_cost()</tt></a>.
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2013</TD><TD>
+Piotr Wygocki, University of Warsaw (<A HREF="mailto:wygos@mimuw.edu.pl">wygos at mimuw.edu.pl</A>)
+</TD></TR></TABLE>
+
+</BODY>
+</HTML> 
+<!--  LocalWords:  HTML Siek Edmonds BGCOLOR ffffff ee VLINK ALINK ff IMG SRC
+ -->
+<!--  LocalWords:  gif ALT BR sec edmonds karp TT DIV CELLPADDING TR TD PRE lt
+ -->
+<!--  LocalWords:  typename VertexListGraph CapacityEdgeMap ReverseEdgeMap gt
+ -->
+<!--  LocalWords:  ResidualCapacityEdgeMap VertexIndexMap src rev ColorMap pred
+ -->
+<!--  LocalWords:  PredEdgeMap tt href html hpp ul li nbsp br LvaluePropertyMap
+ -->
+<!--  LocalWords:  num ColorValue DIMACS cpp pre config iostream dimacs int std
+ -->
+<!--  LocalWords:  namespace vecS directedS cout endl iter ei HR valign nowrap
+ -->
+<!--  LocalWords:  jeremy siek htm Univ mailto jsiek lsc edu
+p -->
+
diff --git a/doc/depth_first_search.html b/doc/depth_first_search.html
index e217972ae..b0057f7d7 100644
--- a/doc/depth_first_search.html
+++ b/doc/depth_first_search.html
@@ -107,6 +107,7 @@ <H1><A NAME="sec:depth-first-search"></A><img src="figs/python.gif" alt="(Python
       <i>...</i>
     <b>else if</b> (<i>color[v] =</i> BLACK) 
       <i>...</i>
+    <i>...</i>
   <b>end for</b>
   <i>color[u] :=</i> BLACK
   <i>f_time[u] := time := time + 1</i> 
@@ -140,6 +141,8 @@ <H1><A NAME="sec:depth-first-search"></A><img src="figs/python.gif" alt="(Python
 -
 <i>(u,v)</i> is a cross or forward edge
 -
+finish edge <i>(u,v)</i>
+-
 finish vertex <i>u</i>
 -
 </pre>
@@ -266,6 +269,9 @@ <h3>Visitor Event Points</h3>
 <li><b><tt>vis.forward_or_cross_edge(e, g)</tt></b> is invoked on
   forward or cross edges in the graph. In an undirected graph this
   method is never called.
+
+<li><b><tt>vis.finish_edge(e, g)</tt></b> is invoked on the non-tree edges in 
+  the graph as well as on each tree edge after its target vertex is finished. 
   
 <li><b><tt>vis.finish_vertex(u, g)</tt></b> is invoked on a vertex after
   all of its out edges have been added to the search tree and all of
diff --git a/doc/dijkstra_shortest_paths.html b/doc/dijkstra_shortest_paths.html
index ac991c794..369e78a0d 100644
--- a/doc/dijkstra_shortest_paths.html
+++ b/doc/dijkstra_shortest_paths.html
@@ -248,9 +248,13 @@ <h3>Named Parameters</h3>
 
 OUT: <tt>predecessor_map(PredecessorMap p_map)</tt> 
 <blockquote>
-  The predecessor map records the edges in the minimum spanning
-  tree. Upon completion of the algorithm, the edges <i>(p[u],u)</i>
-  for all <i>u in V</i> are in the minimum spanning tree. If <i>p[u] =
+  The predecessor map records the edges in the shortest path tree, the tree computed
+  by the traversal of the graph. Upon completion of the algorithm, the edges 
+  <i>(p[u],u)</i> for all <i>u in V</i> are in the tree.  The shortest path
+  from vertex <i>s</i> to each vertex <i>v</i> in the graph consists of the
+  vertices <i>v</i>, <i>p[v]</i>, <i>p[p[v]]</i>, and so on until <i>s</i> is
+  reached, in reverse order.  The
+  tree is not guaranteed to be a minimum spanning tree. If <i>p[u] =
   u</i> then <i>u</i> is either the source vertex or a vertex that is
   not reachable from the source.  The <tt>PredecessorMap</tt> type
   must be a <a
@@ -326,7 +330,9 @@ <h3>Named Parameters</h3>
 <blockquote>
   The <tt>inf</tt> object must be the greatest value of any <tt>D</tt> object.
   That is, <tt>compare(d, inf) == true</tt> for any <tt>d != inf</tt>.
-  The type <tt>D</tt> is the value type of the <tt>DistanceMap</tt>.<br>
+  The type <tt>D</tt> is the value type of the <tt>DistanceMap</tt>.  Edges
+  are assumed to have a weight less than (using <tt>distance_compare</tt> for
+  comparison) this value.<br>
   <b>Default:</b> <tt>std::numeric_limits&lt;D&gt;::max()</tt><br>
 
   <b>Python</b>: Unsupported parameter.
@@ -386,7 +392,7 @@ <h3>Named Parameters</h3>
 <H3>Complexity</H3>
 
 <P>
-The time complexity is <i>O(V log V)</i>.
+The time complexity is <i>O(V log V + E)</i>.
 
 
 <h3>Visitor Event Points</h3>
diff --git a/doc/dijkstra_shortest_paths_no_color_map.html b/doc/dijkstra_shortest_paths_no_color_map.html
index c08cc57e0..c7202b68a 100644
--- a/doc/dijkstra_shortest_paths_no_color_map.html
+++ b/doc/dijkstra_shortest_paths_no_color_map.html
@@ -69,7 +69,7 @@ <H1><A NAME="sec:dijkstra"></A>
 </P>
 
 <P>
-	<tt>dijkstra_shortest_paths_no_color_map</tt> differs from the original <tt>dijkstra_shortest_paths</tt> algorithm by not using a color map to identify vertices as discovered or undiscovered.  Instead, this is done with the distance map: a vertex <i>u</i> such that <i>distance_compare(distance_map[u], distance_infinity) == false</i> is considered to be undiscovered.
+	<tt>dijkstra_shortest_paths_no_color_map</tt> differs from the original <tt>dijkstra_shortest_paths</tt> algorithm by not using a color map to identify vertices as discovered or undiscovered.  Instead, this is done with the distance map: a vertex <i>u</i> such that <i>distance_compare(distance_map[u], distance_infinity) == false</i> is considered to be undiscovered.  Note that this means that edges with infinite weight will not work correctly in this algorithm.
 </P>
 
 <P>
@@ -116,10 +116,6 @@ <H1><A NAME="sec:dijkstra"></A>
 <td valign="top">
 <pre>
 DIJKSTRA(<i>G</i>, <i>s</i>, <i>w</i>)
-  <b>for</b> each vertex <i>u in V</i> <b>(This loop is not run in dijkstra_shortest_paths_no_color_map_no_init)</b>
-    <i>d[u] := infinity</i> 
-    <i>p[u] := u</i> 
-  <b>end for</b>
   <i>d[s] := 0</i> 
   INSERT(<i>Q</i>, <i>s</i>)
   <b>while</b> (<i>Q != &Oslash;</i>)
@@ -128,11 +124,12 @@ <H1><A NAME="sec:dijkstra"></A>
       <b>if</b> (<i>w(u,v) + d[u] < d[v]</i>)
         <i>d[v] := w(u,v) + d[u]</i>
         <i>p[v] := u</i> 
-        DECREASE-KEY(<i>Q</i>, <i>v</i>)
+        <b>if</b> (<i>d[v]</i> was originally infinity) 
+          INSERT(<i>Q</i>, <i>v</i>)   
+        <b>else</b>
+          DECREASE-KEY(<i>Q</i>, <i>v</i>)
       <b>else</b>
       	...
-      <b>if</b> (<i>d[v]</i> was originally infinity) 
-        INSERT(<i>Q</i>, <i>v</i>)   
     <b>end for</b>
   <b>end while</b>
   return (<i>d</i>, <i>p</i>)
@@ -141,10 +138,6 @@ <H1><A NAME="sec:dijkstra"></A>
 <td valign="top">
 <pre>
 
-initialize vertex <i>u</i>
-
-
-
 
 discover vertex <i>s</i>
 
@@ -154,10 +147,11 @@ <H1><A NAME="sec:dijkstra"></A>
 edge <i>(u,v)</i> relaxed
 
 
+discover vertex <i>v</i>
+
 
 edge <i>(u,v)</i> not relaxed
 
-discover vertex <i>v</i>
 finish vertex <i>u</i>
 </pre>
 </td>
@@ -293,7 +287,9 @@ <h3>Named Parameters</h3>
 <blockquote>
   The <tt>distance_infinity</tt> object must be the greatest value of any <tt>D</tt> object.
   That is, <tt>distance_compare(d, distance_infinity) == true</tt> for any <tt>d != distance_infinity</tt>.
-  The type <tt>D</tt> is the value type of the <tt>DistanceMap</tt>.<br>
+  The type <tt>D</tt> is the value type of the <tt>DistanceMap</tt>.  All edges
+  are assumed to have weight less than (by <tt>distance_compare</tt>) this
+  value.<br>
   <b>Default:</b> <tt>std::numeric_limits&lt;D&gt;::max()</tt><br>
 </blockquote>
 
@@ -322,7 +318,7 @@ <h3>Named Parameters</h3>
 <H3>Complexity</H3>
 
 <P>
-The time complexity is <i>O(V log V)</i>.
+The time complexity is <i>O(V log V + E)</i>.
 
 
 <h3>Visitor Event Points</h3>
diff --git a/doc/directed_graph.html b/doc/directed_graph.html
new file mode 100644
index 000000000..227a3fa30
--- /dev/null
+++ b/doc/directed_graph.html
@@ -0,0 +1,96 @@
+<HTML>
+<!--
+     Copyright (c) David Doria 2012
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Boost Graph Library: Directed Graph</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H1><A NAME="sec:directed-graph-class"></A>
+<pre>
+directed_graph&lt;VertexProp, EdgeProp, GraphProp&gt;
+</pre>
+</H1>
+
+
+<P>
+The <tt>directed_graph</tt> class template is a simplified version
+of the BGL adjacency list. This class is provided for ease of use, but
+may not perform as well as custom-defined adjacency list classes. Instances
+of this template model the BidirectionalGraph, VertexIndexGraph, and
+EdgeIndexGraph concepts.
+
+<H3>Example</H3>
+
+A simple examples of creating a directed_graph is available here <a href="../../../libs/graph/example/directed_graph.cpp"><tt>libs/graph/example/directed_graph.cpp</tt></a>.
+<P>
+
+
+<PRE>
+  typedef boost::directed_graph&lt;&gt; Graph;
+  Graph g;
+  boost::graph_traits&lt;Graph&gt;::vertex_descriptor v0 = g.add_vertex();
+  boost::graph_traits&lt;Graph&gt;::vertex_descriptor v1 = g.add_vertex();
+
+  g.add_edge(v0, v1);
+</PRE>
+
+<H3>Template Parameters</H3>
+
+<P>
+<TABLE border>
+<TR>
+<th>Parameter</th><th>Description</th><th>Default</th>
+</tr>
+
+<TR><TD><TT>VertexProp</TT></TD>
+<TD>A property map for the graph vertices.</TD>
+<TD>&nbsp;</TD>
+</TR>
+
+<TR>
+<TD><TT>EdgeProp</TT></TD>
+<TD>A property map for the graph edges.</TD>
+<TD>&nbsp;</TD>
+</TR>
+
+<TR>
+<TD><TT>GraphProp</TT></TD>
+<TD>A property map for the graph itself.</TD>
+</TR>
+
+</TABLE>
+<P>
+
+<H3>Where Defined</H3>
+
+<P>
+<a href="../../../boost/graph/directed_graph.hpp"><TT>boost/graph/directed_graph.hpp</TT></a>
+
+<P>
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</A>,
+Indiana University (<A
+HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
+<A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
+<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+Indiana University (<A
+HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
+</TD></TR></TABLE>
+
+</BODY>
+</HTML> 
diff --git a/doc/distance_recorder.html b/doc/distance_recorder.html
index fe7cd559f..a6b05fe27 100644
--- a/doc/distance_recorder.html
+++ b/doc/distance_recorder.html
@@ -153,7 +153,7 @@ <h3>See Also</h3>
 <a href="./visitor_concepts.html">Visitor concepts</a>
 <p>
 The following are other event visitors: <a
- href="./distance_recorder.html"><tt>predecessor_recorder</tt></a>,
+ href="./predecessor_recorder.html"><tt>predecessor_recorder</tt></a>,
 <a href="./time_stamper.html"><tt>time_stamper</tt></a>,
 and <a href="./property_writer.html"><tt>property_writer</tt></a>.
 
diff --git a/doc/edge_coloring.html b/doc/edge_coloring.html
new file mode 100644
index 000000000..7febb4692
--- /dev/null
+++ b/doc/edge_coloring.html
@@ -0,0 +1,98 @@
+<HTML>
+<!--
+  ~~ Copyright (c) Maciej Piechotka 2013
+  ~~
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+-->
+  
+  
+<Head> 
+<Title>Boost Graph Library: Edge Coloring</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H1>
+<!-- <img src="figs/python.gif" alt="(Python)"/> -->
+<TT>edge_coloring</TT>
+</H1>
+
+
+<P>
+<DIV ALIGN="LEFT">
+<TABLE CELLPADDING=3 border>
+<TR><TH ALIGN="LEFT"><B>Graphs:</B></TH>
+<TD ALIGN="LEFT">undirected, loop-free</TD>
+</TR>
+<TR><TH ALIGN="LEFT"><B>Properties:</B></TH>
+<TD ALIGN="LEFT">color</TD>
+</TR>
+<TR><TH ALIGN="LEFT"><B>Complexity:</B></TH>
+<TD ALIGN="LEFT">time: <i>O(|E| |V|)</i> </TD>
+</TR>
+</TABLE>
+</DIV>
+
+
+<pre>
+  template &lt;class Graph, class ColorMap&gt;
+  typename boost::property_traits<ColorMap>::value_type
+  edge_coloring(const Graph &amp;g, ColorMap color);
+</pre>
+
+<p>Computes an edge coloring for the vertices in the graph, using
+an algorithm proposed by Mista et al. []. Given edges ordered
+e<sub>1</sub>, e<sub>2</sub>, ..., e<sub>n</sub> it assignes a
+colors c<sub>1</sub>, c<sub>2</sub>, ..., c<sub>n</sub> in a way
+that no vertex connects with 2 edges of the same color. Furthermore
+at most m + 1 colors are used.
+
+<!-- King, I.P. An automatic reordering scheme for simultaneous equations derived from network analysis. Int. J. Numer. Methods Engrg. 2 (1970), 523-533 -->
+
+<h3>Where defined</h3>
+<a href="../../../boost/graph/edge_coloring.hpp"><tt>boost/graph/edge_coloring.hpp</tt></a>
+
+<h3>Parameters</h3>
+
+IN: <tt>const Graph&amp; g</tt>
+<blockquote>
+  The graph object on which the algorithm will be applied. The type
+  <tt>Graph</tt> must be a model of <a href="EdgeListGraph.html">
+  Edge List Graph</a> and <a href="IncidenceGraph.html">Incidence
+  Graph</a>.
+</blockquote>
+
+OUT: <tt>ColorMap color</tt>
+<blockquote>
+  This property map records the colors of each edges. It must be a
+  model of <A HREF="../../property_map/doc/ReadWritePropertyMap.html">
+  Read/Write Property Map</A> whose key type is the same as the edge
+  descriptor type of the graph and whose value type is an integral type
+  that can store all values smaller or equal to m.
+</blockquote>
+
+
+<h3>Example</h3>
+
+See <A
+href="../example/edge_coloring.cpp"><tt>example/king_ordering.cpp</tt></A>.
+
+<h3>See Also</h3>
+
+<A href="./sequential_vertex_coloring.html">sequential vertex ordering</tt></A>.
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2013</TD><TD>
+Maciej Piechotka (<A HREF="mailto:uzytkownik2@gmail.com">uzytkownik2@gmail.com</A>)
+</TD></TR></TABLE>
+
+</BODY>
+</HTML> 
diff --git a/doc/edge_predecessor_recorder.html b/doc/edge_predecessor_recorder.html
new file mode 100644
index 000000000..9ed626b63
--- /dev/null
+++ b/doc/edge_predecessor_recorder.html
@@ -0,0 +1,197 @@
+<HTML>
+<!--
+     Copyright (c) Jeremy Siek, Lie-Quan Lee, and Andrew Lumsdaine 2000
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Boost Graph Library: edge_predecessor_recorder</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H1>
+<pre>
+edge_predecessor_recorder&lt;PredEdgeMap, EventTag&gt;
+</pre>
+</H1>
+
+This is an <a href="./EventVisitor.html">EventVisitor</a> that records
+the predecessor (or parent) edge of a vertex in a property
+map. This is particularly useful in graph search algorithms where
+recording the predecessors is an efficient way to encode the search
+tree that was traversed during the search. The edge predecessor recorder is
+typically used with the <tt>on_tree_edge</tt> or
+<tt>on_relax_edge</tt> events and cannot be used with vertex events.  This
+visitor is meant to be used instead of <a
+href="predecessor_recorder.html"><tt>predecessor_recorder</tt></a> when a
+graph has parallel edges and it is necessary to know which incoming edge a
+search algorithm
+used to get to a particular vertex.
+
+<p>
+<tt>edge_predecessor_recorder</tt> can be used with graph algorithms by
+wrapping it with an algorithm-specific adaptor, such as <a
+href="./bfs_visitor.html"><tt>bfs_visitor</tt></a> and <a
+href="./dfs_visitor.html"><tt>dfs_visitor</tt></a>. Also, this event
+visitor can be combined with other event visitors using
+<tt>std::pair</tt> to form an EventVisitorList.
+
+<p>
+Algorithms such as Dijkstra's and breadth-first search will not assign
+a predecessor edge to the source vertex (which is the root of the search
+tree). It is often useful to initialize the source vertex's
+predecessor to a special value, thereby identifying the root vertex.
+When using an algorithm like
+depth-first search that creates a forest (multiple search trees) it
+is useful to do the same for every vertex. This
+way all the root nodes can be distinguished.
+
+
+<!-- <h3>Example</h3>
+
+See the example for <a href="./bfs_visitor.html"><tt>bfs_visitor</tt></a>.
+-->
+
+<h3>Model of</h3>
+
+<a href="./EventVisitor.html">EventVisitor</a>
+
+
+<H3>Where Defined</H3>
+
+<P>
+<a href="../../../boost/graph/visitors.hpp">
+<TT>boost/graph/visitors.hpp</TT></a>
+
+<H3>Template Parameters</H3>
+
+<P>
+<TABLE border>
+<TR>
+<th>Parameter</th><th>Description</th><th>Default</th>
+</tr>
+
+<TR><TD><TT>PredEdgeMap</TT></TD>
+<TD>
+A <a
+href="../../property_map/doc/WritablePropertyMap.html">WritablePropertyMap</a>
+where the key and value types are the vertex and edge descriptor types, respectively, of the graph.
+</TD>
+<TD>&nbsp;</TD>
+</TR>
+
+<TR><TD><TT>EventTag</TT></TD>
+<TD>
+The tag to specify when the <tt>edge_predecessor_recorder</tt> should be
+applied during the graph algorithm. <tt>EventTag</tt> must be an
+edge event.
+</TD>
+<TD>&nbsp;</TD>
+</TR>
+
+</table>
+
+<H2>Associated Types</H2>
+
+<table border>
+
+<tr>
+<th>Type</th><th>Description</th>
+</tr>
+
+<tr>
+<td><tt>edge_predecessor_recorder::event_filter</tt></td>
+<td>
+This will be the same type as the template parameter <tt>EventTag</tt>.
+</td>
+</tr>
+
+</table>
+
+<h3>Member Functions</h3>
+
+<p>
+
+<table border>
+<tr>
+<th>Member</th><th>Description</th>
+</tr>
+
+<tr>
+<td><tt>
+edge_predecessor_recorder(PredEdgeMap pa);
+</tt></td>
+<td>
+Construct an edge predecessor recorder object with predecessor property map
+<tt>pa</tt>.
+</td>
+</tr>
+
+<tr>
+<td><tt>
+template &lt;class Edge, class Graph&gt;<br>
+void operator()(Edge e, const Graph& g);
+</tt></td>
+<td>
+Given edge <i>e = (u,v)</i>, this records <i>e</i> as the
+predecessor (or parent) edge of <i>v</i>.
+</td>
+</tr>
+
+</table>
+
+<h3>Non-Member Functions</h3>
+
+<table border>
+<tr>
+<th>Function</th><th>Description</th>
+</tr>
+
+<tr><td><tt>
+template &lt;class PredEdgeMap, class Tag&gt;<br>
+edge_predecessor_recorder&lt;PredEdgeMap, Tag&gt; <br>
+record_edge_predecessors(PredEdgeMap pa, Tag);
+</tt></td><td>
+A convenient way to create a <tt>edge_predecessor_recorder</tt>.
+</td></tr>
+
+</table>
+
+<h3>See Also</h3>
+
+<a href="./visitor_concepts.html">Visitor concepts</a>
+<p>
+The following are other event visitors: <a
+<a href="./distance_recorder.html"><tt>distance_recorder</tt></a>,
+<a href="./time_stamper.html"><tt>time_stamper</tt></a>,
+and <a href="./property_writer.html"><tt>property_writer</tt></a>.
+
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</A>,
+Indiana University (<A
+HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
+<A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
+<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+Indiana University (<A
+HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
+</TD></TR></TABLE>
+
+</BODY>
+</HTML> 
+<!--  LocalWords:  PredEdgeMap EventTag EventVisitor map bfs dfs const
+ -->
+<!--  LocalWords:  EventVisitorList WritablePropertyMap Siek Univ Quan
+ -->
+<!--  LocalWords:  Lumsdaine
+ -->
diff --git a/doc/faq.html b/doc/faq.html
index 6f4914842..c77fca5db 100644
--- a/doc/faq.html
+++ b/doc/faq.html
@@ -115,7 +115,7 @@ <h1>Frequently Asked Questions</h1>
   // initialize the vertex_index property values
   graph_traits&lt;graph_t&gt;::vertex_iterator vi, vend;
   graph_traits&lt;graph_t&gt;::vertices_size_type cnt = 0;
-  for(tie(vi,vend) = vertices(G); vi != vend; ++vi)
+  for(boost::tie(vi,vend) = vertices(G); vi != vend; ++vi)
     put(index, *vi, cnt++);
 </pre>
 </li>
@@ -124,8 +124,8 @@ <h1>Frequently Asked Questions</h1>
 not being found, such as:
 <pre>
 ../../../boost/concept_check.hpp:209: no match for
-`boost::detail::error_property_not_found & == 
- boost::detail::error_property_not_found &'
+`boost::detail::error_property_not_found &amp; == 
+ boost::detail::error_property_not_found &amp;'
 </pre>
 or a message such as:
 <pre>
diff --git a/doc/file_dependency_example.html b/doc/file_dependency_example.html
index c600b74c9..501526764 100644
--- a/doc/file_dependency_example.html
+++ b/doc/file_dependency_example.html
@@ -211,7 +211,7 @@ <H2><A NAME="sec:parallel-compilation"></A>
 the time slot must be one more than the maximum time-slot of the files
 it depends on.
 
-<P>We start be creating a vector <code>time</code> that will store the
+<P>We start by creating a vector <code>time</code> that will store the
   time step at which each file can be built. We initialize every value
   with time step zero.</p>
 
@@ -233,7 +233,7 @@ <H2><A NAME="sec:parallel-compilation"></A>
       if (in_degree (*i, g) &gt; 0) {
         Graph::in_edge_iterator j, j_end;
         int maxdist = 0;
-        for (tie(j, j_end) = in_edges(*i, g); j != j_end; ++j)
+        for (boost::tie(j, j_end) = in_edges(*i, g); j != j_end; ++j)
           maxdist = std::max(time[source(*j, g)], maxdist);
         time[*i]=maxdist+1;
       }
diff --git a/doc/find_flow_cost.html b/doc/find_flow_cost.html
new file mode 100644
index 000000000..7f839cf90
--- /dev/null
+++ b/doc/find_flow_cost.html
@@ -0,0 +1,139 @@
+<HTML>
+<!--
+     Copyright (c) Piotr Wygocki 2013
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Boost Graph Library: Find Flow Cost</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H1><A NAME="sec:find_flow_cost">
+<TT>find_flow_cost</TT>
+</H1>
+
+<PRE>
+<i>// named parameter version</i>
+template &lt;class <a href="./Graph.html">Graph</a>&gt;
+typename property_traits&lt;typename property_map &lt; Graph, edge_capacity_t &gt;::type&gt;::value_type
+find_flow_cost(const Graph &amp; g,
+        const bgl_named_params&lt;P, T, R&gt; &amp; params  = <i>all defaults</i>)
+
+<i>// non-named parameter version</i>
+template&lt;class <a href="./Graph.html">Graph</a>, class Capacity, class ResidualCapacity, class Weight&gt;
+typename property_traits&lt;typename property_map &lt; Graph, edge_capacity_t &gt;::type&gt;::value_type
+find_flow_cost(const Graph &amp; g, Capacity capacity, ResidualCapacity residual_capacity, Weight weight) 
+</PRE>
+
+<P>
+The <tt>find_flow_cost()</tt> function calculates the minimum cost maximum flow value of a network and given flow. See Section <a
+href="./graph_theory_review.html#sec:network-flow-algorithms">Network
+Flow Algorithms</a> for a description of maximum flow.  
+The function  calculates the cost from the flow values <i>f(u,v)</i> for <i>(u,v)</i> in
+<i>E</i>, which are passed in the form of the residual capacity
+<i>r(u,v) = c(u,v) - f(u,v)</i>. 
+
+<p>
+In order to compute the min cost max flow use : 
+<a href="./successive_shortest_path_nonnegative_weights.html"><tt>successive_shortest_path_nonnegative_weights()</tt></a>  or
+<a href="./cycle_canceling.html"><tt>cycle_canceling()</tt></a>.
+
+<H3>Where Defined</H3>
+
+<P>
+<a href="../../../boost/graph/successive_shortest_path_nonnegative_weights.hpp"><TT>boost/graph/successive_shortest_path_nonnegative_weights.hpp</TT></a>
+
+<P>
+
+<h3>Parameters</h3>
+
+IN: <tt>const Graph&amp; g</tt>
+<blockquote>
+  A directed graph. The
+  graph's type must be a model of <a
+  href="./VertexListGraph.html">VertexListGraph</a> and <a href="./IncidenceGraph.html">IncidenceGraph</a> For each edge
+  <i>(u,v)</i> in the graph, the reverse edge <i>(v,u)</i> must also
+  be in the graph.
+</blockquote>
+<h3>Named Parameters</h3>
+
+
+IN: <tt>capacity_map(CapacityEdgeMap cap)</tt>
+<blockquote>
+  The edge capacity property map. The type must be a model of a
+  constant <a
+  href="../../property_map/doc/LvaluePropertyMap.html">Lvalue Property Map</a>. The
+  key type of the map must be the graph's edge descriptor type.<br>
+  <b>Default:</b> <tt>get(edge_capacity, g)</tt>
+</blockquote>
+  
+IN: <tt>residual_capacity_map(ResidualCapacityEdgeMap res)</tt>
+<blockquote>
+  This maps edges to their residual capacity. The type must be a model
+  of a mutable <a
+  href="../../property_map/doc/LvaluePropertyMap.html">Lvalue Property
+  Map</a>. The key type of the map must be the graph's edge descriptor
+  type.<br>
+  <b>Default:</b> <tt>get(edge_residual_capacity, g)</tt>
+</blockquote>
+
+
+IN: <tt>weight_map(WeightMap w_map)</tt>   
+<blockquote>
+  The weight or ``cost'' of each edge in the graph.
+  The type <tt>WeightMap</tt> must be a model of
+  <a href="../../property_map/doc/ReadablePropertyMap.html">Readable Property Map</a>. The edge descriptor type of
+  the graph needs to be usable as the key type for the weight
+  map. The value type for this map must be
+  the same as the value type of the distance map.<br>
+  <b>Default:</b>  <tt>get(edge_weight, g)</tt><br>
+
+</blockquote>
+
+<h3>Complexity</h3>
+The complexity is <i> O(|E|)</i>, 
+
+<h3>Example</h3>
+
+The function is used in the successive_shortest_path_nonnegative_weights example. The program in <a
+href="../example/successive_shortest_path_nonnegative_weights_example.cpp"><tt>example/successive_shortest_path_nonnegative_weights_example.cpp</tt></a>.
+
+<h3>See Also</h3>
+
+<a href="./cycle_canceling.html"><tt>cycle_canceling()</tt></a><br>
+<a href="./successive_shortest_path_nonnegative_weights.html"><tt>successive_shortest_path_nonnegative_weights()</tt></a>.
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2013</TD><TD>
+Piotr Wygocki, University of Warsaw (<A HREF="mailto:wygos@mimuw.edu.pl">wygos at mimuw.edu.pl</A>)
+</TD></TR></TABLE>
+
+</BODY>
+</HTML> 
+<!--  LocalWords:  HTML Siek Edmonds BGCOLOR ffffff ee VLINK ALINK ff IMG SRC
+ -->
+<!--  LocalWords:  gif ALT BR sec edmonds karp TT DIV CELLPADDING TR TD PRE lt
+ -->
+<!--  LocalWords:  typename VertexListGraph CapacityEdgeMap ReverseEdgeMap gt
+ -->
+<!--  LocalWords:  ResidualCapacityEdgeMap VertexIndexMap src rev ColorMap pred
+ -->
+<!--  LocalWords:  PredEdgeMap tt href html hpp ul li nbsp br LvaluePropertyMap
+ -->
+<!--  LocalWords:  num ColorValue DIMACS cpp pre config iostream dimacs int std
+ -->
+<!--  LocalWords:  namespace vecS directedS cout endl iter ei HR valign nowrap
+ -->
+<!--  LocalWords:  jeremy siek htm Univ mailto jsiek lsc edu
+p -->
+
diff --git a/doc/floyd_warshall_shortest.html b/doc/floyd_warshall_shortest.html
index ab407a6c0..7d110a80a 100644
--- a/doc/floyd_warshall_shortest.html
+++ b/doc/floyd_warshall_shortest.html
@@ -134,7 +134,7 @@ <h3>Named Parameters</h3>
 <blockquote>
 The value used to initialize the distance for each vertex before
 starting the algorithm, and to represent the distance between vertices
-for which there is not path.  Should be larger than any possible valid
+for which there is no path.  Should be larger than any possible valid
 path length.  The argument type must match the value type of the <code>
 WeightMap</code>.<br>
 
diff --git a/doc/fruchterman_reingold.html b/doc/fruchterman_reingold.html
index f8a61d6d6..f0ea6bd95 100644
--- a/doc/fruchterman_reingold.html
+++ b/doc/fruchterman_reingold.html
@@ -216,7 +216,7 @@ <h3>Named Parameters</h3>
 <H3>Complexity</H3>
 
 <P> The time complexity is <i>O(|V|<sup>2</sup> + |E|)</i> for each
-iteration of the algorithm in the worse case. The average case for the
+iteration of the algorithm in the worst case. The average case for the
 grid variant is <i>O(|V| + |E|)</i>. The number of iterations is
 determined by the cooling schedule.
 
diff --git a/doc/graph_coloring.html b/doc/graph_coloring.html
index cfeaaef97..1d4dcb77d 100644
--- a/doc/graph_coloring.html
+++ b/doc/graph_coloring.html
@@ -127,7 +127,7 @@ <H1>Graph Coloring</H1>
     const size_type num = num_vertices(G);
     
     typename GraphTraits::vertex_iterator v, vend;
-    for (tie(v, vend) = vertices(G); v != vend; ++v) {
+    for (boost::tie(v, vend) = vertices(G); v != vend; ++v) {
       put(marker, *v, num);
       put(degree, *v, out_degree(*v, G));
       degree_buckets.push(*v);
@@ -152,7 +152,7 @@ <H1>Graph Coloring</H1>
       put(marker, node, 0); //node has been ordered.
       
       typename GraphTraits::adjacency_iterator v, vend;
-      for (tie(v,vend) = adjacent_vertices(node, G); v != vend; ++v)
+      for (boost::tie(v,vend) = adjacent_vertices(node, G); v != vend; ++v)
         
         if ( get(marker, *v) &gt; current_order ) { //*v is unordered vertex
           put(marker, *v, current_order);   //mark the columns adjacent to node
diff --git a/doc/graph_concepts.html b/doc/graph_concepts.html
index b18ce3bb5..9b5b5cd39 100644
--- a/doc/graph_concepts.html
+++ b/doc/graph_concepts.html
@@ -396,7 +396,7 @@ <H2><A NAME="sec:undirected-graphs"></A>
 demonstrates using the <TT>out_edges()</TT>, <TT>source()</TT>, and
 <TT>target()</TT> with an undirected graph. The source code for this
 example and the following one can be found in <a
-href="../example/undirected.cpp"><TT>examples/undirected.cpp</TT></a>.
+href="../example/undirected_adjacency_list.cpp"><TT>example/undirected_adjacency_list.cpp</TT></a>.
 
 <P>
 <PRE>
@@ -408,7 +408,7 @@ <H2><A NAME="sec:undirected-graphs"></A>
   boost::graph_traits&lt;UndirectedGraph&gt;::out_edge_iterator e, e_end;
   boost::graph_traits&lt;UndirectedGraph&gt;::vertex_descriptor 
     s = vertex(0, undigraph);
-  for (tie(e, e_end) = out_edges(s, undigraph); e != e_end; ++e)
+  for (boost::tie(e, e_end) = out_edges(s, undigraph); e != e_end; ++e)
     std::cout &lt;&lt; "(" &lt;&lt; source(*e, undigraph) 
               &lt;&lt; "," &lt;&lt; target(*e, undigraph) &lt;&lt; ")" &lt;&lt; endl;
 </PRE>
@@ -447,8 +447,8 @@ <H2><A NAME="sec:undirected-graphs"></A>
     add_edge(digraph, v, u, Weight(2.4));
     boost::graph_traits&lt;DirectedGraph&gt;::edge_descriptor e1, e2;
     bool found;
-    tie(e1, found) = edge(u, v, digraph);
-    tie(e2, found) = edge(v, u, digraph);
+    boost::tie(e1, found) = edge(u, v, digraph);
+    boost::tie(e2, found) = edge(v, u, digraph);
     std::cout &lt;&lt; "in a directed graph is ";
     std::cout &lt;&lt; "(u,v) == (v,u) ? " &lt;&lt; (e1 == e2) &lt;&lt; std::endl;
 
@@ -464,8 +464,8 @@ <H2><A NAME="sec:undirected-graphs"></A>
     add_edge(undigraph, u, v, Weight(3.1));
     boost::graph_traits&lt;UndirectedGraph&gt;::edge_descriptor e1, e2;
     bool found;
-    tie(e1, found) = edge(u, v, undigraph);
-    tie(e2, found) = edge(v, u, undigraph);
+    boost::tie(e1, found) = edge(u, v, undigraph);
+    boost::tie(e2, found) = edge(v, u, undigraph);
     std::cout &lt;&lt; "in an undirected graph is ";
     std::cout &lt;&lt; "(u,v) == (v,u) ? " &lt;&lt; (e1 == e2) &lt;&lt; std::endl;
 
diff --git a/doc/graph_theory_review.html b/doc/graph_theory_review.html
index e811d2979..33a6d2cd2 100644
--- a/doc/graph_theory_review.html
+++ b/doc/graph_theory_review.html
@@ -552,6 +552,9 @@ <H2><a name="sec:network-flow-algorithms">Network Flow Algorithms</H2>
 The <b><i>maximum flow problem</i></b> is to determine the maximum
 possible value for <i>|f|</i> and the corresponding flow values for
 every vertex pair in the graph.
+<p>
+The <b><i>minimum cost maximum flow problem</i></b> is to determine the maximum flow which minimizes <i> sum<sub>(u,v) in E</sub>
+cost(u,v) * f(u,v) </i>.
 
 <p>
 A flow network is shown in <a href="#fig:max-flow">Figure
diff --git a/doc/grid_graph.html b/doc/grid_graph.html
index bebbd1c27..0a2fea5dd 100644
--- a/doc/grid_graph.html
+++ b/doc/grid_graph.html
@@ -69,7 +69,7 @@ <h3 id="overview">Overview</h3>
     <p>
       Defined in
       <a href="../../../boost/graph/grid_graph.hpp"><tt>boost/graph/grid_graph.hpp</tt></a>
-      with all functions in the <tt>boost</tt> namespace.  All examples are available in a single program file in <a href="../../../libs/graph/example/grid_graph_example.cpp"><tt>libs/graph/example/grid_graph_example.cpp</tt></a>
+      with all functions in the <tt>boost</tt> namespace.  A simple examples of creating and iterating over a grid_graph is available here <a href="../../../libs/graph/example/grid_graph_example.cpp"><tt>libs/graph/example/grid_graph_example.cpp</tt></a>. An example of adding properties to a grid_graph is also available <a href="../../../libs/graph/example/grid_graph_example.cpp"><tt>libs/graph/example/grid_graph_properties.cpp</tt></a>
     </p>
 
     <h4>Template Parameters</h4>
@@ -81,13 +81,13 @@ <h4>Template Parameters</h4>
     </pre>
     <ul>
       <li>
-        <tt>Dimensions</tt> - Number of dimensions in the graph, <b>must be greater than 2</b>
+        <tt>Dimensions</tt> - Number of dimensions in the graph
       </li>
       <li>
-        <tt>VertexIndex</tt> - Type used for vertex indices, defaults to std::size_t
+        <tt>VertexIndex</tt> - Type used for vertex indices, defaults to <tt>std::size_t</tt>
       </li>
       <li>
-        <tt>EdgeIndex</tt> - Type used for edge indices, defaults to the same type as VertexIndex
+        <tt>EdgeIndex</tt> - Type used for edge indices, defaults to the same type as <tt>VertexIndex</tt>
       </li>
     </ul>
 
diff --git a/doc/gursoy_atun_layout.html b/doc/gursoy_atun_layout.html
index 52482a36a..db61443e8 100644
--- a/doc/gursoy_atun_layout.html
+++ b/doc/gursoy_atun_layout.html
@@ -161,7 +161,8 @@ <h3>Parameters</h3>
 IN: <tt>VertexIndexMap vertex_index_map</tt> 
 <blockquote>
   This maps each vertex to an integer in the range <tt>[0,
-    num_vertices(g))</tt>. 
+    num_vertices(g))</tt>. This is only necessary when no
+    displacement map is provided. 
   The type <tt>VertexIndexMap</tt> must be a model of <a
   href="../../property_map/doc/ReadablePropertyMap.html">Readable Property
   Map</a>. The value type of the map must be an integer type. The
@@ -176,9 +177,7 @@ <h3>Parameters</h3>
 
 IN: <tt>EdgeWeightMap weight</tt> 
 <blockquote>
-  This maps each edge to an weight.
-    num_vertices(g))</tt>. This is only necessary when no
-    displacement map is provided. 
+  This maps each edge to a weight.
   The type <tt>EdgeWeightMap</tt> must be a model of <a
   href="../../property_map/doc/ReadablePropertyMap.html">Readable Property
   Map</a>. The value type of the map must be an floating-point type
@@ -221,7 +220,7 @@ <h3>Named Parameters</h3>
 <b>Default:</b> <tt>get(vertex_index, g)</tt>
     Note: if you use this default, make sure your graph has
     an internal <tt>vertex_index</tt> property. For example,
-    <tt>adjacenty_list</tt> with <tt>VertexList=listS</tt> does
+    <tt>adjacency_list</tt> with <tt>VertexList=listS</tt> does
     not have an internal <tt>vertex_index</tt> property.
 </blockquote>
 
diff --git a/doc/hawick_circuits.html b/doc/hawick_circuits.html
new file mode 100644
index 000000000..5fabcf7c5
--- /dev/null
+++ b/doc/hawick_circuits.html
@@ -0,0 +1,58 @@
+<p><body bgcolor="#ffffff" link="#0000ee" text="#000000" vlink="#551a8b" alink="#ff0000"></p>
+
+<p><img src="../../../boost.png" alt="C++ Boost" /></p>
+
+<h1 id="hawick_circuits"><code>hawick_circuits</code></h1>
+
+<pre><code>template &lt;typename Graph, typename Visitor, typename VertexIndexMap&gt;
+void hawick_circuits(Graph const&amp; graph, Visitor visitor, VertexIndexMap const&amp; vim = get(vertex_index, graph));
+
+template &lt;typename Graph, typename Visitor, typename VertexIndexMap&gt;
+void hawick_unique_circuits(Graph const&amp; graph, Visitor visitor, VertexIndexMap const&amp; vim = get(vertex_index, graph));
+</code></pre>
+
+<p>Enumerate all the elementary circuits in a directed multigraph. Specifically,
+self-loops and redundant circuits caused by parallel edges are enumerated too.
+<code>hawick_unique_circuits</code> may be used if redundant circuits caused by parallel
+edges are not desired.</p>
+
+<p>The algorithm is described in detail in
+<a href="http://www.massey.ac.nz/~kahawick/cstn/013/cstn-013.pdf">http://www.massey.ac.nz/~kahawick/cstn/013/cstn-013.pdf</a>.</p>
+
+<h3 id="where-defined">Where defined</h3>
+
+<p><a href="../../../boost/graph/hawick_circuits.hpp"><code>#include &lt;boost/graph/hawick_circuits.hpp&gt;</code></a></p>
+
+<h3 id="parameters">Parameters</h3>
+
+<p><strong>IN:</strong> <code>Graph const&amp; graph</code></p>
+
+<blockquote>
+  <p>The graph on which the algorithm is to be performed. It must be a model of
+  the <code>VertexListGraph</code> and <code>AdjacencyGraph</code> concepts.</p>
+</blockquote>
+
+<p><strong>IN:</strong> <code>Visitor visitor</code></p>
+
+<blockquote>
+  <p>The visitor that will be notified on each circuit found by the algorithm.
+  The <code>visitor.cycle(circuit, graph)</code> expression must be valid, with <code>circuit</code>
+  being a <code>const</code>-reference to a random access sequence of <code>vertex_descriptor</code>s.</p>
+
+  <p>For example, if a circuit <code>u -&gt; v -&gt; w -&gt; u</code> exists in the graph, the
+  visitor will be called with a sequence consisting of <code>(u, v, w)</code>.</p>
+</blockquote>
+
+<p><strong>IN:</strong> <code>VertexIndexMap const&amp; vim = get(vertex_index, graph)</code></p>
+
+<blockquote>
+  <p>A model of the <code>ReadablePropertyMap</code> concept mapping each <code>vertex_descriptor</code>
+  to an integer in the range <code>[0, num_vertices(graph))</code>. It defaults to using
+  the vertex index map provided by the <code>graph</code>.</p>
+</blockquote>
+
+<hr />
+
+<div class="footer">
+    &copy; 2013 Louis Dionne
+</div>
diff --git a/doc/hawick_circuits.md b/doc/hawick_circuits.md
new file mode 100644
index 000000000..828a71b9c
--- /dev/null
+++ b/doc/hawick_circuits.md
@@ -0,0 +1,53 @@
+<body bgcolor="#ffffff" link="#0000ee" text="#000000" vlink="#551a8b" alink="#ff0000">
+
+![C++ Boost](../../../boost.png)
+
+# `hawick_circuits`
+
+    template <typename Graph, typename Visitor, typename VertexIndexMap>
+    void hawick_circuits(Graph const& graph, Visitor visitor, VertexIndexMap const& vim = get(vertex_index, graph));
+
+    template <typename Graph, typename Visitor, typename VertexIndexMap>
+    void hawick_unique_circuits(Graph const& graph, Visitor visitor, VertexIndexMap const& vim = get(vertex_index, graph));
+
+Enumerate all the elementary circuits in a directed multigraph. Specifically,
+self-loops and redundant circuits caused by parallel edges are enumerated too.
+`hawick_unique_circuits` may be used if redundant circuits caused by parallel
+edges are not desired.
+
+The algorithm is described in detail in
+<http://www.massey.ac.nz/~kahawick/cstn/013/cstn-013.pdf>.
+
+
+### Where defined
+
+[`#include <boost/graph/hawick_circuits.hpp>`](../../../boost/graph/hawick_circuits.hpp)
+
+
+### Parameters
+
+__IN:__ `Graph const& graph`
+
+> The graph on which the algorithm is to be performed. It must be a model of
+> the `VertexListGraph` and `AdjacencyGraph` concepts.
+
+__IN:__ `Visitor visitor`
+
+> The visitor that will be notified on each circuit found by the algorithm.
+> The `visitor.cycle(circuit, graph)` expression must be valid, with `circuit`
+> being a `const`-reference to a random access sequence of `vertex_descriptor`s.
+>
+> For example, if a circuit `u -> v -> w -> u` exists in the graph, the
+> visitor will be called with a sequence consisting of `(u, v, w)`.
+
+__IN:__ `VertexIndexMap const& vim = get(vertex_index, graph)`
+
+> A model of the `ReadablePropertyMap` concept mapping each `vertex_descriptor`
+> to an integer in the range `[0, num_vertices(graph))`. It defaults to using
+> the vertex index map provided by the `graph`.
+
+
+------------------------------------------------------------------------------
+<div class="footer">
+    &copy; 2013 Louis Dionne
+</div>
diff --git a/doc/incident.html b/doc/incident.html
index e75f336c9..703e17f74 100644
--- a/doc/incident.html
+++ b/doc/incident.html
@@ -57,7 +57,7 @@ <h3>Example</h3>
   edge_descriptor e;
   vertex_descriptor u, v;
   ...
-  tie(u, v) = incident(e, g);
+  boost::tie(u, v) = incident(e, g);
 </pre>
 
 
diff --git a/doc/isomorphism-impl-v2.w b/doc/isomorphism-impl-v2.w
index 75f88b2bd..602db7ee2 100644
--- a/doc/isomorphism-impl-v2.w
+++ b/doc/isomorphism-impl-v2.w
@@ -388,31 +388,31 @@ unsigned integers.
 @d Concept checking
 @{
 // Graph requirements
-function_requires< VertexListGraphConcept<Graph1> >();
-function_requires< EdgeListGraphConcept<Graph1> >();
-function_requires< VertexListGraphConcept<Graph2> >();
-function_requires< BidirectionalGraphConcept<Graph2> >();
+BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph1> ));
+BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph1> ));
+BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph2> ));
+BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph2> ));
 
 typedef typename graph_traits<Graph1>::vertex_descriptor vertex1_t;
 typedef typename graph_traits<Graph2>::vertex_descriptor vertex2_t;
 typedef typename graph_traits<Graph1>::vertices_size_type size_type;
 
 // Vertex invariant requirement
-function_requires< AdaptableUnaryFunctionConcept<Invariant1,
-  size_type, vertex1_t> >();
-function_requires< AdaptableUnaryFunctionConcept<Invariant2,
-  size_type, vertex2_t> >();
+BOOST_CONCEPT_ASSERT(( AdaptableUnaryFunctionConcept<Invariant1,
+  size_type, vertex1_t> ));
+BOOST_CONCEPT_ASSERT(( AdaptableUnaryFunctionConcept<Invariant2,
+  size_type, vertex2_t> ));
 
 // Property map requirements
-function_requires< ReadWritePropertyMapConcept<IsoMapping, vertex1_t> >();
+BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<IsoMapping, vertex1_t> ));
 typedef typename property_traits<IsoMapping>::value_type IsoMappingValue;
 BOOST_STATIC_ASSERT((is_same<IsoMappingValue, vertex2_t>::value));
 
-function_requires< ReadablePropertyMapConcept<IndexMap1, vertex1_t> >();
+BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<IndexMap1, vertex1_t> ));
 typedef typename property_traits<IndexMap1>::value_type IndexMap1Value;
 BOOST_STATIC_ASSERT((is_convertible<IndexMap1Value, size_type>::value));
 
-function_requires< ReadablePropertyMapConcept<IndexMap2, vertex2_t> >();
+BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<IndexMap2, vertex2_t> ));
 typedef typename property_traits<IndexMap2>::value_type IndexMap2Value;
 BOOST_STATIC_ASSERT((is_convertible<IndexMap2Value, size_type>::value));
 @}
diff --git a/doc/isomorphism-impl-v3.w b/doc/isomorphism-impl-v3.w
index 4ce875176..6e35e8e7e 100644
--- a/doc/isomorphism-impl-v3.w
+++ b/doc/isomorphism-impl-v3.w
@@ -507,31 +507,31 @@ unsigned integers.
 @d Concept checking
 @{
 // Graph requirements
-function_requires< VertexListGraphConcept<Graph1> >();
-function_requires< EdgeListGraphConcept<Graph1> >();
-function_requires< VertexListGraphConcept<Graph2> >();
-function_requires< BidirectionalGraphConcept<Graph2> >();
+BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph1> ));
+BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph1> ));
+BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph2> ));
+BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph2> ));
 
 typedef typename graph_traits<Graph1>::vertex_descriptor vertex1_t;
 typedef typename graph_traits<Graph2>::vertex_descriptor vertex2_t;
 typedef typename graph_traits<Graph1>::vertices_size_type size_type;
 
 // Vertex invariant requirement
-function_requires< AdaptableUnaryFunctionConcept<Invariant1,
-  size_type, vertex1_t> >();
-function_requires< AdaptableUnaryFunctionConcept<Invariant2,
-  size_type, vertex2_t> >();
+BOOST_CONCEPT_ASSERT(( AdaptableUnaryFunctionConcept<Invariant1,
+  size_type, vertex1_t> ));
+BOOST_CONCEPT_ASSERT(( AdaptableUnaryFunctionConcept<Invariant2,
+  size_type, vertex2_t> ));
 
 // Property map requirements
-function_requires< ReadWritePropertyMapConcept<IsoMapping, vertex1_t> >();
+BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<IsoMapping, vertex1_t> ));
 typedef typename property_traits<IsoMapping>::value_type IsoMappingValue;
 BOOST_STATIC_ASSERT((is_same<IsoMappingValue, vertex2_t>::value));
 
-function_requires< ReadablePropertyMapConcept<IndexMap1, vertex1_t> >();
+BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<IndexMap1, vertex1_t> ));
 typedef typename property_traits<IndexMap1>::value_type IndexMap1Value;
 BOOST_STATIC_ASSERT((is_convertible<IndexMap1Value, size_type>::value));
 
-function_requires< ReadablePropertyMapConcept<IndexMap2, vertex2_t> >();
+BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<IndexMap2, vertex2_t> ));
 typedef typename property_traits<IndexMap2>::value_type IndexMap2Value;
 BOOST_STATIC_ASSERT((is_convertible<IndexMap2Value, size_type>::value));
 @}
diff --git a/doc/isomorphism-impl.w b/doc/isomorphism-impl.w
index 58b4bed89..e881a9461 100644
--- a/doc/isomorphism-impl.w
+++ b/doc/isomorphism-impl.w
@@ -174,7 +174,7 @@ need to consider those vertices that have the same vertex invariant
 number. The number of vertices in a graph with the same vertex
 invariant number $i$ is called the \emph{invariant multiplicity} for
 $i$.  In this implementation, by default we use the out-degree of the
-vertex as the vertex invariant, though the user can also supply there
+vertex as the vertex invariant, though the user can also supply their
 own invariant function. The ability of the invariant function to prune
 the search space varies widely with the type of graph.
 
@@ -301,21 +301,21 @@ unsigned integers.
 @d Concept checking
 @{
 // Graph requirements
-function_requires< VertexListGraphConcept<Graph1> >();
-function_requires< EdgeListGraphConcept<Graph1> >();
-function_requires< VertexListGraphConcept<Graph2> >();
-function_requires< BidirectionalGraphConcept<Graph2> >();
+BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph1> ));
+BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph1> ));
+BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph2> ));
+BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph2> ));
 
 // Property map requirements
-function_requires< ReadWritePropertyMapConcept<IndexMapping, vertex1_t> >();
+BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<IndexMapping, vertex1_t> ));
 typedef typename property_traits<IndexMapping>::value_type IndexMappingValue;
 BOOST_STATIC_ASSERT((is_same<IndexMappingValue, vertex2_t>::value));
 
-function_requires< ReadablePropertyMapConcept<IndexMap1, vertex1_t> >();
+BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<IndexMap1, vertex1_t> ));
 typedef typename property_traits<IndexMap1>::value_type IndexMap1Value;
 BOOST_STATIC_ASSERT((is_convertible<IndexMap1Value, size_type>::value));
 
-function_requires< ReadablePropertyMapConcept<IndexMap2, vertex2_t> >();
+BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<IndexMap2, vertex2_t> ));
 typedef typename property_traits<IndexMap2>::value_type IndexMap2Value;
 BOOST_STATIC_ASSERT((is_convertible<IndexMap2Value, size_type>::value));
 @}
diff --git a/doc/isomorphism.html b/doc/isomorphism.html
index 2738280aa..3b86077b1 100644
--- a/doc/isomorphism.html
+++ b/doc/isomorphism.html
@@ -59,7 +59,7 @@ <H1>
 algorithm in [<a
 href="./bibliography.html#fortin96:_graph_iso_prob">46</a>,<a
 href="./bibliography.html#reingold77:_combin_algo">48</a>].  The file
-<a href="./isomorphism-impl.pdf">isomorphism-impl.pdf</a> contains a
+<a href="./isomorphism-impl.pdf">isomorphism-impl.pdf</a> contains a (somewhat out-of-date)
 &quot;literate&quot; description of the implementation.  The algorithm
 used is simple but slow. A more efficient (and much more complex)
 algorithm is described in [<a
@@ -101,31 +101,24 @@ <h3>Named Parameters</h3>
 <b>Python</b>: Must be a <tt>vertex_vertex_map</tt> for the first graph.
 </blockquote>
 
-IN: <tt>vertex_invariant1(VertexInvariant1 i)</tt>
+IN: <tt>vertex_invariant1(VertexInvariant1 i1)</tt>
+IN: <tt>vertex_invariant2(VertexInvariant2 i2)</tt>
 <blockquote>
-A mapping <i>i</i> from vertices to integers such that if there is
-some isomorphism that maps <i>v</i> onto <i>v'</i> then <i>i(v) ==
-i(v')</i>. The <tt>VertexInvariant</tt> type must be a <a
-href="http://www.sgi.com/tech/stl/BinaryFunction.html">BinaryFunction</a>
-where the first argument is a vertex descriptor, the second argument is a
-graph, and the result type is an integer. The vertex invariant must
-work with the types for graph 1.
+Mappings from vertices to integers which restrict which vertices may be
+considered isomorphic. If a candidate isomorphism maps <i>v1</i> to <i>v2</i>
+but <i>i1</i>(<i>v1</i>) != <i>i2</i>(<i>v2</i>), that candidate is rejected.
+This mapping can be used either to speed up the search (as is done by the
+default value, which requires that the degrees of <i>v1</i> and <i>v2</i> are
+equal) or to impose extra conditions on the result.  The
+<tt>VertexInvariant1</tt> and <tt>VertexInvariant2</tt> types must model <a
+href="http://www.sgi.com/tech/stl/UnaryFunction.html">UnaryFunction</a>, with
+the argument type of <tt>vertex_invariant1</tt> being <tt>Graph1</tt>'s vertex
+descriptor type, the argument type of <tt>vertex_invariant2</tt> being
+<tt>Graph2</tt>'s vertex descriptor type, and both functions having integral
+result types.  The values returned by these two functions must be in the range
+[0, <tt>vertex_max_invariant</tt>).
 <br>
-<b>Default:</b> <tt>degree_vertex_invariant</tt><br>
-<b>Python</b>: Unsupported parameter.
-</blockquote>
-
-IN: <tt>vertex_invariant2(VertexInvariant2 i)</tt>
-<blockquote>
-A mapping <i>i</i> from vertices to integers such that if there is
-some isomorphism that maps <i>v</i> onto <i>v'</i> then <i>i(v) ==
-i(v')</i>. The <tt>VertexInvariant</tt> type must be a <a
-href="http://www.sgi.com/tech/stl/BinaryFunction.html">BinaryFunction</a>
-where the first argument is a vertex descriptor, the second argument is a
-graph, and the result type is an integer. The vertex invariant must
-work with the types for both graph 2.
-<br>
-<b>Default:</b> <tt>degree_vertex_invariant</tt><br>
+<b>Default:</b> <tt>degree_vertex_invariant</tt> for both arguments<br>
 <b>Python</b>: Unsupported parameter.
 </blockquote>
 
diff --git a/doc/johnson_all_pairs_shortest.html b/doc/johnson_all_pairs_shortest.html
index 8e95b05a3..716bf5761 100644
--- a/doc/johnson_all_pairs_shortest.html
+++ b/doc/johnson_all_pairs_shortest.html
@@ -15,7 +15,7 @@
 
 <BR Clear>
 
-<H1><A NAME="sec:johnson">
+<H1><A NAME="sec:johnson"></A>
 <TT>johnson_all_pairs_shortest_paths</TT>
 </H1>
 
@@ -75,10 +75,12 @@ <h3>Parameters</h3>
 OUT: <tt>DistanceMatrix&amp; D</tt>
 <blockquote>
 The length of the shortest path between each pair of vertices
-<i>u,v</i> in the graph is stored in <tt>D[u][v]</tt>. The set of
-types {<tt>DistanceMatrix, vertices_size_type, D</tt>} must be a model
+<i>u,v</i> in the graph is stored in <tt>D[u][v]</tt>. The tuple of
+types (<tt>DistanceMatrix, vertices_size_type, D</tt>) must be a model
 of <a href="BasicMatrix.html">BasicMatrix</a> where <tt>D</tt> is the
-value type of the <tt>DistanceMap</tt>.
+value type of the <tt>DistanceMap</tt>.  There must be implicit conversions
+between the value type of the distance matrix and the value type of the weight
+map.
 </blockquote>
 
 
@@ -86,12 +88,11 @@ <h3>Named Parameters</h3>
 
 IN: <tt>weight_map(WeightMap w_map)</tt>   
 <blockquote>
-  The weight or ``length'' of each edge in the graph.
+  The weight or "length" of each edge in the graph.
   The type <tt>WeightMap</tt> must be a model of
   <a href="../../property_map/doc/ReadablePropertyMap.html">Readable Property Map</a>. The edge descriptor type of
   the graph needs to be usable as the key type for the weight
-  map. The value type for the map must be
-  <i>Addable</i> with the value type of the distance map.<br>
+  map.  The value type of the weight map must support a subtraction operation.<br>
   <b>Default:</b>  <tt>get(edge_weight, g)</tt>
 </blockquote>
 
@@ -112,7 +113,7 @@ <h3>Named Parameters</h3>
   <b>Default:</b> <tt>get(vertex_index, g)</tt>
     Note: if you use this default, make sure your graph has
     an internal <tt>vertex_index</tt> property. For example,
-    <tt>adjacenty_list</tt> with <tt>VertexList=listS</tt> does
+    <tt>adjacency_list</tt> with <tt>VertexList=listS</tt> does
     not have an internal <tt>vertex_index</tt> property.
    <br>
 </blockquote>
@@ -128,7 +129,8 @@ <h3>Named Parameters</h3>
   This function is use to compare distances to determine
   which vertex is closer to the source vertex.
   The <tt>CompareFunction</tt> type must be a model of
-  \stlconcept{BinaryPredicate} and have argument types that
+  <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">Binary Predicate</a>
+  and have argument types that
   match the value type of the <tt>WeightMap</tt> property map.<br>
   <b>Default:</b> <tt>std::less&lt;DT&gt;</tt> with
   <tt>DT=typename&nbsp;property_traits&lt;WeightMap&gt;::value_type</tt>
@@ -139,11 +141,8 @@ <h3>Named Parameters</h3>
   This function is used to combine distances to compute the distance
   of a path. The <tt>CombineFunction</tt> type must be a model of <a
   href="http://www.sgi.com/tech/stl/BinaryFunction.html">Binary
-  Function</a>. The first argument type of the binary function must
-  match the value type of the <tt>DistanceMap</tt> property map and
-  the second argument type must match the value type of the
-  <tt>WeightMap</tt> property map.  The result type must be the same
-  type as the distance value type.<br>
+  Function</a>. Both argument types and the return type of the binary function
+  must match the value type of the <tt>WeightMap</tt> property map.  This operation is required to act as the sum operation for the weight type; in particular, it must be the inverse of the binary <tt>-</tt> operator on that type.<br>
   <b>Default:</b> <tt>std::plus&lt;DT&gt;</tt> with
    <tt>DT=typename&nbsp;property_traits&lt;WeightMap&gt;::value_type</tt>
 </blockquote>
@@ -152,7 +151,7 @@ <h3>Named Parameters</h3>
 <blockquote>
   This value is used to initialize the distance for each
   vertex before the start of the algorithm. 
-  The type <tt>DT</tt> must be the value type of the <tt>WeigthMap</tt>.<br>
+  The type <tt>DT</tt> must be the value type of the <tt>WeightMap</tt>.<br>
   <b>Default:</b> <tt>std::numeric_limits::max()</tt>
 </blockquote>
 
@@ -160,7 +159,7 @@ <h3>Named Parameters</h3>
 <blockquote>
   This value is used to initialize the distance for the source
   vertex before the start of the algorithm.  The type <tt>DT</tt>
-  must be the value type of the <tt>WeigthMap</tt>.<br>
+  must be the value type of the <tt>WeightMap</tt>.<br>
   <b>Default:</b> <tt>0</tt>
 </blockquote>
 
diff --git a/doc/kevin_bacon.html b/doc/kevin_bacon.html
index 8b2670bdf..6648da7f0 100644
--- a/doc/kevin_bacon.html
+++ b/doc/kevin_bacon.html
@@ -156,7 +156,7 @@ <H2>Input File and Graph Setup</H2>
   tokenizer&lt;&gt;::iterator i = line_toks.begin();
   std::string actors_name = *i++;
 
-  tie(pos, inserted) = actors.insert(std::make_pair(actors_name, Vertex()));
+  boost::tie(pos, inserted) = actors.insert(std::make_pair(actors_name, Vertex()));
   if (inserted) {
     u = add_vertex(g);
     actor_name[u] = actors_name;
@@ -174,7 +174,7 @@ <H2>Input File and Graph Setup</H2>
 <PRE>
   std::string movie_name = *i++;
       
-  tie(pos, inserted) = actors.insert(std::make_pair(*i, Vertex()));
+  boost::tie(pos, inserted) = actors.insert(std::make_pair(*i, Vertex()));
   if (inserted) {
     v = add_vertex(g);
     actor_name[v] = *i;
@@ -190,7 +190,7 @@ <H2>Input File and Graph Setup</H2>
 <P>
 <PRE>
   graph_traits&lt;Graph&gt;::edge_descriptor e;
-  tie(e, inserted) = add_edge(u, v, g);
+  boost::tie(e, inserted) = add_edge(u, v, g);
   if (inserted)
     connecting_movie[e] = movie_name;
 </PRE>
diff --git a/doc/kolmogorov_max_flow.html b/doc/kolmogorov_max_flow.html
deleted file mode 100644
index fad874527..000000000
--- a/doc/kolmogorov_max_flow.html
+++ /dev/null
@@ -1,407 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
-<HTML>
-<HEAD>
-	<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=iso-8859-15">
-	<TITLE>Boost Graph Library: Boykov-Kolmogorov Maximum Flow</TITLE>
-	<META NAME="GENERATOR" CONTENT="OpenOffice.org 2.0  (Linux)">
-	<META NAME="CREATED" CONTENT="20060820;17315200">
-	<META NAME="CHANGEDBY" CONTENT="Stephan Diederich">
-	<META NAME="CHANGED" CONTENT="20060820;23125100">
-<!--
-//  Copyright (c) 2006, Stephan Diederich
-//
-//  This documentation may be used under either of the following two licences:
-//
-//    Permission is hereby granted, free of charge, to any person
-//    obtaining a copy of this software and associated documentation
-//    files (the "Software"), to deal in the Software without
-//    restriction, including without limitation the rights to use,
-//    copy, modify, merge, publish, distribute, sublicense, and/or
-//    sell copies of the Software, and to permit persons to whom the
-//    Software is furnished to do so, subject to the following
-//    conditions:
-//
-//    The above copyright notice and this permission notice shall be
-//    included in all copies or substantial portions of the Software.
-//
-//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-//    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-//    OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-//    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-//    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-//    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-//    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-//    OTHER DEALINGS IN THE SOFTWARE. OF SUCH DAMAGE.
-//
-//  Or:
-//
-//    Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//    http://www.boost.org/LICENSE_1_0.txt)
- -->
-	<STYLE>
-	<!--
-		TD P { color: #000000 }
-		H1 { color: #000000 }
-		P { color: #000000 }
-		PRE { color: #000000 }
-		H3 { color: #000000 }
-		BLOCKQUOTE { color: #000000 }
-		A:link { color: #0000ee }
-		A:visited { color: #551a8b }
-	-->
-	</STYLE>
-</HEAD>
-<BODY LANG="de-DE" TEXT="#000000" LINK="#0000ee" VLINK="#551a8b" BGCOLOR="#ffffff" DIR="LTR">
-
-<P>
-<IMG SRC="../../../boost.png" NAME="Grafik1" ALT="C++ Boost" ALIGN=BOTTOM WIDTH=277 HEIGHT=86 BORDER=0>
-</P>
-
-<table align="center" width="75%" style="border:1px solid; border-spacing: 10pt">
-<tr>
-  <td style="vertical-align: top"><img src="figs/warning.png"></td>
-  <td>
-    <b>Warning!</b> This header and its contents are <em>deprecated</em> and
-    will be removed in a future release. Please update your program to use
-    <a href="boykov_kolmogorov_max_flow.html"> <tt>boykov_kolmogorov_max_flow</tt></a>
-    instead. Note that only the name of the algorithm has changed. The template
-    and function parameters will remain the same.
-  </td>
-</tr>
-</table>
-
-
-<H1><A NAME="sec:kolmogorov_max_flow"></A><TT>kolmogorov_max_flow</TT>
-</H1>
-<PRE><I>// named parameter version</I>
-template &lt;class Graph, class P, class T, class R&gt;
-typename property_traits&lt;typename property_map&lt;Graph, edge_capacity_t&gt;::const_type&gt;::value_type
-kolmogorov_max_flow(Graph&amp; g,
-   typename graph_traits&lt;Graph&gt;::vertex_descriptor src,
-   typename graph_traits&lt;Graph&gt;::vertex_descriptor sink,
-   const bgl_named_params&lt;P, T, R&gt;&amp; params = <I>all defaults</I>)
-
-<I>// non-named parameter version</I>
-template &lt;class Graph, class CapacityEdgeMap, class ResidualCapacityEdgeMap, class ReverseEdgeMap,
-          class PredecessorMap, class ColorMap, class DistanceMap, class IndexMap&gt;
-typename property_traits&lt;CapacityEdgeMap&gt;::value_type
-kolmogorov_max_flow(Graph&amp; g,
-       CapacityEdgeMap cap,
-       ResidualCapacityEdgeMap res_cap,
-       ReverseEdgeMap rev_map,
-       PredecessorMap pre_map,
-       ColorMap color,
-       DistanceMap dist,
-       IndexMap idx,
-       typename graph_traits &lt;Graph&gt;::vertex_descriptor src,
-       typename graph_traits &lt;Graph &gt;::vertex_descriptor sink)</PRE><P>
-<FONT SIZE=3>Additional overloaded versions for non-named parameters
-are provided (without DistanceMap/ColorMap/DistanceMap; for those
-iterator_property_maps with the provided index map are used)</FONT></P>
-<P>The <TT>kolmogorov_max_flow()</TT> function calculates the maximum
-flow of a network. See Section <A HREF="graph_theory_review.html#sec:network-flow-algorithms">Network
-Flow Algorithms</A> for a description of maximum flow. The calculated
-maximum flow will be the return value of the function. The function
-also calculates the flow values <I>f(u,v)</I> for all <I>(u,v)</I> in
-<I>E</I>, which are returned in the form of the residual capacity
-<I>r(u,v) = c(u,v) - f(u,v)</I>.
-</P>
-<P><B>Requirements:</B><BR>The directed graph <I>G=(V,E)</I> that
-represents the network must include a reverse edge for every edge in
-<I>E</I>. That is, the input graph should be <I>G<SUB>in</SUB> =
-(V,{E U E<SUP>T</SUP>})</I>. The <TT>ReverseEdgeMap</TT> argument <TT>rev</TT>
-must map each edge in the original graph to its reverse edge, that is
-<I>(u,v) -&gt; (v,u)</I> for all <I>(u,v)</I> in <I>E</I>.
-</P>
-<P>Remarks: While the push-relabel method states that each edge in <I>E<SUP>T</SUP></I>
-has to have capacity of 0, the reverse edges for this algorithm ARE
-allowed to carry capacities. If there are already reverse edges in
-the input Graph <I><FONT FACE="Courier New, monospace">G</FONT></I>,
-those can be used. This can halve the amount of edges and will
-noticeably increase the performance.<BR><BR><B>Algorithm
-description:</B><BR>Kolmogorov's algorithm is a variety of the
-augmenting-path algorithm. Standard augmenting path algorithms find
-shortest paths from source to sink vertex and augment them by
-substracting the bottleneck capacity found on that path from the
-residual capacities of each edge and adding it to the total flow.
-Additionally the minimum capacity is added to the residual capacity
-of the reverse edges. If no more paths in the residual-edge tree are
-found, the algorithm terminates. Instead of finding a new shortest
-path from source to sink in the graph in each iteration, Kolmogorov's
-version keeps the already found paths as follows:</P>
-<P>The algorithm builds up two search trees, a source-tree and a
-sink-tree. Each vertex has a label (stored in <I>ColorMap</I>) to
-which tree it belongs and a status-flag if this vertex is active or
-passive. In the beginning of the algorithm only the source and the
-sink are colored (source==black, sink==white) and have active status.
-All other vertices are colored gray. The algorithm consists of three
-phases:</P>
-<P><I>grow-phase</I>: In this phase active vertices are allowed to
-acquire neighbor vertices that are connected through an edge that has
-a capacity-value greater than zero. Acquiring means that those vertices
-become active and belong now to the search tree of the current
-active vertex. If there are no more valid connections to neighbor
-vertices, the current vertex becomes passive and the grow phase
-continues with the next active vertex. The grow phase terminates if
-there are no more active vertices left or a vertex discovers a vertex
-from the other search tree through an unsaturated edge. In this case
-a path from source to sink is found.</P>
-<P><I>augment-phase</I>: This phase augments the path that was found
-in the grow phase. First it finds the bottleneck capacity of the
-found path, and then it updates the residual-capacity of the edges
-from this path by substracting the bottleneck capacity from the
-residual capacity. Furthermore the residual capacity of the reverse
-edges are updated by adding the bottleneck capacity. This phase can
-destroy the built up search trees, as it creates at least one
-saturated edge. That means, that the search trees collapse to
-forests, because a condition for the search trees is, that each
-vertex in them has a valid (=non-saturated) connection to a terminal.</P>
-<P><I>adoption-phase</I>: Here the search trees are reconstructed. A
-simple solution would be to mark all vertices coming after the first
-orphan in the found path free vertices (gray). A more sophisticated
-solution is to give those orphans new parents: The neighbor vertices
-are checked if they have a valid connection to the same terminal like
-this vertex had (a path with unsaturated edges). If there is one,
-this vertex becomes the new parent of the current orphan and this
-forest is re-included into the search tree. If no new valid parent is
-found, this vertex becomes a free vertex (marked gray), and it's
-children become orphans. The adoption phase terminates if there are
-no more orphans.</P>
-<P><IMG SRC="figs/kolmogorov_max_flow.gif" NAME="Grafik2" ALIGN=LEFT WIDTH=827 HEIGHT=311 BORDER=0><BR CLEAR=LEFT><B>Details:</B></P>
-<UL>
-	<LI><P>Marking heuristics: A timestamp is stored for each vertex
-	which shows in which iteration of the algorithm the distance to the
-	corresponding terminal was calculated.
-	</P>
-	<UL>
-		<LI><P>This distance is used and gets calculated in the
-		adoption-phase. In order to find a valid new parent for an orphan,
-		the possible parent is checked for a connection to the terminal to
-		which tree it belongs. If there is such a connection, the path is
-		tagged with the current time-stamp, and the distance value. If
-		another orphan has to find a parent and it comes across a vertex
-		with a current timestamp, this information is used.</P>
-		<LI><P>The distance is also used in the grow-phase. If a vertex
-		comes across another vertex of the same tree while searching for
-		new vertices, the other's distance is compared to its distance. If
-		it is smaller, that other vertex becomes the new parent of the
-		current. This can decrease the length of the search paths, and so
-		amount of adoptions.</P>
-	</UL>
-	<LI><P>Ordering of orphans: As described above, the augment-phase
-	and the adoption phase can create orphans. The orphans the
-	augment-phase generates, are ordered according to their distance to
-	the terminals (smallest first). This combined with the
-	distance/timestamp heuristics results in the possibility for not
-	having to recheck terminal-connections too often. New orphans which
-	are generated in adoption phase are processed before orphans from
-	the main queue for the same reason.</P>
-</UL>
-<P><BR><B>Implementation notes:</B></P>
-<P>The algorithm is mainly implemented as described in the PhD thesis
-of Kolmogorov. Few changes were made for increasing performance:</P>
-<UL>
-	<LI><P>initialization: the algorithm first augments all paths from
-	source-&gt;sink and all paths from source-&gt;VERTEX-&gt;sink. This
-	improves especially graph-cuts used in image vision where nearly
-	each vertex has a source and sink connect. During this step, all
-	vertices that have an unsaturated connection from source are added
-	to the active vertex list and so the source is not.
-	</P>
-	<LI><P>active vertices: Kolmogorov uses two lists for active nodes
-	and states that new active vertices are added to the rear of the
-	second. Fetching an active vertex is done from the beginning of the
-	first list. If the first list is empty, it is exchanged by the
-	second. This implementation uses just one list.</P>
-	<LI><P>grow-phase: In the grow phase the first vertex in the
-	active-list is taken and all outgoing edges are checked if they are
-	unsaturated. This decreases performance for graphs with high-edge
-	density. This implementation stores the last accessed edge and
-	continues with it, if the first vertex in the active-list is the
-	same one as during the last grow-phase.</P>
-</UL>
-<P>This algorithm [<A HREF="bibliography.html#kolmogorov03">68</a>, <a href="bibliography.html#boykov-kolmogorov04">69</a>] was developed by Boykov and Kolmogorov.
-</P>
-<H3>Where Defined</H3>
-<P><TT><A HREF="../../../boost/graph/kolmogorov_max_flow.hpp">boost/graph/kolmogorov_max_flow.hpp</A></TT>
-</P>
-<H3>Parameters</H3>
-<P>IN: <TT>Graph&amp; g</TT>
-</P>
-<BLOCKQUOTE>A directed graph. The graph's type must be a model of
-<A HREF="VertexListGraph.html">Vertex List Graph</A>, <A HREF="EdgeListGraph.html">Edge
-List Graph</A> and <A HREF="IncidenceGraph.html">Incidence Graph</A>.
-For each edge <I>(u,v)</I> in the graph, the reverse edge <I>(v,u)</I>
-must also be in the graph.  Performance of the algorithm will be slightly
-improved if the graph type also models <a href="AdjacencyMatrix.html">Adjacency
-Matrix</a>.
-</BLOCKQUOTE>
-<P>IN: <TT>vertex_descriptor src</TT>
-</P>
-<BLOCKQUOTE>The source vertex for the flow network graph.
-</BLOCKQUOTE>
-<P>IN: <TT>vertex_descriptor sink</TT>
-</P>
-<BLOCKQUOTE>The sink vertex for the flow network graph.
-</BLOCKQUOTE>
-<H3>Named Parameters</H3>
-<P>IN: <TT>edge_capacity(EdgeCapacityMap cap)</TT>
-</P>
-<BLOCKQUOTE>The edge capacity property map. The type must be a model
-of a constant <A HREF="../../property_map/doc/LvaluePropertyMap.html">Lvalue
-Property Map</A>. The key type of the map must be the graph's edge
-descriptor type.<BR><B>Default:</B> <TT>get(edge_capacity, g)</TT>
-</BLOCKQUOTE>
-<P>OUT: <TT>edge_residual_capacity(ResidualCapacityEdgeMap res)</TT>
-</P>
-<BLOCKQUOTE>The edge residual capacity property map. The type must be
-a model of a mutable <A HREF="../../property_map/doc/LvaluePropertyMap.html">Lvalue
-Property Map</A>. The key type of the map must be the graph's edge
-descriptor type.<BR><B>Default:</B> <TT>get(edge_residual_capacity,
-g)</TT>
-</BLOCKQUOTE>
-<P>IN: <TT>edge_reverse(ReverseEdgeMap rev)</TT>
-</P>
-<BLOCKQUOTE>An edge property map that maps every edge <I>(u,v)</I> in
-the graph to the reverse edge <I>(v,u)</I>. The map must be a model
-of constant <A HREF="../../property_map/doc/LvaluePropertyMap.html">Lvalue
-Property Map</A>. The key type of the map must be the graph's edge
-descriptor type.<BR><B>Default:</B> <TT>get(edge_reverse, g)</TT>
-</BLOCKQUOTE>
-<P>UTIL: <TT>vertex_predecessor(PredecessorMap pre_map)</TT>
-</P>
-<BLOCKQUOTE>A vertex property map that stores the edge to the vertex'
-predecessor. The map must be a model of mutable <A HREF="../../property_map/doc/LvaluePropertyMap.html">Lvalue
-Property Map</A>. The key type of the map must be the graph's vertex
-descriptor type.<BR><B>Default:</B> <TT>get(vertex_predecessor, g)</TT>
-</BLOCKQUOTE>
-<P>OUT/UTIL: <TT>vertex_color(ColorMap color)</TT>
-</P>
-<BLOCKQUOTE>A vertex property map that stores a color for edge
-vertex. If the color of a vertex after running the algorithm is black
-the vertex belongs to the source tree else it belongs to the
-sink-tree (used for minimum cuts). The map must be a model of mutable
-<A HREF="../../property_map/doc/LvaluePropertyMap.html">Lvalue Property
-Map</A>. The key type of the map must be the graph's vertex
-descriptor type.<BR><B>Default:</B> <TT>get(vertex_color, g)</TT>
-</BLOCKQUOTE>
-<P>UTIL: <TT>vertex_distance(DistanceMap dist)</TT>
-</P>
-<BLOCKQUOTE>A vertex property map that stores the distance to the
-corresponding terminal. It's a utility-map for speeding up the
-algorithm. The map must be a model of mutable <A HREF="../../property_map/doc/LvaluePropertyMap.html">Lvalue
-Property Map</A>. The key type of the map must be the graph's vertex
-descriptor type.<BR><B>Default:</B> <TT>get(vertex_distance, g)</TT>
-</BLOCKQUOTE>
-<P>IN: <TT>vertex_index(VertexIndexMap index_map)</TT>
-</P>
-<BLOCKQUOTE>Maps each vertex of the graph to a unique integer in the
-range <TT>[0, num_vertices(g))</TT>. The map must be a model of
-constant <A HREF="../../property_map/doc/LvaluePropertyMap.html">LvaluePropertyMap</A>.
-The key type of the map must be the graph's vertex descriptor
-type.<BR><B>Default:</B> <TT>get(vertex_index, g)</TT>
-</BLOCKQUOTE>
-<H3>Example</H3>
-<P>This reads an example maximum flow problem (a graph with edge
-capacities) from a file in the DIMACS format (<TT><A HREF="../example/max_flow.dat">example/max_flow.dat</A></TT>).
-The source for this example can be found in
-<TT><A HREF="../example/boykov_kolmogorov-eg.cpp">example/boykov_kolmogorov-eg.cpp</A></TT>.
-</P>
-<PRE>#include &lt;boost/config.hpp&gt;
-#include &lt;iostream&gt;
-#include &lt;string&gt;
-#include &lt;boost/graph/kolmogorov_max_flow.hpp&gt;
-#include &lt;boost/graph/adjacency_list.hpp&gt;
-#include &lt;boost/graph/read_dimacs.hpp&gt;
-#include &lt;boost/graph/graph_utility.hpp&gt;
-
-int
-main()
-{
-  using namespace boost;
-
-  typedef adjacency_list_traits &lt; vecS, vecS, directedS &gt; Traits;
-  typedef adjacency_list &lt; vecS, vecS, directedS,
-    property &lt; vertex_name_t, std::string,
-    property &lt; vertex_index_t, long,
-    property &lt; vertex_color_t, boost::default_color_type,
-    property &lt; vertex_distance_t, long,
-    property &lt; vertex_predecessor_t, Traits::edge_descriptor &gt; &gt; &gt; &gt; &gt;,
-
-    property &lt; edge_capacity_t, long,
-    property &lt; edge_residual_capacity_t, long,
-    property &lt; edge_reverse_t, Traits::edge_descriptor &gt; &gt; &gt; &gt; Graph;
-
-  Graph g;
-  property_map &lt; Graph, edge_capacity_t &gt;::type
-      capacity = get(edge_capacity, g);
-  property_map &lt; Graph, edge_residual_capacity_t &gt;::type
-      residual_capacity = get(edge_residual_capacity, g);
-  property_map &lt; Graph, edge_reverse_t &gt;::type rev = get(edge_reverse, g);
-  Traits::vertex_descriptor s, t;
-  read_dimacs_max_flow(g, capacity, rev, s, t);
-
-  std::vector&lt;default_color_type&gt; color(num_vertices(g));
-  std::vector&lt;long&gt; distance(num_vertices(g));
-  long flow = kolmogorov_max_flow(g ,s, t);
-
-  std::cout &lt;&lt; "c  The total flow:" &lt;&lt; std::endl;
-  std::cout &lt;&lt; "s " &lt;&lt; flow &lt;&lt; std::endl &lt;&lt; std::endl;
-
-  std::cout &lt;&lt; "c flow values:" &lt;&lt; std::endl;
-  graph_traits &lt; Graph &gt;::vertex_iterator u_iter, u_end;
-  graph_traits &lt; Graph &gt;::out_edge_iterator ei, e_end;
-  for (tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter)
-    for (tie(ei, e_end) = out_edges(*u_iter, g); ei != e_end; ++ei)
-      if (capacity[*ei] &gt; 0)
-        std::cout &lt;&lt; "f " &lt;&lt; *u_iter &lt;&lt; " " &lt;&lt; target(*ei, g) &lt;&lt; " "
-          &lt;&lt; (capacity[*ei] - residual_capacity[*ei]) &lt;&lt; std::endl;
-
-  return EXIT_SUCCESS;
-}</PRE><P>
-The output is:
-</P>
-<PRE>c  The total flow:
-s 13
-
-c flow values:
-f 0 6 3
-f 0 1 0
-f 0 2 10
-f 1 5 1
-f 1 0 0
-f 1 3 0
-f 2 4 4
-f 2 3 6
-f 2 0 0
-f 3 7 5
-f 3 2 0
-f 3 1 1
-f 4 5 4
-f 4 6 0
-f 5 4 0
-f 5 7 5
-f 6 7 3
-f 6 4 0
-f 7 6 0
-f 7 5 0</PRE><H3>
-See Also</H3>
-<P STYLE="margin-bottom: 0cm"><TT><A HREF="edmonds_karp_max_flow.html">edmonds_karp_max_flow()</A></TT>,<BR><TT><A HREF="push_relabel_max_flow.html">push_relabel_max_flow()</A></TT>.
-</P>
-<HR>
-<TABLE CELLPADDING=2 CELLSPACING=2>
-	<TR VALIGN=TOP>
-		<TD>
-			<P>Copyright &copy; 2006</P>
-		</TD>
-		<TD>
-			<P>Stephan Diederich, University
-			Mannheim(<A HREF="mailto:diederich@ti.uni-manheim.de">diederich@ti.uni-manheim.de</A>)</P>
-		</TD>
-	</TR>
-</TABLE>
-<P><BR><BR>
-</P>
-</BODY>
-</HTML>
diff --git a/doc/leda_conversion.html b/doc/leda_conversion.html
index a8ba39f3d..6c24c6abf 100644
--- a/doc/leda_conversion.html
+++ b/doc/leda_conversion.html
@@ -236,9 +236,9 @@ <H1><a name="sec:leda-conversion">How to Convert Existing Graphs to BGL</H1>
   main(int,char*[])
   {
     typedef GRAPH&lt;int,int&gt; Graph;
-    function_requires&lt; VertexListGraphConcept&lt;Graph&gt; &gt;();
-    function_requires&lt; BidirectionalGraphConcept&lt;Graph&gt; &gt;();
-    function_requires&lt; MutableGraphConcept&lt;Graph&gt; &gt;();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept&lt;Graph&gt; ));
+    BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept&lt;Graph&gt; ));
+    BOOST_CONCEPT_ASSERT(( MutableGraphConcept&lt;Graph&gt; ));
     return 0;
   }
 </PRE>
diff --git a/doc/maximum_adjacency_search.html b/doc/maximum_adjacency_search.html
new file mode 100644
index 000000000..d2aa9e801
--- /dev/null
+++ b/doc/maximum_adjacency_search.html
@@ -0,0 +1,284 @@
+<html>
+<!--
+    Copyright (c) Fernando Vilas 2013
+
+
+    Some content from the Stoer-Wagner Min Cut documentation,
+    Copyright (c) Daniel Trebbien 2010
+
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<head>
+<title>Boost Graph Library: Maximum Adjacency Search</Title>
+<body>
+<img src="../../../boost.png" alt="C++ Boost" width="277" height="86">
+
+<h1><a name="sec:maximum-adjacency-search"></a>
+<tt>maximum_adjacency_search</tt>
+</h1>
+
+<p>
+<pre>
+<em>// named parameter versions</em>
+template &lt;class Graph, class class P, class T, class R&gt;
+void
+maximum_adjacency_search(const Graph&amp; g,
+       const bgl_named_params&lt;P, T, R&gt;&amp; params);
+
+<i>// non-named parameter versions</i>
+template &lt;class Graph, class WeightMap, class MASVisitor&gt;
+void
+maximum_adjacency_search(const Graph&amp; g, WeightMap weights, MASVisitor vis,
+       const typename graph_traits&lt;Graph&gt;::vertex_descriptor start);
+
+</pre>
+
+<p>
+The <tt>maximum_adjacency_search()</tt> function performs a traversal
+of the vertices in an undirected graph. The next vertex visited is the
+vertex that has the most visited neighbors at any time. In the case of
+an unweighted, undirected graph, the number of visited neighbors of the
+very last vertex visited in the graph is also the number of edge-disjoint
+paths between that vertex and the next-to-last vertex visited. These can be
+retrieved from a visitor, an example of which is in the test harness
+mas_test.cpp.
+</p>
+
+<p>
+The <tt>maximum_adjacency_search()</tt> function invokes user-defined
+actions at certain event-points within the algorithm. This provides a
+mechanism for adapting the generic MAS algorithm to the many situations
+in which it can be used. In the pseudo-code below, the event points
+for MAS are the labels on the right. The user-defined actions must be
+provided in the form of a visitor object, that is, an object whose type
+meets the requirements for a MAS Visitor.
+</p>
+
+<table>
+<tr>
+<td valign="top">
+<pre>
+MAS(<i>G</i>)
+  <b>for</b> each vertex <i>u in V</i> 
+    <i>reach_count[u] := 0</i>
+  <b>end for</b>
+  // for the starting vertex s
+  <i>reach_count[s] := 1</i>
+  <b>for</b> each unvisited vertex <i>u in V</i>
+    <b>call</b> MAS-VISIT(<i>G</i>, <i>u</i>)
+    remove u from the list on unvisited vertices
+    <b>for</b> each out edge from <i>u</i> to <i>t</i>
+       <b>if</b> <i>t</i> has not yet been visited
+         increment <i>reach_count[t]</i>
+       <b>end if</b>
+    <b>end for</b> each out edge
+    <b>call</b> MAS-VISIT(<i>G</i>, <i>u</i>)
+  <b>end for</b> each unvisited vertex
+<pre>
+</td>
+<td valign="top">
+<pre>
+-
+-
+initialize vertex <i>u</i>
+-
+-
+-
+-
+examine vertex <i>u</i>
+-
+examine edge <i>(u,t)</i>
+-
+-
+-
+-
+finish vertex <i>u</i>
+-
+</pre>
+</td>
+</tr>
+</table>
+
+<h3>Where Defined</h3>
+
+<p>
+<a href="../../../boost/graph/maximum_adjacency_search.hpp"><tt>boost/graph/maximum_adjacency_search.hpp</tt></a></p>
+
+<h3>Parameters</h3>
+
+IN: <tt>const UndirectedGraph&amp; g</tt></p>
+<blockquote>
+  A connected, directed graph. The graph type must
+  be a model of <a href="./IncidenceGraph.html">Incidence Graph</a>
+  and <a href="./VertexListGraph.html">Vertex List Graph</a>.<br>
+</blockquote>
+
+<h3>Named Parameters</h3>
+
+<p>IN: <tt>WeightMap weights</tt></p>
+<blockquote>
+  The weight or length of each edge in the graph. The
+  <tt>WeightMap</tt> type must be a model of
+  <a href="../../property_map/doc/ReadablePropertyMap.html">Readable
+  Property Map</a> and its value type must be <a class="external"
+  href="http://www.sgi.com/tech/stl/LessThanComparable.html">
+  Less Than Comparable</a> and summable. The key type of this map
+  needs to be the graph's edge descriptor type.
+  <b>Default:</b> <tt>get(edge_weight, g)</tt><br>
+</blockquote>
+
+IN: <tt>visitor(MASVisitor vis)</tt></p>
+<blockquote>
+  A visitor object that is invoked inside the algorithm at the
+  event-points specified by the MAS Visitor concept. The visitor
+  object is passed by value <a href="#1">[1]</a>. <br>
+  <b>Default:</b> <tt>mas_visitor&lt;null_visitor&gt;</tt><br>
+</blockquote>
+
+IN: <tt>root_vertex(typename
+graph_traits&lt;VertexListGraph&gt;::vertex_descriptor start)</tt></p>
+<blockquote>
+  This specifies the vertex that the depth-first search should
+  originate from. The type is the type of a vertex descriptor for the
+  given graph.<br>
+  <b>Default:</b> <tt>*vertices(g).first</tt><br>
+</blockquote>
+
+<h4>Expert Parameters</h4>
+
+<p>IN: <tt>vertex_index_map(VertexIndexMap vertexIndices)</tt> </p>
+<blockquote>
+  This maps each vertex to an integer in the range
+  [0, <tt>num_vertices(g)</tt>). This is only necessary if the default is
+  used for the assignment, index-in-heap, or distance maps.
+  <tt>VertexIndexMap</tt> must be a model of <a
+  href="../../property_map/doc/ReadablePropertyMap.html">Readable Property
+  Map</a>. The value type of the map must be an integer type. The
+  key type must be the graph's vertex descriptor type.<br>
+  <b>Default:</b> <tt>get(boost::vertex_index, g)</tt>
+    Note: if you use this default, make sure your graph has
+    an internal <tt>vertex_index</tt> property. For example,
+    <tt>adjacency_list</tt> with <tt>VertexList=listS</tt> does
+    not have an internal <tt>vertex_index</tt> property.
+</blockquote>
+
+<p>UTIL: <tt>vertex_assignment_map(AssignmentMap assignments)</tt></p>
+<blockquote>
+  <tt>AssignmentMap</tt> must be a model of <a
+  href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write Property
+  Map</a>. The key and value types must be the graph's vertex descriptor
+  type.<br>
+  <b>Default:</b> A <tt>boost::iterator_property_map</tt> using a
+  <tt>std::vector</tt> of <tt>num_vertices(g)</tt> vertex descriptors and
+  <tt>vertexIndices</tt> for the index map.
+</blockquote>
+
+<p>UTIL: <tt>max_priority_queue(MaxPriorityQueue&amp; pq)</tt></p>
+<blockquote>
+  <tt>MaxPriorityQueue</tt> must be a model of <a
+  href="./KeyedUpdatableQueue.html">Keyed Updatable Queue</a> and a
+  max-<a href="./UpdatableQueue.html#concept%3AUpdatablePriorityQueue">
+  Updatable Priority Queue</a>. The value type must be the graph's vertex
+  descriptor and the key type must be the weight type.
+  <b>Default:</b> A <tt>boost::d_ary_heap_indirect</tt> using a default
+  index-in-heap and distance map.
+</blockquote>
+
+<p>UTIL: <tt>index_in_heap_map(IndexInHeapMap indicesInHeap)</tt></p>
+<blockquote>
+  This parameter only has an effect when the default max-priority queue is used.<br>
+  <tt>IndexInHeapMap</tt> must be a model of <a
+  href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write Property
+  Map</a>. The key type must be the graph's vertex descriptor type. The
+  value type must be a size type
+  (<tt>typename&nbsp;std::vector&lt;vertex_descriptor&gt;::size_type</tt>).<br>
+  <b>Default:</b> A <tt>boost::iterator_property_map</tt> using a
+  <tt>std::vector</tt> of <tt>num_vertices(g)</tt> size type objects and
+  <tt>vertexIndices</tt> for the index map.
+</blockquote>
+
+<p>UTIL: <tt>distance_map(DistanceMap wAs)</tt></p>
+<blockquote>
+  This parameter only has an effect when the default max-priority queue is used.<br>
+  <tt>DistanceMap</tt> must be a model of <a
+  href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write Property
+  Map</a>. The key type must be the graph's vertex descriptor type. The
+  value type must be the weight type
+  (<tt>typename&nbsp;boost::property_traits&lt;WeightMap&gt;::value_type</tt>).
+  <br>
+  <b>Default:</b> A <tt>boost::iterator_property_map</tt> using a
+  <tt>std::vector</tt> of <tt>num_vertices(g)</tt> weight type objects
+  and <tt>vertexIndices</tt> for the index map.
+</blockquote>
+
+<h3>Returns</h3>
+<p>void</p>
+
+<h3>Throws</h3>
+
+<p><tt>bad_graph</tt>
+<blockquote>
+  If <tt>num_vertices(g)</tt> is less than 2
+</blockquote></p>
+
+<p><tt>std::invalid_argument</tt>
+<blockquote>
+  If a max-priority queue is given as an argument and it is not empty
+</blockquote>.
+
+<h3><a name="SECTION001340300000000000000">
+Complexity</a>
+</h3>
+
+<p>
+The time complexity is <i>O(E + V)</i>.
+</p>
+
+<h3>References</h3>
+<ul>
+<li>David Matula (1993). <q><a href="http://dl.acm.org/citation.cfm?id=313872&dl=ACM&coll=DL&CFID=85991501&CFTOKEN=44461131">A linear time 2 + epsilon approximation algorightm for edge connectivity</a></q>
+</li>
+<li>Cai, Weiqing and Matula, David W. 
+Partitioning by maximum adjacency search of graphs. 
+Partitioning Data Sets: Dimacs Workshop, April 19-21, 1993. 
+Vol 19. Page 55. 1995. Amer Mathematical Society</li>
+}
+</ul>
+
+<h3>Visitor Event Points</h3>
+
+<ul>
+<li><b><tt>vis.initialize_vertex(s, g)</tt></b> is invoked on every
+  vertex of the graph before the start of the graph search.</li>
+
+<li><b><tt>vis.start_vertex(s, g)</tt></b> is invoked on the source
+  vertex once before processing its out edges.</li>
+
+<li><b><tt>vis.examine_edge(e, g)</tt></b> is invoked on every out-edge
+  of each vertex after it is started.</li>
+
+<li><b><tt>vis.finish_vertex(u, g)</tt></b> is invoked on a vertex after
+  all of its out edges have been examined and the reach counts of the
+  unvisited targets have been updated.</li>
+</ul>
+
+<h3>Notes</h3>
+
+<p><a name="1">[1]</a> 
+  Since the visitor parameter is passed by value, if your visitor
+  contains state then any changes to the state during the algorithm
+  will be made to a copy of the visitor object, not the visitor object
+  passed in. Therefore you may want the visitor to hold this state by
+  pointer or reference.</p>
+
+<hr>
+<table>
+<tr valign=top>
+<td nowrap>Copyright &copy; 2012</td><td>
+Fernando Vilas
+</td></tr></table>
+
+</body>
+</html> 
diff --git a/doc/opposite.html b/doc/opposite.html
index 6e3f12db2..f9be2e477 100644
--- a/doc/opposite.html
+++ b/doc/opposite.html
@@ -56,7 +56,7 @@ <h3>Example</h3>
 edge_descriptor e;
 ...
 vertex_descriptor u, v;
-tie(u, v) = incident(e, g);
+boost::tie(u, v) = incident(e, g);
 assert(v == opposite(e, u, g));
 assert(u == opposite(e, v, g));
 </pre>
diff --git a/doc/planar_face_traversal.html b/doc/planar_face_traversal.html
index c52fa8b89..9a93799d6 100644
--- a/doc/planar_face_traversal.html
+++ b/doc/planar_face_traversal.html
@@ -97,7 +97,7 @@ <h5>A plane drawing of a graph (left), and the 8 faces defined by the planar
     New face: 1 2 5 4
     New face: 2 3 4 5
     New face: 3 0 1 4
-    New face: 2 3 0 1
+    New face: 1 0 3 2
 </pre>
 
 <h3>Visitor Event Points</h3> 
diff --git a/doc/predecessor_recorder.html b/doc/predecessor_recorder.html
index 75fe44a6f..6f600eafd 100644
--- a/doc/predecessor_recorder.html
+++ b/doc/predecessor_recorder.html
@@ -31,7 +31,7 @@ <H1>
 
 <p>
 <tt>predecessor_recorder</tt> can be used with graph algorithms by
-wrapping it with the algorithm specific adaptor, such as <a
+wrapping it with an algorithm-specific adaptor, such as <a
 href="./bfs_visitor.html"><tt>bfs_visitor</tt></a> and <a
 href="./dfs_visitor.html"><tt>dfs_visitor</tt></a>. Also, this event
 visitor can be combined with other event visitors using
@@ -44,7 +44,7 @@ <H1>
 predecessor to itself, thereby identifying the root vertex as the only
 vertex which is its own parent. When using an algorithm like
 depth-first search that creates a forest (multiple search trees) it
-is useful to intialize the predecessor of every vertex to itself. This
+is useful to initialize the predecessor of every vertex to itself. This
 way all the root nodes can be distinguished.
 
 
diff --git a/doc/prim_minimum_spanning_tree.html b/doc/prim_minimum_spanning_tree.html
index 371a7a70e..cf373c70b 100644
--- a/doc/prim_minimum_spanning_tree.html
+++ b/doc/prim_minimum_spanning_tree.html
@@ -67,6 +67,7 @@ <H1><A NAME="sec:prim"></A>
   <b>for</b> each vertex <i>u</i> <i>in</i> <i>V[G]</i>  
     <i>color[u] :=</i> WHITE
     <i>d[u] :=</i> <i>infinity</i>  
+  <b>end for</b>
   <i>color[s] :=</i> GRAY
   <i>d[s] := 0</i> 
   ENQUEUE(<i>PQ</i>, <i>s</i>)  
@@ -171,7 +172,9 @@ <h3>Named Parameters</h3>
   <a href="../../property_map/doc/ReadablePropertyMap.html">Readable Property Map</a>. The edge descriptor type of
   the graph needs to be usable as the key type for the weight
   map. The value type for the map must be
-  <i>Addable</i> with the value type of the distance map.<br>
+  the same as the value type of the distance map, and that type must be <a
+    href="http://www.sgi.com/tech/stl/LessThanComparable.html">Less Than
+      Comparable</a>.<br>
   <b>Default:</b>  <tt>get(edge_weight, g)</tt><br>
   <b>Python</b>: Must be an <tt>edge_double_map</tt> for the graph.<br>
   <b>Python default</b>: <tt>graph.get_edge_double_map("weight")</tt>
@@ -189,7 +192,7 @@ <h3>Named Parameters</h3>
   <b>Default:</b> <tt>get(vertex_index, g)</tt>
     Note: if you use this default, make sure your graph has
     an internal <tt>vertex_index</tt> property. For example,
-    <tt>adjacenty_list</tt> with <tt>VertexList=listS</tt> does
+    <tt>adjacency_list</tt> with <tt>VertexList=listS</tt> does
     not have an internal <tt>vertex_index</tt> property.
    <br>
   <b>Python</b>: Unsupported parameter.
@@ -197,17 +200,15 @@ <h3>Named Parameters</h3>
 
 UTIL/OUT: <tt>distance_map(DistanceMap d_map)</tt> 
 <blockquote>
-  The shortest path weight from the source vertex <tt>s</tt> to each
-  vertex in the graph <tt>g</tt> is recorded in this property map. The
-  shortest path weight is the sum of the edge weights along the
-  shortest path.  The type <tt>DistanceMap</tt> must be a model of
-  <a
+  The weight of the spanning tree edge into each
+  vertex in the graph <tt>g</tt> is recorded in this property map, with edges
+  directed away from the spanning tree root. 
+  The type <tt>DistanceMap</tt> must be a model of <a
   href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write
   Property Map</a>. The vertex descriptor type of the
-  graph needs to be usable as the key type of the distance map. The
-  value type of the distance map must be <a
-  href="http://www.sgi.com/tech/stl/LessThanComparable.html">Less Than
-  Comparable</a>.<br> 
+  graph needs to be usable as the key type of the distance map, and the value
+  type needs to be the same as the value type of the <tt>weight_map</tt>
+  argument.<br> 
   <b>Default:</b> <a href="../../property_map/doc/iterator_property_map.html">
   <tt>iterator_property_map</tt></a> created from a
   <tt>std::vector</tt> of the <tt>WeightMap</tt>'s value type of size
diff --git a/doc/push_relabel_max_flow.html b/doc/push_relabel_max_flow.html
index 4fcab20a2..5dff05047 100644
--- a/doc/push_relabel_max_flow.html
+++ b/doc/push_relabel_max_flow.html
@@ -158,7 +158,7 @@ <h3>Example</h3>
 #include &lt;boost/config.hpp&gt;
 #include &lt;iostream&gt;
 #include &lt;string&gt;
-#include &lt;boost/graph/push_relabel_map_flow.hpp&gt;
+#include &lt;boost/graph/push_relabel_max_flow.hpp&gt;
 #include &lt;boost/graph/adjacency_list.hpp&gt;
 #include &lt;boost/graph/read_dimacs.hpp&gt;
 
@@ -196,8 +196,8 @@ <h3>Example</h3>
   std::cout &lt;&lt; "c flow values:" &lt;&lt; std::endl;
   graph_traits&lt;Graph&gt;::vertex_iterator u_iter, u_end;
   graph_traits&lt;Graph&gt;::out_edge_iterator ei, e_end;
-  for (tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter)
-    for (tie(ei, e_end) = out_edges(*u_iter, g); ei != e_end; ++ei)
+  for (boost::tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter)
+    for (boost::tie(ei, e_end) = out_edges(*u_iter, g); ei != e_end; ++ei)
       if (capacity[*ei] &gt; 0)
         std::cout &lt;&lt; "f " &lt;&lt; *u_iter &lt;&lt; " " &lt;&lt; target(*ei, g) &lt;&lt; " " 
                   &lt;&lt; (capacity[*ei] - residual_capacity[*ei]) &lt;&lt; std::endl;
diff --git a/doc/quick_tour.html b/doc/quick_tour.html
index 5ae9ffe95..cee009259 100644
--- a/doc/quick_tour.html
+++ b/doc/quick_tour.html
@@ -187,7 +187,7 @@ <h2>Accessing the Edge Set</h2>
 iterator gives an edge object. The <tt>source()</tt> and <tt>target()</tt>
 functions return the two vertices that are connected by the edge. Instead of
 explicitly creating a <tt>std::pair</tt> for the iterators, this time we will
-use the <a href="../../tuple/doc/tuple_users_guide.html#tiers"><tt>tie()</tt></a> helper function.
+use the <a href="../../tuple/doc/tuple_users_guide.html#tiers"><tt>boost::tie()</tt></a> helper function.
 This handy function can be used to assign the parts of a <tt>std::pair</tt> into
 two separate variables, in this case <tt>ei</tt> and <tt>ei_end</tt>. This is
 usually more convenient than creating a <tt>std::pair</tt> and is our method of
@@ -200,7 +200,7 @@ <h2>Accessing the Edge Set</h2>
     // ...
     std::cout &lt;&lt; &quot;edges(g) = &quot;;
     graph_traits&lt;Graph&gt;::edge_iterator ei, ei_end;
-    for (tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
+    for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
         std::cout &lt;&lt; &quot;(&quot; &lt;&lt; index[source(*ei, g)] 
                   &lt;&lt; &quot;,&quot; &lt;&lt; index[target(*ei, g)] &lt;&lt; &quot;) &quot;;
     std::cout &lt;&lt; std::endl;
@@ -303,7 +303,7 @@ <h3>Out-Edges, In-Edges, and Edge Descriptors</h3>
       std::cout &lt;&lt; &quot;out-edges: &quot;;
       typename GraphTraits::out_edge_iterator out_i, out_end;
       typename GraphTraits::edge_descriptor e;
-      for (tie(out_i, out_end) = out_edges(v, g); 
+      for (boost::tie(out_i, out_end) = out_edges(v, g); 
            out_i != out_end; ++out_i) {
         e = *out_i;
         Vertex src = source(e, g), targ = target(e, g);
@@ -337,7 +337,7 @@ <h3>Out-Edges, In-Edges, and Edge Descriptors</h3>
       std::cout &lt;&lt; &quot;in-edges: &quot;;
       typedef typename graph_traits&lt;Graph&gt; GraphTraits;
       typename GraphTraits::in_edge_iterator in_i, in_end;
-      for (tie(in_i, in_end) = in_edges(v,g); 
+      for (boost::tie(in_i, in_end) = in_edges(v,g); 
            in_i != in_end; ++in_i) {
         e = *in_i;
         Vertex src = source(e, g), targ = target(e, g);
@@ -373,7 +373,7 @@ <h3>Adjacent Vertices</h3>
       std::cout &lt;&lt; &quot;adjacent vertices: &quot;;
       typename graph_traits&lt;Graph&gt;::adjacency_iterator ai;
       typename graph_traits&lt;Graph&gt;::adjacency_iterator ai_end;
-      for (tie(ai, ai_end) = adjacent_vertices(v, g);
+      for (boost::tie(ai, ai_end) = adjacent_vertices(v, g);
            ai != ai_end; ++ai)
         std::cout &lt;&lt; index[*ai] &lt;&lt;  &quot; &quot;;
       std::cout &lt;&lt; std::endl;
@@ -386,7 +386,7 @@ <h3>Adjacent Vertices</h3>
   adjacent vertices: 0 1
 </pre>
 <p>&nbsp;
-<h2>Adding Some Color to your Graph</h2>
+<h2>Vertex and Edge Properties</h2>
 <p>BGL attempts to be as flexible as possible in terms of accommodating how
 properties are attached to a graph. For instance, a property such as edge weight
 may need to be used throughout a graph object's lifespan and therefore it would
diff --git a/doc/r_c_shortest_paths.html b/doc/r_c_shortest_paths.html
index cc5fd260f..069d4c714 100755
--- a/doc/r_c_shortest_paths.html
+++ b/doc/r_c_shortest_paths.html
@@ -123,7 +123,7 @@ <h3>Introduction and Problem Description</h3>
 Desaulniers, G.; Desrosiers, J.; Solomon, M. (eds.) (2005):<br>
 Column Generation<br>
 Springer, New York, pp. 33&ndash;65<br>
-(available online <a href="http://www.dpor.rwth-aachen.de/de/publikationen/pdf/or_2004-01.pdf">
+(available online <a href="http://logistik.bwl.uni-mainz.de/Dateien/or_2004-01.pdf">
 here</a>)
 <p>
 
@@ -446,11 +446,11 @@ <h3>Parameters</h3>
 OUT: <tt>std::vector&lt;typename graph_traits&lt;Graph&gt;::edge_descriptor&gt;&amp; 
 pareto_optimal_solution</tt>
 <blockquote>
-A container for storing the first Pareto-optimal (undominated) solution (<i>s</i>-<i>t</i>-path) in the overloads where only one Pareto-optimal solution is returned. The path is returned as a sequence of edge descriptors in reverse order (from <tt>t</tt> to <tt>s</tt>).
+A container for storing the first Pareto-optimal (undominated) solution (<i>s</i>-<i>t</i>-path) in the overloads where only one Pareto-optimal solution is returned. The path is returned as a sequence of edge descriptors in reverse order (from <tt>t</tt> to <tt>s</tt>).  This argument is not modified if there are no solutions.
 </blockquote>
 OUT: <tt>Resource_Container&amp; pareto_optimal_resource_container</tt>
 <blockquote>
-A <tt>Resource_Container</tt> object for storing the Pareto-optimal resource container corresponding to the first Pareto-optimal path in the overloads where only one Pareto-optimal solution is returned.
+A <tt>Resource_Container</tt> object for storing the Pareto-optimal resource container corresponding to the first Pareto-optimal path in the overloads where only one Pareto-optimal solution is returned.  This argument is not modified if there are no solutions.
 </blockquote>
 IN: <tt>const Resource_Container&amp; rc</tt>
 <blockquote>
@@ -466,7 +466,7 @@ <h3>Parameters</h3>
 </blockquote>
 IN: <tt>Label_Allocator la</tt>
 <blockquote>
-An object of type <tt>Label_Allocator</tt> specifying a strategy for the memory management of the labels. It must offer the same interface as <tt>std::allocator<lt;r_c_shortest_paths_label&lt;Graph, Resource_Container&gt; &gt;</tt>. There is a default type <tt>default_r_c_shortest_paths_allocator</tt> for this parameter using the STL standard allocator. If the third or the fourth overload of the function is used, an object of this type is used as <tt>Label_Allocator</tt> parameter. If the first or the second overload is used, one must specify both a <tt>Label_Allocator</tt> and a <tt>Visitor</tt> parameter. If one wants to develop a user-defined type only for <tt>Visitor</tt>, one can use <tt>default_r_c_shortest_paths_allocator</tt> as <tt>Label_Allocator</tt> parameter. If one wants to use a specialized allocator, one can specify an arbitrary type as template parameter for the value type to the allocator; it is rebound to the correct type.
+An object of type <tt>Label_Allocator</tt> specifying a strategy for the memory management of the labels. It must offer the same interface as <tt>std::allocator&lt;r_c_shortest_paths_label&lt;Graph, Resource_Container&gt; &gt;</tt>. There is a default type <tt>default_r_c_shortest_paths_allocator</tt> for this parameter using the STL standard allocator. If the third or the fourth overload of the function is used, an object of this type is used as <tt>Label_Allocator</tt> parameter. If the first or the second overload is used, one must specify both a <tt>Label_Allocator</tt> and a <tt>Visitor</tt> parameter. If one wants to develop a user-defined type only for <tt>Visitor</tt>, one can use <tt>default_r_c_shortest_paths_allocator</tt> as <tt>Label_Allocator</tt> parameter. If one wants to use a specialized allocator, one can specify an arbitrary type as template parameter for the value type to the allocator; it is rebound to the correct type.
 </blockquote>
 IN: <tt>Visitor vis</tt>
 <blockquote>
diff --git a/doc/random_spanning_tree.html b/doc/random_spanning_tree.html
index 15d4ac3e7..e6d82f48a 100644
--- a/doc/random_spanning_tree.html
+++ b/doc/random_spanning_tree.html
@@ -76,7 +76,7 @@ <h3>Parameters</h3>
 <blockquote>
   A random number generator. The generator type must
   be a model of <a
-  href="../../random/doc/reference.html#boost_random.reference.concepts.uniform_random_number_generator">Uniform
+  href="../../../doc/html/boost_random/reference.html#boost_random.reference.concepts.uniform_random_number_generator">Uniform
   Random Number Generator</a> or a pointer or reference to such a type.<br>
 </blockquote>
 
diff --git a/doc/read_graphml.html b/doc/read_graphml.html
index 42c542a16..21796d8ec 100644
--- a/doc/read_graphml.html
+++ b/doc/read_graphml.html
@@ -20,7 +20,7 @@ <h1 class="title"><a class="reference external" href="../../../index.htm"><img a
 Authors: Tiago de Paula Peixoto -->
 <pre class="literal-block">
 void read_graphml(std::istream&amp; in, MutableGraph&amp; graph,
-                  dynamic_properties&amp; dp);
+                  dynamic_properties&amp; dp, size_t graph_index = 0);
 </pre>
 <p>The <tt class="docutils literal"><span class="pre">read_graphml</span></tt> function interprets a graph described using the
 <a class="reference external" href="http://graphml.graphdrawing.org/">GraphML</a> format and builds a BGL graph that captures that
@@ -39,6 +39,10 @@ <h1 class="title"><a class="reference external" href="../../../index.htm"><img a
 and with the appropriate C++ value type based on the GraphML attribute type
 definition. Graph properties are also set with the same
 <a class="reference external" href="../../property_map/doc/dynamic_property_map.html">dynamic_properties</a> object, where the key type is the type of the graph itself.</p>
+<p>If the file contains multiple graphs, the <tt class="docutils literal"><span class="pre">graph_index</span></tt> parameter controls
+which graph will be loaded.  It defaults to <tt class="docutils literal"><span class="pre">0</span></tt>, meaning that the first graph
+in the file will be loaded.  If <tt class="docutils literal"><span class="pre">graph_index</span></tt> is greater than or equal to the
+number of graphs in the file, an empty graph will be returned.</p>
 <dl class="docutils">
 <dt>Requirements:</dt>
 <dd><ul class="first last simple">
@@ -156,7 +160,7 @@ <h1><a class="toc-backref" href="#id6">See Also</a></h1>
 </div>
 <div class="footer">
 <hr class="footer" />
-Generated on: 2009-06-12 00:41 UTC.
+Generated on: 2012-11-12 22:25 UTC.
 Generated by <a class="reference external" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference external" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.
 
 </div>
diff --git a/doc/read_graphml.rst b/doc/read_graphml.rst
index c61156d89..1e8bd8182 100644
--- a/doc/read_graphml.rst
+++ b/doc/read_graphml.rst
@@ -19,7 +19,7 @@ __ ../../../index.htm
 ::
 
   void read_graphml(std::istream& in, MutableGraph& graph,
-                    dynamic_properties& dp);
+                    dynamic_properties& dp, size_t graph_index = 0);
 
  
 The ``read_graphml`` function interprets a graph described using the
@@ -42,6 +42,11 @@ and with the appropriate C++ value type based on the GraphML attribute type
 definition. Graph properties are also set with the same
 dynamic_properties_ object, where the key type is the type of the graph itself.
 
+If the file contains multiple graphs, the ``graph_index`` parameter controls
+which graph will be loaded.  It defaults to ``0``, meaning that the first graph
+in the file will be loaded.  If ``graph_index`` is greater than or equal to the
+number of graphs in the file, an empty graph will be returned.
+
 Requirements:
  - The type of the graph must model the `Mutable Graph`_ concept.
  - The type of the iterator must model the `Multi-Pass Iterator`_
diff --git a/doc/read_graphviz.html b/doc/read_graphviz.html
index b2d7a0b1a..8163c6d05 100644
--- a/doc/read_graphviz.html
+++ b/doc/read_graphviz.html
@@ -181,8 +181,8 @@ <h1><a class="toc-backref" href="#id4">Example</a></h1>
 <div class="section" id="building-the-graphviz-readers">
 <h1><a class="toc-backref" href="#id5">Building the GraphViz Readers</a></h1>
 <p>To use the GraphViz readers, you will need to build and link against
-the &quot;boost_graph&quot; library. The library can be built by following the
-<a class="reference external" href="../../../more/getting_started.html#Build_Install">Boost Jam Build Instructions</a> for the subdirectory <tt class="docutils literal"><span class="pre">libs/graph/build</span></tt>.</p>
+the &quot;boost_graph&quot; and &quot;boost_regex&quot; libraries. These libraries can be built by following the
+<a class="reference external" href="../../../more/getting_started.html#Build_Install">Boost Jam Build Instructions</a> for the subdirectories <tt class="docutils literal"><span class="pre">libs/graph/build</span></tt> and <tt class="docutils literal"><span class="pre">libs/regex/build</span></tt>.</p>
 </div>
 <div class="section" id="notes">
 <h1><a class="toc-backref" href="#id6">Notes</a></h1>
diff --git a/doc/read_graphviz.rst b/doc/read_graphviz.rst
index 053d1ef22..b8bd341dd 100644
--- a/doc/read_graphviz.rst
+++ b/doc/read_graphviz.rst
@@ -182,8 +182,8 @@ GraphViz reader to populate an ``adjacency_list`` graph
 Building the GraphViz Readers
 -----------------------------
 To use the GraphViz readers, you will need to build and link against
-the "boost_graph" library. The library can be built by following the
-`Boost Jam Build Instructions`_ for the subdirectory ``libs/graph/build``.
+the "boost_graph" and "boost_regex" libraries. These libraries can be built by following the
+`Boost Jam Build Instructions`_ for the subdirectories ``libs/graph/build`` and ``libs/regex/build``.
 
 
 Notes
diff --git a/doc/reverse_graph.html b/doc/reverse_graph.html
index 96d03537c..bb4a10f19 100644
--- a/doc/reverse_graph.html
+++ b/doc/reverse_graph.html
@@ -27,7 +27,7 @@ <H1><A NAME="sec:reverse-graph-adaptor"></A>
 a <a href="./BidirectionalGraph.html">BidirectionalGraph</a>,
 effectively transposing the graph. The construction of the
 <tt>reverse_graph</tt> is constant time, providing a highly efficient
-way to obtain a transposed-view of a graph.
+way to obtain a transposed view of a graph.
 
 
 <H3>Example</H3>
@@ -215,6 +215,16 @@ <H2>Associated Types</H2>
 <hr>
 
 
+<tt>property_map&lt;reverse_graph, edge_underlying_t&gt;::type</tt><br>
+and<br>
+<tt>property_map&lt;reverse_graph, edge_underlying_t&gt;::const_type</tt>
+<br><br>
+An edge property type mapping from edge descriptors in the <tt>reverse_graph</tt> to
+edge descriptors in the underlying <tt>BidirectionalGraph</tt> object.
+
+<hr>
+
+
 <H2>Member Functions</H2>
 
 <hr>
@@ -358,6 +368,16 @@ <H2>Non-Member Functions</H2>
 
 <hr>
 
+<pre>
+property_map&lt;reverse_graph, edge_underlying_t&gt;::const_type
+get(PropertyTag, const reverse_graph&amp; g)
+</pre>
+Returns a property map object that converts from edge descriptors in the
+<tt>reverse_graph</tt> to edge descriptors in the underlying
+<tt>BidirectionalGraph</tt> object.
+
+<hr>
+
 <pre>
 template &lt;class <a href="./PropertyTag.html">PropertyTag</a>, class X&gt;
 typename property_traits&lt;property_map&lt;reverse_graph, PropertyTag&gt;::const_type&gt;::value_type
@@ -367,6 +387,13 @@ <H2>Non-Member Functions</H2>
 a vertex or edge descriptor.
 <hr>
 
+<pre>
+typename graph_traits&lt;BidirectionalGraph&gt;::edge_descriptor
+get(edge_underlying_t, const reverse_graph&amp; g, edge_descriptor e)
+</pre>
+This returns the underlying edge descriptor for the edge <tt>e</tt> in the <tt>reverse_graph</tt>.
+<hr>
+
 <pre>
 template &lt;class <a href="./PropertyTag.html">PropertyTag</a>, class X, class Value&gt;
 void
diff --git a/doc/small_world_generator.html b/doc/small_world_generator.html
index 0b853502f..5dfffae54 100644
--- a/doc/small_world_generator.html
+++ b/doc/small_world_generator.html
@@ -45,7 +45,7 @@
 
   small_world_iterator();
   small_world_iterator(RandomGenerator&amp; gen, vertices_size_type n,
-                       vertices_size_type k, double probability,
+                       vertices_size_type k, double probability = 0.,
                        bool allow_self_loops = false);
   // Iterator operations
   reference operator*() const;
@@ -82,7 +82,7 @@ <h3>Constructors</h3>
 
 <pre>
 small_world_iterator(RandomGenerator&amp; gen, vertices_size_type n,
-                     vertices_size_type k, double probability,
+                     vertices_size_type k, double probability = 0.,
                      bool allow_self_loops = false);
 </pre>
 <blockquote>
diff --git a/doc/sorted_erdos_renyi_gen.html b/doc/sorted_erdos_renyi_gen.html
index 55273fa23..b61242a5a 100644
--- a/doc/sorted_erdos_renyi_gen.html
+++ b/doc/sorted_erdos_renyi_gen.html
@@ -63,7 +63,7 @@
 href="adjacency_list.html"><tt>adjacency_list</tt></a> or other graph
 structure with iterator-based initialization. An Erd&ouml;s-Renyi
 graph <em>G = (n, p)</em> is a graph with <em>n</em> vertices
-that. The probability of having an edge <em>(u, v)</em> in <em>G</em>
+such that the probability of having an edge <em>(u, v)</em> in <em>G</em>
 is <em>p</em> for any vertices <em>u</em> and <em>v</em>. Typically,
 there are no self-loops, but the generator can optionally introduce
 self-loops with probability <em>p</em>.</p>
@@ -93,7 +93,7 @@ <h3>Constructors</h3>
 Constructs an Erd&ouml;s-Renyi generator iterator that creates a
 graph with <tt>n</tt> vertices and a given <tt>probability</tt> of the
 total number of edges that a simple graph may have.
-<tt>probability</tt>. Random vertices and edges are selected using the
+Random vertices and edges are selected using the
 random number generator <tt>gen</tt>. Self-loops are permitted only when
 <tt>allow_self_loops</tt> is <tt>true</tt>.
 </blockquote>
diff --git a/doc/sparse_matrix_ordering.html b/doc/sparse_matrix_ordering.html
index 87b39e7f5..44a6a1bc2 100644
--- a/doc/sparse_matrix_ordering.html
+++ b/doc/sparse_matrix_ordering.html
@@ -143,7 +143,7 @@ <H3><A NAME="SECTION001032100000000000000">
     rcm_queue&lt;Vertex, Degree&gt; Q(degree);
     
     typename boost::graph_traits&lt;Graph&gt;::vertex_iterator ui, ui_end;
-    for (tie(ui, ui_end) = vertices(G); ui != ui_end; ++ui)
+    for (boost::tie(ui, ui_end) = vertices(G); ui != ui_end; ++ui)
       put(color, *ui, white(c));
     breadth_first_search(G, u, Q, bfs_visitor&lt;&gt;(), color);
 
@@ -214,7 +214,7 @@ <H3><A NAME="SECTION001032100000000000000">
     CMVisitor cm_visitor(inverse_permutation);
     
     typename boost::graph_traits&lt;Graph&gt;::vertex_iterator ui, ui_end;
-    for (tie(ui, ui_end) = vertices(G); ui != ui_end; ++ui)
+    for (boost::tie(ui, ui_end) = vertices(G); ui != ui_end; ++ui)
       put(color, *ui, white(c));
     breadth_first_search(G, s, Q, cm_visitor, color);
   }  
diff --git a/doc/subgraph.html b/doc/subgraph.html
index 09d07b30b..90c6019ce 100644
--- a/doc/subgraph.html
+++ b/doc/subgraph.html
@@ -76,9 +76,9 @@ <h3>Example</h3>
 and subgraphs in Figure 1, so we will need a total of six vertices.
 
 <pre>
-typedef adjacency_list_traits<vecS, vecS, directedS> Traits;
-typedef subgraph< adjacency_list<vecS, vecS, directedS,
-  no_property, property<edge_index_t, int> > > Graph;
+typedef adjacency_list_traits&lt; vecS, vecS, directedS &gt; Traits;
+typedef subgraph&lt; adjacency_list&lt; vecS, vecS, directedS,
+  no_property, property&lt; edge_index_t, int &gt; &gt; &gt; Graph;
 
 const int N = 6;
 Graph G0(N);
diff --git a/doc/successive_shortest_path_nonnegative_weights.html b/doc/successive_shortest_path_nonnegative_weights.html
new file mode 100644
index 000000000..d6d53be22
--- /dev/null
+++ b/doc/successive_shortest_path_nonnegative_weights.html
@@ -0,0 +1,264 @@
+<HTML>
+<!--
+     Copyright (c) Piotr Wygocki 2013
+    
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Boost Graph Library: Successive Shortest Path for  Min Cost Max Flow</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
+        ALINK="#ff0000"> 
+<IMG SRC="../../../boost.png" 
+     ALT="C++ Boost" width="277" height="86"> 
+
+<BR Clear>
+
+<H1><A NAME="sec:successive_shortest_path_nonnegative_weights">
+<TT>successive_shortest_path_nonnegative_weights</TT>
+</H1>
+
+<PRE>
+<i>// named parameter version</i>
+template &lt;class <a href="./Graph.html">Graph</a>, class P, class T, class R&gt;
+void successive_shortest_path_nonnegative_weights(
+        Graph &amp;g, 
+        typename graph_traits&lt;Graph&gt;::vertex_descriptor s, 
+        typename graph_traits&lt;Graph&gt;::vertex_descriptor t,
+        const bgl_named_params&lt;P, T, R&gt; &amp; params  = <i>all defaults</i>)
+
+<i>// non-named parameter version</i>
+template &lt;class <a href="./Graph.html">Graph</a>, class Capacity, class ResidualCapacity, class Reversed, class Pred, class Weight, class Distance, class Distance2, class VertexIndex&gt;
+void successive_shortest_path_nonnegative_weights(
+        const Graph &amp; g, 
+        typename graph_traits&lt;Graph&gt;::vertex_descriptor s, 
+        typename graph_traits&lt;Graph&gt;::vertex_descriptor t,
+        Capacity capacity,
+        ResidualCapacity residual_capacity,
+        Weight weight, 
+        Reversed rev,
+        VertexIndex index,
+        Pred pred, 
+        Distance distance,
+        Distance2 distance_prev) 
+</PRE>
+
+<P>
+The <tt>successive_shortest_path_nonnegative_weights()</tt> function calculates the minimum cost maximum flow of a network. See Section <a
+href="./graph_theory_review.html#sec:network-flow-algorithms">Network
+Flow Algorithms</a> for a description of maximum flow.  
+ The function calculates the flow values <i>f(u,v)</i> for all <i>(u,v)</i> in
+<i>E</i>, which are returned in the form of the residual capacity
+<i>r(u,v) = c(u,v) - f(u,v)</i>. 
+
+<p>
+There are several special requirements on the input graph and property
+map parameters for this algorithm. First, the directed graph
+<i>G=(V,E)</i> that represents the network must be augmented to
+include the reverse edge for every edge in <i>E</i>.  That is, the
+input graph should be <i>G<sub>in</sub> = (V,{E U
+E<sup>T</sup>})</i>. The <tt>ReverseEdgeMap</tt> argument <tt>rev</tt>
+must map each edge in the original graph to its reverse edge, that is
+<i>(u,v) -> (v,u)</i> for all <i>(u,v)</i> in <i>E</i>. The
+<tt>CapacityEdgeMap</tt> argument <tt>cap</tt> must map each edge in
+<i>E</i> to a positive number, and each edge in <i>E<sup>T</sup></i>
+to 0. The <tt>WeightMap</tt> has to map each edge from  <i>E</i> to  nonnegative number, and each edge from <i>E<sup>T</sup></i> to <i>-weight</i> of its reversed edge.
+
+<p>
+The algorithm is described in <a
+href="./bibliography.html#ahuja93:_network_flows">Network Flows</a>.
+
+<p>
+This algorithm starts with empty flow and in each round augments the shortest path (in terms of weight) in the residual graph.
+
+<p> 
+In order to find the cost of the result flow use:
+<a href="./find_flow_cost.html"><tt>find_flow_cost()</tt></a>.
+
+<H3>Where Defined</H3>
+
+<P>
+<a href="../../../boost/graph/successive_shortest_path_nonnegative_weights.hpp"><TT>boost/graph/successive_shortest_path_nonnegative_weights.hpp</TT></a>
+
+<P>
+
+<h3>Parameters</h3>
+
+IN: <tt>Graph&amp; g</tt>
+<blockquote>
+  A directed graph. The
+  graph's type must be a model of <a
+  href="./VertexListGraph.html">VertexListGraph</a> and <a href="./IncidenceGraph.html">IncidenceGraph</a> For each edge
+  <i>(u,v)</i> in the graph, the reverse edge <i>(v,u)</i> must also
+  be in the graph.
+</blockquote>
+
+IN: <tt>vertex_descriptor s</tt>
+<blockquote>
+  The source vertex for the flow network graph.
+</blockquote>
+  
+IN: <tt>vertex_descriptor t</tt>
+<blockquote>
+  The sink vertex for the flow network graph.
+</blockquote>
+  
+<h3>Named Parameters</h3>
+
+
+IN: <tt>capacity_map(CapacityEdgeMap cap)</tt>
+<blockquote>
+  The edge capacity property map. The type must be a model of a
+  constant <a
+  href="../../property_map/doc/LvaluePropertyMap.html">Lvalue Property Map</a>. The
+  key type of the map must be the graph's edge descriptor type.<br>
+  <b>Default:</b> <tt>get(edge_capacity, g)</tt>
+</blockquote>
+  
+OUT: <tt>residual_capacity_map(ResidualCapacityEdgeMap res)</tt>
+<blockquote>
+  This maps edges to their residual capacity. The type must be a model
+  of a mutable <a
+  href="../../property_map/doc/LvaluePropertyMap.html">Lvalue Property
+  Map</a>. The key type of the map must be the graph's edge descriptor
+  type.<br>
+  <b>Default:</b> <tt>get(edge_residual_capacity, g)</tt>
+</blockquote>
+
+IN: <tt>reverse_edge_map(ReverseEdgeMap rev)</tt>
+<blockquote>
+  An edge property map that maps every edge <i>(u,v)</i> in the graph
+  to the reverse edge <i>(v,u)</i>. The map must be a model of
+  constant <a href="../../property_map/doc/LvaluePropertyMap.html">Lvalue
+  Property Map</a>. The key type of the map must be the graph's edge
+  descriptor type.<br>
+  <b>Default:</b> <tt>get(edge_reverse, g)</tt>
+</blockquote>
+
+IN: <tt>weight_map(WeightMap w_map)</tt>   
+<blockquote>
+  The weight or ``cost'' of each edge in the graph. The weights
+  must all be non-negative, and the algorithm will throw a
+  <a href="./exception.html#negative_edge"><tt>negative_edge</tt></a> 
+  exception if one of the edges is negative.
+  The type <tt>WeightMap</tt> must be a model of
+  <a href="../../property_map/doc/ReadablePropertyMap.html">Readable Property Map</a>. The edge descriptor type of
+  the graph needs to be usable as the key type for the weight
+  map. The value type for this map must be
+  the same as the value type of the distance map.<br>
+  <b>Default:</b>  <tt>get(edge_weight, g)</tt><br>
+
+</blockquote>
+
+UTIL: <tt>predecessor_map(PredEdgeMap pred)</tt>
+<blockquote>
+  Use by the algorithm to store augmenting paths. The map must be a
+  model of mutable <a
+  href="../../property_map/doc/LvaluePropertyMap.html">Lvalue Property Map</a>.
+  The key type must be the graph's vertex descriptor type and the
+  value type must be the graph's edge descriptor type.<br>
+
+  <b>Default:</b> an <a
+  href="../../property_map/doc/iterator_property_map.html">
+  <tt>iterator_property_map</tt></a> created from a <tt>std::vector</tt>
+  of edge descriptors of size <tt>num_vertices(g)</tt> and
+  using the <tt>i_map</tt> for the index map.
+</blockquote>
+
+UTIL: <tt>distance_map(DistanceMap d_map)</tt> 
+<blockquote>
+  The shortest path weight from the source vertex <tt>s</tt> to each
+  vertex in the graph <tt>g</tt> is recorded in this property map. The
+  shortest path weight is the sum of the edge weights along the
+  shortest path.  The type <tt>DistanceMap</tt> must be a model of <a
+  href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write
+  Property Map</a>. The vertex descriptor type of the graph needs to
+  be usable as the key type of the distance map. 
+
+  <b>Default:</b> <a
+  href="../../property_map/doc/iterator_property_map.html">
+  <tt>iterator_property_map</tt></a> created from a
+  <tt>std::vector</tt> of the <tt>WeightMap</tt>'s value type of size
+  <tt>num_vertices(g)</tt> and using the <tt>i_map</tt> for the index
+  map.<br>
+
+</blockquote>
+
+UTIL: <tt>distance_map2(DistanceMap2 d_map2)</tt> 
+<blockquote>
+  The shortest path computation in iteration nr <i>k</i> uses distances computed in iteration <i>k</i>.
+  The type <tt>DistanceMap2</tt> must be a model of <a
+  href="../../property_map/doc/ReadWritePropertyMap.html">Read/Write
+  Property Map</a>. The vertex descriptor type of the graph needs to
+  be usable as the key type of the distance map. 
+
+  <b>Default:</b> <a
+  href="../../property_map/doc/iterator_property_map.html">
+  <tt>iterator_property_map</tt></a> created from a
+  <tt>std::vector</tt> of the <tt>WeightMap</tt>'s value type of size
+  <tt>num_vertices(g)</tt> and using the <tt>i_map</tt> for the index
+  map.<br>
+
+</blockquote>
+
+IN: <tt>vertex_index_map(VertexIndexMap i_map)</tt>
+<blockquote>
+  Maps each vertex of the graph to a unique integer in the range
+  <tt>[0, num_vertices(g))</tt>. This property map is only needed
+  if the default for the distance or distance2 or predecessor map is used.
+  The vertex index map must be a model of <a
+  href="../../property_map/doc/ReadablePropertyMap.html">Readable Property
+  Map</a>. The key type of the map must be the graph's vertex
+  descriptor type.<br>
+  <b>Default:</b> <tt>get(vertex_index, g)</tt>
+    Note: if you use this default, make sure your graph has
+    an internal <tt>vertex_index</tt> property. For example,
+    <tt>adjacenty_list</tt> with <tt>VertexList=listS</tt> does
+    not have an internal <tt>vertex_index</tt> property.
+</blockquote>
+
+
+<h3>Complexity</h3>
+In the integer capacity case, if <i>U</i> is the value of the max flow, then the complexity is <i> O(U * (|E| + |V|*log|V|))</i>, 
+where <i>O(|E| + |V|*log|V|)</i> is the complexity of the dijkstra algorithm and <i>U</i> is upper bound on number of iteration.
+In many real world cases number of iterations is much smaller than <i>U</i>.
+
+
+<h3>Example</h3>
+
+The program in <a
+href="../example/successive_shortest_path_nonnegative_weights_example.cpp"><tt>example/successive_shortest_path_nonnegative_weights_example.cpp</tt></a>.
+
+<h3>See Also</h3>
+
+<a href="./cycle_canceling.html"><tt>cycle_canceling()</tt></a><br>
+<a href="./find_flow_cost.html"><tt>find_flow_cost()</tt></a>.
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2013</TD><TD>
+Piotr Wygocki, University of Warsaw (<A HREF="mailto:wygos@mimuw.edu.pl">wygos at mimuw.edu.pl</A>)
+</TD></TR></TABLE>
+
+</BODY>
+</HTML> 
+<!--  LocalWords:  HTML Siek Edmonds BGCOLOR ffffff ee VLINK ALINK ff IMG SRC
+ -->
+<!--  LocalWords:  gif ALT BR sec edmonds karp TT DIV CELLPADDING TR TD PRE lt
+ -->
+<!--  LocalWords:  typename VertexListGraph CapacityEdgeMap ReverseEdgeMap gt
+ -->
+<!--  LocalWords:  ResidualCapacityEdgeMap VertexIndexMap src rev ColorMap pred
+ -->
+<!--  LocalWords:  PredEdgeMap tt href html hpp ul li nbsp br LvaluePropertyMap
+ -->
+<!--  LocalWords:  num ColorValue DIMACS cpp pre config iostream dimacs int std
+ -->
+<!--  LocalWords:  namespace vecS directedS cout endl iter ei HR valign nowrap
+ -->
+<!--  LocalWords:  jeremy siek htm Univ mailto jsiek lsc edu
+p -->
+
diff --git a/doc/table_of_contents.html b/doc/table_of_contents.html
index 8c0783f98..9e0e9ec78 100644
--- a/doc/table_of_contents.html
+++ b/doc/table_of_contents.html
@@ -90,6 +90,7 @@ <h1>Table of Contents: the Boost Graph Library
         <li>Event Visitors
           <OL>
             <LI><a href="predecessor_recorder.html"><tt>predecessor_recorder</tt></a>
+            <LI><a href="edge_predecessor_recorder.html"><tt>edge_predecessor_recorder</tt></a>
             <LI><a href="distance_recorder.html"><tt>distance_recorder</tt></a>
             <LI><a href="time_stamper.html"><tt>time_stamper</tt></a>
             <LI><a href="property_writer.html"><tt>property_writer</tt></a>
@@ -100,6 +101,10 @@ <h1>Table of Contents: the Boost Graph Library
         <LI>Graph classes
           <OL>
             <LI><A href="./adjacency_list.html"><tt>adjacency_list</tt></a></li>
+              <OL>
+               <LI><A href="./directed_graph.html"><tt>directed_graph</tt></a></li>
+               <LI><A href="./undirected_graph.html"><tt>undirected_graph</tt></a></li>
+              </OL>
             <LI><A href="./adjacency_matrix.html"><tt>adjacency_matrix</tt></a></li>
             <li><a href="compressed_sparse_row.html"><tt>compressed_sparse_row_graph</tt></a></li>
           </OL></li>
@@ -167,7 +172,7 @@ <h1>Table of Contents: the Boost Graph Library
           href="./johnson_all_pairs_shortest.html"><tt>johnson_all_pairs_shortest_paths</tt></A>
           <li><a href="floyd_warshall_shortest.html"><tt>floyd_warshall_all_pairs_shortest_paths</tt></a></li>
           <li><a href="r_c_shortest_paths.html"><tt>r_c_shortest_paths</tt> - resource-constrained shortest paths</a></li>
-          <li><a href="astar_search.html"><tt>astar_search</tt></a></li>
+          <li><a href="astar_search.html"><tt>astar_search</tt> (A* search algorithm)</a></li>
         </OL>
       <LI>Minimum Spanning Tree Algorithms
         <OL>
@@ -181,6 +186,11 @@ <h1>Table of Contents: the Boost Graph Library
           <LI><A
           href="./random_spanning_tree.html"><tt>random_spanning_tree</tt></A>
         </OL>
+      <LI>Algorithm for Common Spanning Trees of Two Graphs
+        <OL>
+          <LI><A
+          href="./two_graphs_common_spanning_trees.html"><tt>two_graphs_common_spanning_trees</tt></A>
+        </OL>
       <LI>Connected Components Algorithms
       <OL>
           <LI><A href="./connected_components.html"><tt>connected_components</tt></A>
@@ -201,16 +211,19 @@ <h1>Table of Contents: the Boost Graph Library
                 <OL>
                   <LI><A href="edmonds_karp_max_flow.html"><tt>edmonds_karp_max_flow</tt></A>
                   <LI><A href="push_relabel_max_flow.html"><tt>push_relabel_max_flow</tt></A>
-                  <li>
-                    <a href="kolmogorov_max_flow.html"><tt>kolmogorov_max_flow</tt></a> (<em>Deprecated</em>.
-                    Use <a href="boykov_kolmogorov_max_flow.html"><tt>boykov_kolmogorov_max_flow</tt></a>
-                    instead.)
-                  </li>
                   <li><a href="boykov_kolmogorov_max_flow.html"><tt>boykov_kolmogorov_max_flow</tt></a></li>
                   <LI><A href="maximum_matching.html"><tt>edmonds_maximum_cardinality_matching</tt></A>
+                </OL>
+              <LI>Minimum Cost Maximum Flow Algorithms
+                <OL>
+                  <LI><A href="cycle_canceling.html"><tt>cycle_canceling</tt></A>
+                  <LI><A href="successive_shortest_path_nonnegative_weights.html"><tt>successive_shortest_path_nonnegative_weights</tt></A>
+                  <li><a href="find_flow_cost.html"><tt>find_flow_cost</tt></a></li>
+                </OL>
+              <LI>Minimum Cut Algorithms
+                <OL>
                   <LI><A href="stoer_wagner_min_cut.html"><tt>stoer_wagner_min_cut</tt></A>
                 </OL>
-
               <li>Sparse Matrix Ordering Algorithms
                 <ol>
                   <LI><A
@@ -233,6 +246,7 @@ <h1>Table of Contents: the Boost Graph Library
               <li>Graph Structure Comparisons
                 <ol>
                   <LI><A href="isomorphism.html"><tt>isomorphism</tt></A>
+                  <LI><A href="vf2_sub_graph_iso.html"><tt>vf2_sub_graph_iso</tt> (VF2 subgraph isomorphism algorithm)</A>
                   <li><a href="mcgregor_common_subgraphs.html"><tt>mcgregor_common_subgraphs</tt></a></li>
                 </ol>
 
@@ -276,9 +290,12 @@ <h1>Table of Contents: the Boost Graph Library
               <li>Miscellaneous Algorithms
                   <ol>
                       <li><a href="metric_tsp_approx.html"><tt>metric_tsp_approx</tt></a></li>
-                      <LI><A href="sequential_vertex_coloring.html"><tt>sequential_vertex_coloring</tt></A>
-                      <LI><A href="is_bipartite.html"><tt>is_bipartite</tt></A> (including two-coloring of bipartite graphs)
-                      <LI><A href="find_odd_cycle.html"><tt>find_odd_cycle</tt></A>
+                      <LI><A href="sequential_vertex_coloring.html"><tt>sequential_vertex_coloring</tt></A></li>
+                      <LI><A href="edge_coloring.html"><tt>edge_coloring</tt></A></li>
+                      <LI><A href="is_bipartite.html"><tt>is_bipartite</tt></A> (including two-coloring of bipartite graphs)</li>
+                      <LI><A href="find_odd_cycle.html"><tt>find_odd_cycle</tt></A></li>
+                      <LI><A href="maximum_adjacency_search.html"><tt>maximum_adjacency_search</tt></A></li>
+                      <LI><A href="hawick_circuits.html"><tt>hawick_circuits</tt></A> (find all circuits of a directed graph)</li>
                   </ol>
               </li>
 
diff --git a/doc/topology.html b/doc/topology.html
index 24271c0c7..57f53e57c 100644
--- a/doc/topology.html
+++ b/doc/topology.html
@@ -124,8 +124,8 @@ <h3>Summary</h3>
   struct point 
   {
     point() { }
-    double& operator[](std::size_t i) {return values[i];}
-    const double& operator[](std::size_t i) const {return values[i];}
+    double&amp; operator[](std::size_t i) {return values[i];}
+    const double&amp; operator[](std::size_t i) const {return values[i];}
 
   private:
     double values[Dims];
@@ -157,7 +157,7 @@ <h3>Summary</h3>
 {
 public:
   explicit hypercube_topology(double scaling = 1.0);
-  hypercube_topology(RandomNumberGenerator& gen, double scaling = 1.0);
+  hypercube_topology(RandomNumberGenerator&amp; gen, double scaling = 1.0);
   point_type random_point() const;
 };
 </pre>
@@ -173,13 +173,13 @@ <h3>Summary</h3>
 {
  public:
   explicit square_topology(double scaling = 1.0);
-  square_topology(RandomNumberGenerator& gen, double scaling = 1.0);
+  square_topology(RandomNumberGenerator&amp; gen, double scaling = 1.0);
 };
 </pre>
 
 <a name="cube_topology"><h3>Class template <tt>cube_topology</tt></h3></a>
 
-<p>Class template <tt>cube_topology</tt> is a two-dimensional
+<p>Class template <tt>cube_topology</tt> is a three-dimensional
 hypercube topology.
 
 <pre>
@@ -188,7 +188,7 @@ <h3>Summary</h3>
 {
  public:
   explicit cube_topology(double scaling = 1.0);
-  cube_topology(RandomNumberGenerator& gen, double scaling = 1.0);
+  cube_topology(RandomNumberGenerator&amp; gen, double scaling = 1.0);
 };
 </pre>
 
@@ -209,7 +209,7 @@ <h3>Summary</h3>
 {
 public:
   explicit ball_topology(double radius = 1.0);
-  ball_topology(RandomNumberGenerator& gen, double radius = 1.0); 
+  ball_topology(RandomNumberGenerator&amp; gen, double radius = 1.0); 
   point_type random_point() const;
 };
 </pre>
@@ -225,13 +225,13 @@ <h3>Summary</h3>
 {
  public:
   explicit circle_topology(double radius = 1.0);
-  circle_topology(RandomNumberGenerator& gen, double radius = 1.0);
+  circle_topology(RandomNumberGenerator&amp; gen, double radius = 1.0);
 };
 </pre>
 
 <a name="sphere_topology"><h3>Class template <tt>sphere_topology</tt></h3></a>
 
-<p>Class template <tt>sphere_topology</tt> is a two-dimensional
+<p>Class template <tt>sphere_topology</tt> is a three-dimensional
 ball topology.
 
 <pre>
@@ -240,7 +240,7 @@ <h3>Summary</h3>
 {
  public:
   explicit sphere_topology(double radius = 1.0);
-  sphere_topology(RandomNumberGenerator& gen, double radius = 1.0);
+  sphere_topology(RandomNumberGenerator&amp; gen, double radius = 1.0);
 };
 </pre>
 
@@ -258,7 +258,7 @@ <h3>Summary</h3>
   typedef <em>unspecified</em> point_type;
 
   heart_topology();
-  heart_topology(RandomNumberGenerator& gen);
+  heart_topology(RandomNumberGenerator&amp; gen);
   point_type random_point() const;
   double distance(point_type a, point_type b) const;
   point_type move_position_toward(point_type a, double fraction, point_type b) const;
diff --git a/doc/transitive_closure.w b/doc/transitive_closure.w
index c8db56dc9..136eab681 100644
--- a/doc/transitive_closure.w
+++ b/doc/transitive_closure.w
@@ -160,11 +160,11 @@ algorithm.
 
 @d Concept checking
 @{
-function_requires< VertexListGraphConcept<Graph> >();
-function_requires< AdjacencyGraphConcept<Graph> >();
-function_requires< VertexMutableGraphConcept<GraphTC> >();
-function_requires< EdgeMutableGraphConcept<GraphTC> >();
-function_requires< ReadablePropertyMapConcept<VertexIndexMap, vertex> >();
+BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+BOOST_CONCEPT_ASSERT(( VertexMutableGraphConcept<GraphTC> ));
+BOOST_CONCEPT_ASSERT(( EdgeMutableGraphConcept<GraphTC> ));
+BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<VertexIndexMap, vertex> ));
 @}
 
 \noindent To simplify the code in the rest of the function we make the
@@ -566,8 +566,8 @@ void warshall_transitive_closure(G& g)
   typedef typename graph_traits<G>::vertex_descriptor vertex;
   typedef typename graph_traits<G>::vertex_iterator vertex_iterator;
 
-  function_requires< AdjacencyMatrixConcept<G> >();
-  function_requires< EdgeMutableGraphConcept<G> >();
+  BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept<G> ));
+  BOOST_CONCEPT_ASSERT(( EdgeMutableGraphConcept<G> ));
 
   // Matrix form:
   // for k
@@ -597,8 +597,8 @@ void warren_transitive_closure(G& g)
   typedef typename graph_traits<G>::vertex_descriptor vertex;
   typedef typename graph_traits<G>::vertex_iterator vertex_iterator;
 
-  function_requires< AdjacencyMatrixConcept<G> >();
-  function_requires< EdgeMutableGraphConcept<G> >();
+  BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept<G> ));
+  BOOST_CONCEPT_ASSERT(( EdgeMutableGraphConcept<G> ));
 
   // Make sure second loop will work  
   if (num_vertices(g) == 0)
@@ -671,6 +671,7 @@ indent -nut -npcs -i2 -br -cdw -ce transitive_closure.hpp
 #include <boost/graph/topological_sort.hpp>
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/named_function_params.hpp>
+#include <boost/concept/assert.hpp>
 
 namespace boost {
 
diff --git a/doc/two_graphs_common_spanning_trees.html b/doc/two_graphs_common_spanning_trees.html
new file mode 100644
index 000000000..f06825b04
--- /dev/null
+++ b/doc/two_graphs_common_spanning_trees.html
@@ -0,0 +1,143 @@
+<html>
+<!--
+          Copyright (C) 2012, Michele Caini.
+ Distributed under the Boost Software License, Version 1.0.
+    (See accompanying file LICENSE_1_0.txt or copy at
+          http://www.boost.org/LICENSE_1_0.txt)
+
+          Two Graphs Common Spanning Trees Algorithm
+      Based on academic article of Mint, Read and Tarjan
+     Efficient Algorithm for Common Spanning Tree Problem
+ Electron. Lett., 28 April 1983, Volume 19, Issue 9, p.346–347
+-->
+<head>
+<title>Boost Graph Library: Two-Graphs Common Spanning Trees</title>
+<body bgcolo="#ffffff" link="#0000ee" text="#000000" vlink="#551a8b" alink="#ff0000">
+<img src="../../../boost.png" alt="C++ Boost" width="277" height="86">
+
+<br clear>
+
+<h1><tt><a name="sec:two-graphs-common-spanning-trees">Two-Graphs Common Spanning Trees (MRT Algorithm)</a></tt></h1>
+
+<p>
+The <b>MRT</b> algorithm, based on an academic article of <b>Mint</b>, <b>Read</b> and
+<b>Tarjan</b>, is an efficient algorithm for the common spanning tree problem.<br/>
+This kind of algorithm is widely used in electronics, being the basis of the
+analysis of electrical circuits. Another area of interest may be that of the
+networking.
+</p>
+
+<p>
+The proposed algorithm receives several arguments and works with callbacks.<br/>
+The prototypes are:
+</p>
+
+<p>
+<i>// Ordered Edges List</i>
+<pre>
+template &lt; typename Graph, typename Order, typename Func, typename Seq &gt;
+void two_graphs_common_spanning_trees
+  (
+    const Graph&amp; iG,
+    Order iG_map,
+    const Graph&amp; vG,
+    Order vG_map,
+    Func func,
+    Seq inL
+  )
+</pre>
+
+<i>// Unordered Edges List</i>
+<pre>
+template &lt; typename Graph, typename Func, typename Seq &gt;
+void two_graphs_common_spanning_trees
+  (
+    const Graph&amp; iG,
+    const Graph&amp; vG,
+    Func func,
+    Seq inL
+  )
+</pre>
+</p>
+
+<p>
+The problem of common spanning tree is easily described.<br/>
+Imagine we have two graphs that are represented as lists of edges. A common
+spanning tree is a set of indices that identifies a spanning tree for both
+the first and for the second of the two graphs. Despite it is easily accomplished
+with edge list representation for graphs, it is intuitively difficult to achieve
+with adjacency list representation. This is due to the fact that it is necessary
+to represent an edge with an absolute index.
+</p>
+<p>
+Note that the set of common spanning trees of the two graphs is a subset of
+the set of spanning trees of the first graph, as well as those of the second
+graph.
+</p>
+
+<h3>Where Defined</h3>
+
+<p>
+<a href="../../../boost/graph/two_graphs_common_spanning_trees.hpp"><TT>boost/graph/two_graphs_common_spanning_trees.hpp</TT></a>
+
+<h3>Parameters</h3>
+
+<tt>const Graph& iG, const Graph& vG</tt>
+<blockquote>
+These are the graphs to be analyzed.<br/>
+They must comply with the concepts VertexAndEdgeListGraphConcept and IncidenceGraphConcept.<br/>
+In addition, the directed_category should be of type undirected_tag.
+</blockquote>
+
+<tt>Order iG_map, Order vG_map</tt>
+<blockquote>
+These are lists of references to edges, that define the preferred order for access to the lists of edges.<br/>
+They must comply with the concept RandomAccessContainer.
+</blockquote>
+
+<tt>Func func</tt>
+<blockquote>
+This is a callback that is invoked by the algorithm for each common spanning tree found.<br/>
+It must comply with the concept UnaryFunction with void as return value, and an object of type <i>typeof(inL)</i> as argument.
+</blockquote>
+
+<tt>Seq inL<a href="#1">[1]</a></tt>
+<blockquote>
+This is the way in which the edges are marked as belonging to the common spanning tree.<br/>
+It must comply with the concept Mutable_RandomAccessContainer. In addition, the value_type should be of type bool.
+If the i-th edge or <i>inL[i]</i> is true, then it belongs to the common spanning tree, otherwise it does not belong.
+</blockquote>
+
+<h3>Example</h3>
+
+<p>
+The file
+<a href="../example/two_graphs_common_spanning_trees.cpp"><tt>examples/two_graphs_common_spanning_trees.cpp</tt></a>
+contains an example of finding common spanning trees of two undirected graphs.
+</p>
+
+<h3>Notes</h3>
+
+<p>
+<a name="1">[1]</a><br/>
+  The presence of <i>inL</i> may seem senseless. The algorithm can use a vector of
+  placeholders internally generated. However, doing so has more flexibility on
+  the callback function. Moreover, being largely involved in the electronics
+  world, there are cases where some edges have to be forced in every tree (ie
+  you want to search all the trees that have the same root): With this
+  solution, the problem is easily solved.<br/>
+  Intuitively from the above, <i>inL</i> must be of a size equal to <i>(V-1)</i>, where
+  <i>V</i> is the number of vertices of the graph.
+</p>
+
+<br/>
+<hr>
+<table>
+<tr valign=top>
+<td nowrap>Copyright &copy; 2012</td>
+<td>Michele Caini, (<a href="mailto:michele.caini@gmail.com">michele.caini@gmail.com</a>)</td>
+</tr>
+</table>
+
+</body>
+</html>
diff --git a/doc/undirected_dfs.html b/doc/undirected_dfs.html
index ffbefa286..78def89b0 100644
--- a/doc/undirected_dfs.html
+++ b/doc/undirected_dfs.html
@@ -7,7 +7,7 @@
      http://www.boost.org/LICENSE_1_0.txt)
   -->
 <Head>
-<Title>Boost Graph Library: Depth-First Search</Title>
+<Title>Boost Graph Library: Undirected Depth-First Search</Title>
 <BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b" 
         ALINK="#ff0000"> 
 <IMG SRC="../../../boost.png" 
@@ -116,6 +116,7 @@ <H1><A NAME="sec:depth-first-search"></A>
       <b>call</b> DFS-VISIT(<i>G</i>, <i>v</i>)
     <b>else if</b> (<i>vcolor[v] =</i> GRAY and <i>ec =</i> WHITE)
       <i>...</i>
+    <i>...</i>
   <b>end for</b>
   <i>vcolor[u] :=</i> BLACK
   <i>f_time[u] := time := time + 1</i> 
@@ -152,6 +153,8 @@ <H1><A NAME="sec:depth-first-search"></A>
 <i>(u,v)</i> is a back edge
 -
 -
+finish edge <i>(u,v)</i>
+-
 finish vertex <i>u</i>
 -
 </pre>
@@ -291,6 +294,9 @@ <h3>Visitor Event Points</h3>
 <li><b><tt>vis.back_edge(e, g)</tt></b> is invoked on the back edges in
   the graph. 
 
+<li><b><tt>vis.finish_edge(e, g)</tt></b> is invoked on the back edges in 
+  the graph as well as on each tree edge after its target vertex is finished. 
+
 <li><b><tt>vis.finish_vertex(u, g)</tt></b> is invoked on a vertex after
   all of its out edges have been added to the search tree and all of
   the adjacent vertices have been discovered (but before their
diff --git a/doc/undirected_graph.html b/doc/undirected_graph.html
new file mode 100644
index 000000000..09a55b0cb
--- /dev/null
+++ b/doc/undirected_graph.html
@@ -0,0 +1,96 @@
+<HTML>
+<!--
+     Copyright (c) David Doria 2012
+
+     Distributed under the Boost Software License, Version 1.0.
+     (See accompanying file LICENSE_1_0.txt or copy at
+     http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<Head>
+<Title>Boost Graph Library: Undirected Graph</Title>
+<BODY BGCOLOR="#ffffff" LINK="#0000ee" TEXT="#000000" VLINK="#551a8b"
+        ALINK="#ff0000">
+<IMG SRC="../../../boost.png"
+     ALT="C++ Boost" width="277" height="86">
+
+<BR Clear>
+
+<H1><A NAME="sec:undirected-graph-class"></A>
+<pre>
+undirected_graph&lt;VertexProp, EdgeProp, GraphProp&gt;
+</pre>
+</H1>
+
+
+<P>
+The <tt>undirected_graph</tt> class template is is a simplified version
+of the BGL adjacency list. This class is provided for ease of use, but
+may not perform as well as custom-defined adjacency list classes. Instances
+of this template model the BidirectionalGraph, VertexIndexGraph, and
+EdgeIndexGraph concepts.
+
+<H3>Example</H3>
+
+A simple example of creating an undirected_graph is available here <a href="../../../libs/graph/example/undirected_graph.cpp"><tt>libs/graph/example/undirected_graph.cpp</tt></a>
+<P>
+
+
+<PRE>
+  typedef boost::undirected_graph<> Graph;
+  Graph g;
+  boost::graph_traits<Graph>::vertex_descriptor v0 = g.add_vertex();
+  boost::graph_traits<Graph>::vertex_descriptor v1 = g.add_vertex();
+
+  g.add_edge(v0, v1);
+</PRE>
+
+<H3>Template Parameters</H3>
+
+<P>
+<TABLE border>
+<TR>
+<th>Parameter</th><th>Description</th><th>Default</th>
+</tr>
+
+<TR><TD><TT>VertexProp</TT></TD>
+<TD>A property map for the graph vertices.</TD>
+<TD>&nbsp;</TD>
+</TR>
+
+<TR>
+<TD><TT>EdgeProp</TT></TD>
+<TD>A property map for the graph edges.</TD>
+<TD>&nbsp;</TD>
+</TR>
+
+<TR>
+<TD><TT>GraphProp</TT></TD>
+<TD>A property map for the graph itself.</TD>
+</TR>
+
+</TABLE>
+<P>
+
+<H3>Where Defined</H3>
+
+<P>
+<a href="../../../boost/graph/undirected_graph.hpp"><TT>boost/graph/undirected_graph.hpp</TT></a>
+
+<P>
+
+<br>
+<HR>
+<TABLE>
+<TR valign=top>
+<TD nowrap>Copyright &copy; 2000-2001</TD><TD>
+<A HREF="http://www.boost.org/people/jeremy_siek.htm">Jeremy Siek</A>,
+Indiana University (<A
+HREF="mailto:jsiek@osl.iu.edu">jsiek@osl.iu.edu</A>)<br>
+<A HREF="http://www.boost.org/people/liequan_lee.htm">Lie-Quan Lee</A>, Indiana University (<A HREF="mailto:llee@cs.indiana.edu">llee@cs.indiana.edu</A>)<br>
+<A HREF="http://www.osl.iu.edu/~lums">Andrew Lumsdaine</A>,
+Indiana University (<A
+HREF="mailto:lums@osl.iu.edu">lums@osl.iu.edu</A>)
+</TD></TR></TABLE>
+
+</BODY>
+</HTML>
diff --git a/doc/using_adjacency_list.html b/doc/using_adjacency_list.html
index 03206ecc3..efcb40f12 100644
--- a/doc/using_adjacency_list.html
+++ b/doc/using_adjacency_list.html
@@ -71,7 +71,7 @@ <H2><A NAME="SECTION00831000000000000000"></A>
 <LI><TT>slistS</TT> selects <TT>std::slist</TT>.</LI>
 <LI><TT>setS</TT> selects <TT>std::set</TT>.</LI>
 <LI><TT>multisetS</TT> selects <TT>std::multiset</TT>.</LI>
-<LI><TT>hash_setS</TT> selects <TT>std::hash_set</TT>.</LI>
+<LI><TT>hash_setS</TT> selects <TT>boost::unordered_set</TT>.</LI>
 </UL>
 
 <P>
@@ -326,7 +326,7 @@ <H2><a name="sec:directed-and-undirected">Directed and Undirected Adjacency List
 graph.  See Section <A
 HREF="graph_concepts.html#sec:undirected-graphs">Undirected Graphs</A>
 for a description of the difference between directed and undirected
-graphs in BGL.  The <TT>bidirectealS</TT> selector specifies that the
+graphs in BGL.  The <TT>bidirectionalS</TT> selector specifies that the
 graph will provide the <TT>in_edges()</TT> function as well as the
 <TT>out_edges()</TT> function. This imposes twice as much space
 overhead per edge, which is why <TT>in_edges()</TT> is optional.
diff --git a/doc/using_property_maps.html b/doc/using_property_maps.html
index 451e858e1..661e66e05 100644
--- a/doc/using_property_maps.html
+++ b/doc/using_property_maps.html
@@ -219,7 +219,7 @@ <H2><A NAME="sec:exterior-properties"></A>
 
 <P>
 The first method uses the adaptor class
-<TT>random_access_iterator_property_map</TT>. This
+<TT>iterator_property_map</TT>. This
 class wraps a random access iterator, creating a property map out
 of it. The random access iterator must point to the beginning of a
 range of property values, and the length of the range must be the
@@ -229,7 +229,7 @@ <H2><A NAME="sec:exterior-properties"></A>
 edge descriptor to the offset of the property value (offset from the
 random access iterator). The ID property map will typically be an
 interior property map of the graph.  The following example shows
-how the <TT>random_access_iterator_property_map</TT>
+how the <TT>iterator_property_map</TT>
 can be used to create exterior property maps for the capacity and flow properties, which are stored in arrays. The arrays are
 indexed by edge ID. The edge ID is added to the graph using a property,
 and the values of the ID's are given when each edge is added to the
@@ -257,7 +257,7 @@ <H2><A NAME="sec:exterior-properties"></A>
   typedef property_map&lt;Graph, edge_index_t&gt;::type EdgeID_Map;
   EdgeID_Map edge_id = get(edge_index, G);
 
-  random_access_iterator_property_map
+  iterator_property_map
     &lt;int*, int, int&amp;, EdgeID_Map&gt; 
       capacity(capacity_array, edge_id), 
       flow(flow_array, edge_id);
@@ -276,7 +276,7 @@ <H2><A NAME="sec:exterior-properties"></A>
 <TT>VertexList</TT> is not <TT>vecS</TT>, then the vertex descriptor is
 not an integer, and cannot be used with a pointer property map.
 Instead the method described above of using a
-<TT>random_access_iterator_property_map</TT> with an ID
+<TT>iterator_property_map</TT> with an ID
 property must be used. The <TT>edge_list</TT> class may also use an
 integer type for the vertex descriptor, depending on how the adapted
 edge iterator is defined. The example in
@@ -388,10 +388,10 @@ <H2><A NAME="sec:custom-exterior-property-maps"></A>
 
 <P>
 The implementation of the
-<TT>random_access_iterator_property_map</TT> class
+<TT>iterator_property_map</TT> class
 serves as a good example for how to build and exterior property
 map. Here we present a simplified implementation of the
-<TT>random_access_iterator_property_map</TT> class
+<TT>iterator_property_map</TT> class
 which we will name <TT>iterator_pa</TT>.
 
 <P>
@@ -462,7 +462,7 @@ <H2><A NAME="sec:custom-exterior-property-maps"></A>
 <P>
 That is it. The <TT>iterator_map</TT> class is complete and could be
 used just like the
-<TT>random_access_iterator_property_map</TT> in the
+<TT>iterator_property_map</TT> in the
 previous section.
 
 <P>
diff --git a/doc/vf2_sub_graph_iso.html b/doc/vf2_sub_graph_iso.html
new file mode 100755
index 000000000..95ea9496b
--- /dev/null
+++ b/doc/vf2_sub_graph_iso.html
@@ -0,0 +1,531 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
+          "http://www.w3.org/TR/html4/strict.dtd">
+<!--
+    Copyright (C) Flavio De Lorenzi 2012 
+    
+    Distributed under the Boost Software License, Version 1.0.
+    (See accompanying file LICENSE_1_0.txt or copy at
+    http://www.boost.org/LICENSE_1_0.txt)
+  -->
+<html>
+  <head>
+    <meta http-equiv="content-type" content="text/html; charset=iso-8859-15">
+    <title>Boost Graph Library: VF2 (Sub)Graph Isomorphism</title>
+    <style type="text/css">
+      <!--
+          body {
+          color: black;
+          background-color: white;
+          }
+          
+          .comment {
+          color: #333333;
+          }
+          
+          a {
+          color: blue;
+          }
+          
+          a:visited {
+          color: #551A8B;
+          }
+        -->
+    </style>
+  </head>
+  <body>
+    <p><img src="../../../boost.png" alt="C++ Boost" width="277" height="86"></p>
+    <h1>
+      <tt>vf2_subgraph_iso</tt>
+    </h1>
+    <pre>
+<em class="comment">// All defaults interface</em>
+template &lt;typename GraphSmall,
+          typename GraphLarge,
+          typename SubGraphIsoMapCallback&gt;
+bool vf2_subgraph_iso(const GraphSmall&amp; graph_small,
+                      const GraphLarge&amp; graph_large, 
+                      SubGraphIsoMapCallback user_callback)
+
+
+<em class="comment">// Named parameter version</em>
+template &lt;typename GraphSmall,
+          typename GraphLarge,
+          typename VertexOrderSmall,
+          typename SubGraphIsoMapCallback,
+          typename Param,
+          typename Tag,
+          typename Rest&gt;
+bool vf2_subgraph_iso(const GraphSmall&amp; graph_small,
+                      const GraphLarge&amp; graph_large,
+                      SubGraphIsoMapCallback user_callback,
+                      const VertexOrderSmall&amp; vertex_order_small,
+                      const bgl_named_params&lt;Param, Tag, Rest&gt;&amp; params)
+
+
+<em class="comment">// Non-named parameter version</em>
+template &lt;typename GraphSmall,
+          typename GraphLarge,
+          typename <a href="../../property_map/doc/ReadablePropertyMap.html">IndexMapSmall</a>,
+          typename <a href="../../property_map/doc/ReadablePropertyMap.html">IndexMapLarge</a>,
+          typename VertexOrderSmall,
+          typename <a href="http://www.sgi.com/tech/stl/BinaryFunction.html">EdgeEquivalencePredicate</a>,
+          typename <a href="http://www.sgi.com/tech/stl/BinaryFunction.html">VertexEquivalencePredicate</a>,
+          typename SubGraphIsoMapCallback&gt;
+bool vf2_subgraph_iso(const GraphSmall&amp; graph_small,
+                      const GraphLarge&amp; graph_large,
+                      SubGraphIsoMapCallback user_callback,
+                      IndexMapSmall index_map_small,
+                      IndexMapLarge index_map_large, 
+                      const VertexOrderSmall&amp; vertex_order_small,
+                      EdgeEquivalencePredicate edge_comp,
+                      VertexEquivalencePredicate vertex_comp)
+    </pre>
+    <p>
+      An isomorphism between two graphs <em>G<sub>1</sub>=(V<sub>1</sub>, E<sub>1</sub>)</em> 
+      and <em>G<sub>2</sub>=(V<sub>2</sub>, E<sub>2</sub>)</em> is a
+      bijective mapping <em>M</em> of the vertices of one graph to vertices of the other
+      graph that preserves the edge structure of the graphs. <em>M</em> is said to be a
+      graph-subgraph isomorphism if and only if <em>M</em> is an isomorphism between 
+      <em>G<sub>1</sub></em> and a subgraph of <em>G<sub>2</sub></em>.
+      An induced subgraph of a graph <em>G = (V, E)</em> is a normal subgraph
+      <em>G' = (V', E')</em> with the extra condition that all edges of <em>G</em>
+      which have both endpoints in <em>V'</em> are in <em>E'</em>.
+    </p>
+    
+    <p>
+      This function finds all induced subgraph isomorphisms between
+      graphs <tt>graph_small</tt> and <tt>graph_large</tt> and outputs them to
+      <tt>user_callback</tt>. It continues until <tt>user_callback</tt>
+      returns false or the search space has been fully explored. <tt>vf2_subgraph_iso</tt>
+      returns true if a graph-subgraph isomorphism exists and false otherwise.
+      <tt>EdgeEquivalencePredicate</tt> and
+      <tt>VertexEquivalencePredicate</tt> predicates are used to test whether
+      edges and vertices are equivalent. To use property maps for equivalence,
+      see 
+      <tt><a href="./mcgregor_common_subgraphs.html#make_property_map_equivalent">
+          make_property_map_equivalent</a></tt>
+      function. By default <tt><a href="./mcgregor_common_subgraphs.html#always_equivalent">
+          always_equivalent</a></tt> is used, which returns
+      true for any pair of vertices or edges.
+    </p>
+    <p>
+      The current implementation is based on the <em>VF2</em> algorithm,
+      introduced by Cordella et al. An in-depth description of the algorithm is
+      given in [<a href="#cordella2001">1</a>] and [<a href="#cordella2004">2</a>]
+      and references therein. The original code by P. Foggia and collaborators can 
+      be found at [<a href="#foggia_etal">3</a>]. In brief, the process of 
+      finding a mapping between the two graphs <em>G<sub>1</sub></em> and
+      <em>G<sub>2</sub></em> determines the isomorphism mapping <em>M</em>,
+      which associates vertices <em>G<sub>1</sub></em> with vertices of
+      <em>G<sub>2</sub></em> and vice versa. It can be described by means of a
+      state space representation which is created by the algorithm
+      while exploring the search graph in depth-first fashion. 
+      Each state <em>s</em> of the matching process
+      can be associated with a partial mapping <em>M(s)</em>.  At each level,
+      the algorithm computes the set of the vertex pairs that are candidates to
+      be added to the current state <em>s</em>. If a pair of vertices 
+      (<em>v, w</em>) is feasible, the mapping is extended and the associated
+      successor state <em>s'</em> is computed.
+      The whole procedure is then repeated for state <em>s'</em>.
+    </p>
+
+    <h3>Where Defined</h3>
+    <p>
+      <a href="../../../boost/graph/vf2_sub_graph_iso.hpp">
+        <tt>boost/graph/vf2_sub_graph_iso.hpp</tt></a><br>
+      All functions are defined in the boost namespace.
+    </p>
+    
+    <h3>Parameters</h3>
+  
+    <p>IN: <tt>const GraphSmall&amp; graph_small</tt></p>
+    <blockquote>
+      <p>
+        The (first) smaller graph (fewer vertices) of the pair to be tested for 
+        isomorphism. The type <tt>GraphSmall</tt> must be a
+        model of 
+        <a href="./VertexListGraph.html">Vertex List Graph</a>,
+        <a href="./EdgeListGraph.html">Edge List Graph</a>,
+        <a href="./BidirectionalGraph.html">Bidirectional Graph</a> and
+        <a href="./AdjacencyMatrix.html">Adjacency Matrix</a>.
+        The edge descriptors <tt>graph_traits&lt;GraphSmall&gt;::edge_descriptor</tt>
+        must be <a href="http://www.sgi.com/tech/stl/LessThanComparable.html">
+        LessThan Comparable</a>, cf. also the remark <a href="#notes">below</a>.
+      </p>
+    </blockquote>
+
+    <p>IN: <tt>const GraphLarge&amp; graph_large</tt></p>
+    <blockquote>
+      <p>
+        The (second) larger graph to be tested.
+        Type <tt>GraphLarge</tt> must be a model of 
+        <a href="./VertexListGraph.html">Vertex List Graph</a>,
+        <a href="./EdgeListGraph.html">Edge List Graph</a>,
+        <a href="./BidirectionalGraph.html">Bidirectional Graph</a> and
+        <a href="./AdjacencyMatrix.html">Adjacency Matrix</a>.
+        The edge descriptors <tt>graph_traits&lt;GraphLarge&gt;::edge_descriptor</tt>
+        must be <a href="http://www.sgi.com/tech/stl/LessThanComparable.html">
+        LessThan Comparable</a>, cf. also the remark <a href="#notes">below</a>. 
+      </p>
+    </blockquote>
+    
+    <p>OUT: <tt>SubGraphIsoMapCallback  user_callback</tt></p>
+    <blockquote>
+      <p>
+        A function object to be called when a graph-subgraph isomorphism has been discovered. The
+        <tt>operator()</tt> must have following form:
+      </p>
+      <pre>
+template &lt;typename CorrespondenceMap1To2,
+          typename CorrespondenceMap2To1&gt;
+bool operator()(CorrespondenceMap1To2 f, CorrespondenceMap2To1 g) const
+      </pre>
+      <p>
+        Both the <tt>CorrespondenceMap1To2</tt>
+        and <tt>CorresondenceMap2To1</tt> types are models
+        of <a href="../../property_map/doc/ReadablePropertyMap.html">Readable
+          Property Map</a> and map equivalent vertices across the two
+        graphs given to <tt>vf2_subgraph_iso</tt> (or <tt>vf2_graph_iso</tt> or
+        <tt>vf2_subgraph_mono</tt>). For instance, if <tt>v</tt> is
+        from <tt>graph_small</tt>, <tt>w</tt> is from <tt>graph_large</tt>,
+        and the vertices can be considered equivalent,
+        then <tt>get(f, v)</tt> will be <tt>w</tt> and <tt>get(g, w)</tt> 
+        will be <tt>v</tt>. If any vertex, say <tt>v</tt> in <tt>graph_small</tt>, 
+        does not match a vertex in <tt>graph_large</tt> ,
+        then <tt>get(f, v)</tt> will be <tt>graph_traits&lt;GraphLarge&gt;::null_vertex()</tt>.
+        Likewise for any unmatched vertices from <tt>graph_large</tt>,
+        <tt>get(g, w)</tt> will be <tt>graph_traits&lt;GraphSmall&gt;::null_vertex()</tt>.
+
+        Returning false from the callback will abort the search immediately. Otherwise,
+        the entire search space will be explored. A "default" print callback 
+        is provided as a <a href="#vf2_callback">utility function</a>.
+        </p>
+    </blockquote>
+
+    <p>IN: <tt>const VertexOrderSmall&amp; vertex_order_small</tt></p>
+    <blockquote>
+      <p>
+        The ordered vertices of the smaller (first) graph <tt>graph_small</tt>.
+        During the matching process the vertices are examined in the order given by
+        <tt>vertex_order_small</tt>. Type <tt>VertexOrderSmall</tt> must be a model 
+        of <a href="http://www.sgi.com/tech/stl/Container.html">ContainerConcept</a> 
+        with value type 
+        <tt>graph_traits&lt;GraphSmall&gt;::vertex_descriptor</tt>.
+        <br>
+        <b>Default</b> The vertices are ordered by multiplicity of
+        in/out degrees.
+      </p>
+    </blockquote>
+    
+    <h3>Named Parameters</h3>
+    
+    <p>IN: <tt>vertex_index1(IndexMapSmall index_map_small)</tt></p>  
+    <blockquote>
+      <p>
+        This maps each vertex to an integer in the range <tt>[0, num_vertices(graph_small))</tt>.
+        Type <tt>IndexMapSmall</tt> must be a model of 
+        <a href="../../property_map/doc/ReadablePropertyMap.html">Readable Property Map</a>.
+        <br>
+        <b>Default:</b> <tt>get(vertex_index, graph_small)</tt>
+      </p>
+    </blockquote>
+
+    <p>IN: <tt>vertex_index2(IndexMapLarge index_map_large)</tt></p>  
+    <blockquote>
+      <p>
+        This maps each vertex to an integer in the range <tt>[0, num_vertices(graph_large))</tt>.
+        Type <tt>IndexMapLarge</tt> must be a model of
+        <a href="../../property_map/doc/ReadablePropertyMap.html">Readable Property Map</a>.
+        <br>
+        <b>Default:</b> <tt>get(vertex_index, graph_large)</tt>
+      </p>
+    </blockquote>
+    
+    <p>IN: <tt>edges_equivalent(EdgeEquivalencePredicate edge_comp)</tt></p>
+    <blockquote>
+      <p>
+        This function object is used to determine if edges between the two graphs 
+        <tt>graph_small</tt> and <tt>graph_large</tt> are equivalent. 
+        Type <tt>EdgeEquivalencePredicate</tt> must be a model of 
+        <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">Binary
+          Predicate</a> and have argument types of
+        <tt>graph_traits&lt;GraphSmall&gt;::edge_descriptor</tt> and
+        <tt>graph_traits&lt;GraphLarge&gt;::edge_descriptor</tt>.
+        The edge descriptors must be <a href="http://www.sgi.com/tech/stl/LessThanComparable.html">
+        LessThan Comparable</a>. A return value of true indicates that the edges are equivalent.
+        <br>
+        <b>Default:</b> <tt><a href="./mcgregor_common_subgraphs.html#always_equivalent">
+            always_equivalent</a></tt>
+        </p>
+    </blockquote>
+    
+    <p>IN: <tt>vertices_equivalent(VertexEquivalencePredicate vertex_comp)</tt></p>
+    <blockquote>
+      <p>
+        This function object is used to determine if vertices between the two graphs 
+        <tt>graph_small</tt> and <tt>graph_large</tt> are equivalent. 
+        Type <tt>VertexEquivalencePredicate</tt> must be a model of 
+        <a href="http://www.sgi.com/tech/stl/BinaryPredicate.html">Binary Predicate</a> 
+        and have argument types of
+        <tt>graph_traits&lt;GraphSmall&gt;::vertex_descriptor</tt> and
+        <tt>graph_traits&lt;GraphLarge&gt;::vertex_descriptor</tt>. A return value of true
+        indicates that the vertices are equivalent.
+        <br>
+        <b>Default:</b> <tt><a href="./mcgregor_common_subgraphs.html#always_equivalent">
+            always_equivalent</a></tt>
+        </p>
+    </blockquote>
+
+    <h3>Related Functions</h3>
+    <p>
+      Non-named parameter, named-parameter and all default parameter versions of 
+      function
+    </p>
+    <p><tt>vf2_graph_iso(...)</tt></p>
+    <p><tt>vf2_subgraph_mono(...)</tt></p>
+    <p>
+      for isomorphism and (not necessarily induced) subgraph isomorphism testing,
+      taking the same parameters as the corresponding functions <tt>vf2_subgraph_iso</tt> 
+      for induced subgraph isomorphism testing.
+      For <tt>vf2_graph_iso</tt> the algorithm finds all isomorphism mappings between
+      graphs <tt>graph1</tt> and <tt>graph2</tt> and outputs them to
+      <tt>user_callback</tt>.
+      For <tt>vf2_graph_mono</tt> the algorithm finds all mappings of <tt>graph_small</tt>
+      to subgraphs of <tt>graph_large</tt>.
+      Note that, as opposed to <tt>vf2_subgraph_iso</tt>,
+      these subgraphs need not to be induced subgraphs.
+    </p>
+    <p> 
+      Both algorithms continues until <tt>user_callback</tt>
+      returns false or the search space has been fully explored. As before,
+      <tt>EdgeEquivalencePredicate</tt> and
+      <tt>VertexEquivalencePredicate</tt> predicates are used to test
+      whether edges and vertices are equivalent. By default
+      <tt>always_equivalent</tt> is used.
+    </p>
+    
+    <h3>Utility Functions and Structs</h3>
+    <p>
+    <tt id="vf2_callback">
+template&lt;typename Graph1,
+          typename Graph2&gt;
+struct vf2_print_callback
+    </tt>
+    </p>
+    <blockquote>
+      <p>
+        Callback function object that prints out the correspondences between vertices
+        of <tt>Graph1</tt> and <tt>Graph2</tt>. The constructor takes
+        the two graphs <em>G<sub>1</sub></em> and <em>G<sub>2</sub></em>.
+      </p>
+    </blockquote>
+
+    <pre>
+template&lt;typename Graph&gt;
+std::vector&lt;typename graph_traits&lt;Graph&gt;::vertex_descriptor&gt;
+  vertex_order_by_mult(const Graph&amp; graph) 
+    </pre>
+    <blockquote>
+      <p>
+        Returns a vector containing the vertices of a graph, sorted
+        by multiplicity of in/out degrees.
+      </p>
+    </blockquote>
+
+    <pre>
+<em class="comment">// Variant of verify_subgraph_iso with all default parameters</em>
+template&lt;typename Graph1,
+         typename Graph2,
+         typename CorresponenceMap1To2&gt;
+inline bool verify_vf2_subgraph_iso(const Graph1&amp; graph1, const Graph2&amp; graph2, 
+                                    const CorresponenceMap1To2 f)
+
+
+<em class="comment">// Verifies a graph (sub)graph isomorphism map</em> 
+template&lt;typename Graph1,
+         typename Graph2,
+         typename CorresponenceMap1To2,
+         typename EdgeEquivalencePredicate,
+         typename VertexEquivalencePredicate&gt;
+inline bool verify_vf2_subgraph_iso(const Graph1&amp; graph1, const Graph2&amp; graph2, 
+                                    const CorresponenceMap1To2 f,
+                                    EdgeEquivalencePredicate edge_comp, 
+                                    VertexEquivalencePredicate vertex_comp) 
+    </pre>
+    <blockquote>
+      <p>
+        This function can be used to verify a (sub)graph isomorphism
+        mapping <em>f</em>. The parameters are analogous to
+        function <tt>vf2_subgraph_iso</tt> (<tt>vf2_graph_iso</tt>).
+      </p>
+    </blockquote>
+
+
+    <h3>Complexity</h3>
+    <p>
+      Spatial and time complexity are given in [<a href="#cordella2004">2</a>]. The spatial
+      complexity of VF2 is of order <em>O(V)</em>, where V is the (maximum) number
+      of vertices of the two graphs. Time complexity is <em>O(V<sup>2</sup>)</em> in the best case and
+      <em>O(V!&middot;V)</em> in the worst case.
+    </p>
+    
+    <h3>Examples</h3>
+
+    <h4>Example 1</h4>
+    <p>
+      In the example below, a small graph <tt>graph1</tt> and a larger graph
+      <tt>graph2</tt> are defined. Here small and large refers to the number of
+      vertices of the graphs. <tt>vf2_subgraph_iso</tt> computes all the
+      subgraph isomorphism mappings between the two graphs and outputs them
+      via <tt>callback</tt>.
+    </p>
+    <pre>
+typedef adjacency_list&lt;setS, vecS, bidirectionalS&gt; graph_type;
+
+<em class="comment">// Build graph1</em>
+int num_vertices1 = 8; graph_type graph1(num_vertices1);
+add_edge(0, 6, graph1); add_edge(0, 7, graph1);
+add_edge(1, 5, graph1); add_edge(1, 7, graph1);
+add_edge(2, 4, graph1); add_edge(2, 5, graph1); add_edge(2, 6, graph1);
+add_edge(3, 4, graph1);
+
+<em class="comment">// Build graph2</em>
+int num_vertices2 = 9; graph_type graph2(num_vertices2);
+add_edge(0, 6, graph2); add_edge(0, 8, graph2);
+add_edge(1, 5, graph2); add_edge(1, 7, graph2);
+add_edge(2, 4, graph2); add_edge(2, 7, graph2); add_edge(2, 8, graph2);
+add_edge(3, 4, graph2); add_edge(3, 5, graph2); add_edge(3, 6, graph2);
+<em class="comment">
+// Create callback to print mappings</em>
+vf2_print_callback&lt;graph_type, graph_type&gt; callback(graph1, graph2);
+
+<em class="comment">
+// Print out all subgraph isomorphism mappings between graph1 and graph2.
+// Vertices and edges are assumed to be always equivalent.</em>
+vf2_subgraph_iso(graph1, graph2, callback);
+    </pre>
+    <p>
+      The complete example can be found under
+      <a href="../example/vf2_sub_graph_iso_example.cpp"><tt>examples/vf2_sub_graph_iso_example.cpp</tt></a>.
+      <br>
+    </p>
+
+    <h4>Example 2</h4>
+    <p>
+      In this example, the subgraph isomorphism mappings between multi-graphs are computed. The vertices
+      and edges of the multi-graphs are distinguished using property maps.
+    </p>
+    <pre>
+<em class="comment">// Define edge and vertex properties</em>
+typedef property&lt;edge_name_t, char&gt; edge_property;
+typedef property&lt;vertex_name_t, char, property&lt;vertex_index_t, int&gt; &gt; vertex_property;
+
+<em class="comment">// Using a vecS graphs => the index maps are implicit.</em>
+typedef adjacency_list&lt;vecS, vecS, bidirectionalS, vertex_property, edge_property&gt; graph_type;
+
+<em class="comment">// Create graph1</em>
+graph_type graph1;
+<em class="comment">// Add vertices... </em>
+add_vertex(vertex_property('a'), graph1);
+...
+<em class="comment">//... and edges </em>
+add_edge(0, 1, edge_property('b'), graph1); 
+add_edge(0, 1, edge_property('b'), graph1); 
+...
+
+<em class="comment">// Create graph2 </em>
+graph_type graph2;
+add_vertex(vertex_property('a'), graph2);
+...  
+add_edge(0, 1, edge_property('a'), graph2); 
+...
+    </pre>
+
+    <p>
+      To distinguish vertices and edges with property maps, binary predicates are created using the 
+      <tt><a href="./mcgregor_common_subgraphs.html#make_property_map_equivalent">
+          make_property_map_equivalent</a></tt> function:
+    </p>
+
+    <pre>
+<em class="comment">// Create the vertex binary predicate</em>
+typedef property_map&lt;graph_type, vertex_name_t&gt;::type vertex_name_map_t;
+typedef property_map_equivalent&lt;vertex_name_map_t, vertex_name_map_t&gt; vertex_comp_t;
+vertex_comp_t vertex_comp =
+  make_property_map_equivalent(get(vertex_name, graph1), get(vertex_name, graph2));
+
+<em class="comment">// Create the vertex binary predicate</em>
+typedef property_map&lt;graph_type, edge_name_t&gt;::type edge_name_map_t;
+typedef property_map_equivalent&lt;edge_name_map_t, edge_name_map_t&gt; edge_comp_t;
+edge_comp_t edge_comp =
+  make_property_map_equivalent(get(edge_name, graph1), get(edge_name, graph2));
+    </pre>
+
+    <p>
+      Finally, a callback function object is created and the subgraph isomorphism mappings are
+      computed:
+    </p>
+    <pre>
+<em class="comment">// Create callback</em>
+vf2_print_callback&lt;graph_type, graph_type&gt; callback(graph1, graph2);
+
+<em class="comment">
+// Print out all subgraph isomorphism mappings between graph1 and graph2.
+// Function vertex_order_by_mult is used to compute the order of 
+// vertices of graph1. This is the order in which the vertices are examined
+// during the matching process.</em>
+vf2_subgraph_iso(graph1, graph2, callback, vertex_order_by_mult(graph1),
+                 edges_equivalent(edge_comp).vertices_equivalent(vertex_comp));
+    </pre>
+
+    <p>
+      For the complete example, see
+      <a href="../example/vf2_sub_graph_iso_multi_example.cpp">
+        <tt>examples/vf2_sub_graph_iso_multi_example.cpp</tt></a>.
+      <br>
+    </p>
+
+    <h3 id="notes">Notes</h3>
+    <p>
+      If the <tt>EdgeList</tt> allows for parallel edges, e.g. <tt>vecS</tt>, the
+      algorithm does some bookkeeping of already identified edges. Matched edges
+      are temporarily stored using <tt>std::set</tt> as container, requiring that
+      <tt>edge_descriptor</tt> are <a href="http://www.sgi.com/tech/stl/LessThanComparable.html">
+        LessThan Comparable</a>. In contrast, if instead you enforce the absence of
+      parallel edges, e.g. by using <tt>setS</tt>, the lookup function falls back
+      to <tt>edge()</tt> without performing any bookkeeping.
+    </p>
+
+    <h3>Bibliography</h3>
+
+    <dl>
+      <dt><a name="cordella2001">1</a></dt>
+      <dd>
+        L.&nbsp;P. Cordella, P. Foggia, C. Sansone, and M. Vento.
+        <br><em>An improved algorithm for matching large graphs</em>.
+        <br>In: 3rd IAPR-TC15 Workshop on Graph-based Representations in Pattern Recognition, pp. 149-159, Cuen, 2001.
+        <p></p>
+      </dd>
+      <dt><a name="cordella2004">2</a></dt>
+      <dd>
+        L.&nbsp;P. Cordella, P. Foggia, C. Sansone, and M. Vento.
+        <br><em>A (Sub)Graph Isomorphism Algorithm for Matching Large Graphs</em>.
+        <br>IEEE Trans. Pattern Anal. Mach. Intell., vol. 26, no. 10, pp. 1367-1372, 2004.
+        <p></p>
+      </dd>
+      <dt><a name="foggia_etal">3</a></dt>
+      <dd>
+        <a href="http://www.cs.sunysb.edu/~algorith/implement/vflib/implement.shtml">
+          <tt>http://www.cs.sunysb.edu/~algorith/implement/vflib/implement.shtml</tt></a>
+        <p></p>
+      </dd>
+    </dl>
+    <hr>
+    <p>
+      Copyright &copy; 2012, Flavio De Lorenzi 
+      (<a href="mailto:fdlorenzi@gmail.com">fdlorenzi@gmail.com</a>) <br />
+      Copyright &copy; 2013, Jakob Lykke Andersen, University of Southern Denmark
+      (<a href="mailto:jlandersen@imada.sdu.dk">jlandersen@imada.sdu.dk</a>)
+    </p>
+  </body>
+</html> 
diff --git a/doc/write-graphviz.html b/doc/write-graphviz.html
index 5ae376c52..9af6e7b7b 100644
--- a/doc/write-graphviz.html
+++ b/doc/write-graphviz.html
@@ -134,7 +134,7 @@ <h3><A NAME="concept:PropertyWriter">
   public:
     label_writer(Name _name) : name(_name) {}
     template &lt;class VertexOrEdge&gt;
-    void operator()(std::ostream& out, const VertexOrEdge& v) const {
+    void operator()(std::ostream&amp; out, const VertexOrEdge&amp; v) const {
       out &lt;&lt; "[label=\"" &lt;&lt; name[v] &lt;&lt; "\"]";
     }
   private:
@@ -154,13 +154,13 @@ <h3><A NAME="concept:PropertyWriter">
 A <a href="./write-graphviz.html#concept:PropertyWriter">PropertyWriter</a>
 for graphs is a functor which is called with one parameter of type
 <tt>std::ostream</tt> and should print a series of graph properties. The following
-code excerpt is an example of a PropertyWriter for a graph.
+code excerpt is an example of a PropertyWriter for a graph:
 <pre>
   struct sample_graph_writer {
-    void operator()(std::ostream& out) const {
-      out << "graph [bgcolor=lightgrey]" << std::endl;
-      out << "node [shape=circle color=white]" << std::endl;
-      out << "edge [style=dashed]" << std::endl;
+    void operator()(std::ostream&amp; out) const {
+      out &lt;&lt; "graph [bgcolor=lightgrey]" &lt;&lt; std::endl;
+      out &lt;&lt; "node [shape=circle color=white]" &lt;&lt; std::endl;
+      out &lt;&lt; "edge [style=dashed]" &lt;&lt; std::endl;
     }
   };
 }
@@ -168,9 +168,9 @@ <h3><A NAME="concept:PropertyWriter">
 
 <p>
 There exists a class <tt>default_writer</tt>, which can be used as both
-vertex/edge and graph property writer, and does nothing. It comes handy when
-only edge properties must be written, but function interface requries to pass
-vertex property writer as well.
+vertex/edge and graph property writer, and does nothing. It is useful when
+only edge properties must be written, but the function interface also requires a
+vertex property writer.
 
 <h3>Parameters</h3>
  OUT: <tt>std::ostream&amp; out</tt>
@@ -181,38 +181,38 @@ <h3>Parameters</h3>
  IN: <tt>VertexAndEdgeListGraph&amp; g</tt>
 <blockquote>
   A directed or undirected graph. The graph's type must be a model of
-  <a href="./VertexAndEdgeListGraph.html">VertexAndEdgeListGraph</a>. Also the
+  <a href="./VertexAndEdgeListGraph.html">VertexAndEdgeListGraph</a>. In most cases, the
   graph must have an internal <tt>vertex_index</tt> property map.
 </blockquote>
 
  IN: <tt>VertexPropertyWriter vpw</tt>
 <blockquote>
-  A functor that models <a href="./write-graphviz.html#concept:PropertyWriter">PropertyWriter</a> concept to print
+  A functor that models <a href="./write-graphviz.html#concept:PropertyWriter">PropertyWriter</a> to print
   properties of a vertex.<br>
 <b>Default</b>: <tt>default_writer()</tt>
 </blockquote>
 
  IN: <tt>EdgePropertyWriter epw</tt>
 <blockquote>
-  A functor that models <a href="./write-graphviz.html#concept:PropertyWriter">PropertyWriter</a> concept to print
+  A functor that models <a href="./write-graphviz.html#concept:PropertyWriter">PropertyWriter</a> to print
   properties of an edge.<br>
 <b>Default</b>: <tt>default_writer()</tt>
 </blockquote>
 
  IN: <tt>GraphPropertyWriter epw</tt>
 <blockquote>
-  A functor that models <a href="./write-graphviz.html#concept:PropertyWriter">PropertyWriter</a> concept to print
-  properties of a graph.<br>
+  A functor that models <a href="./write-graphviz.html#concept:PropertyWriter">PropertyWriter</a> to print
+  properties of the graph.<br>
 <b>Default</b>: <tt>default_writer()</tt>
 </blockquote>
 
-IN: <tt>dynamic_properties& dp</tt>
+IN: <tt>dynamic_properties&amp; dp</tt>
 <blockquote>
   Contains all of the vertex and edge properties that should be
   emitted by the GraphViz writer.
 </blockquote>
 
-IN: <tt>const std::string& node_id</tt>
+IN: <tt>const std::string&amp; node_id</tt>
 <blockquote>
   The name of the property map that provides identifiers for the
   vertices in the graph.<br>
@@ -221,15 +221,15 @@ <h3>Parameters</h3>
 
 IN: <tt>VertexID vertex_id</tt>
 <blockquote>
-  A property map that models <a href="../../property_map/doc/ReadablePropertyMap.html">Readable Property Map</a> whose key type is the vertex descriptor of the graph and whose value type can be written to a stream. The value should be a unique descriptor that can be used to name a node in a Graphviz file (so it should not, for instance, have any spaces in it).<br>
-<b>Default</b>: If no <code>dynamic_properties</code> object is provided, <tt>get(vertex_index, g)</tt>. Otherwise, a dynamic property map that accesses the property map named <code>node_id</code>.
+  A property map that models <a href="../../property_map/doc/ReadablePropertyMap.html">Readable Property Map</a>, whose key type is the vertex descriptor of the graph, and whose value type can be written to a stream. The value should be a unique descriptor for each vertex, and will be used to name each node in the Graphviz file (it will be escaped properly for Graphviz output).<br>
+<b>Default</b>: If no <code>dynamic_properties</code> object is provided, <tt>get(vertex_index, g)</tt>. Otherwise, a dynamic property map that accesses the property map in <code>dp</code> whose name is given by the <code>node_id</code> parameter.
 </blockquote>
 <H3>
 Example
 </H3>
 
-This example demonstrates using BGL-graphviz interface to write
-a BGL graph into a graphviz format file.
+This example demonstrates using the BGL-Graphviz interface to write
+a BGL graph into a Graphviz format file.
 
 <pre>
 #include &lt;boost/graph/graphviz.hpp&gt;
diff --git a/doc/write_graphml.html b/doc/write_graphml.html
index b3bbd131f..8ed7127ab 100644
--- a/doc/write_graphml.html
+++ b/doc/write_graphml.html
@@ -116,11 +116,11 @@ <h1><a class="toc-backref" href="#id4">Example</a></h1>
     Graph g(used_by, used_by + nedges, N);
 
     graph_traits&lt;Graph&gt;::vertex_iterator v, v_end;
-    for (tie(v,v_end) = vertices(g); v != v_end; ++v)
+    for (boost::tie(v,v_end) = vertices(g); v != v_end; ++v)
         put(vertex_color_t(), g, *v, name[*v]);
 
     graph_traits&lt;Graph&gt;::edge_iterator e, e_end;
-    for (tie(e,e_end) = edges(g); e != e_end; ++e)
+    for (boost::tie(e,e_end) = edges(g); e != e_end; ++e)
         put(edge_weight_t(), g, *e, 3);
 
     dynamic_properties dp;
diff --git a/example/Jamfile.v2 b/example/Jamfile.v2
index c85df0ca4..13cdf75f6 100644
--- a/example/Jamfile.v2
+++ b/example/Jamfile.v2
@@ -20,6 +20,7 @@ exe bron_kerbosch_print_cliques : bron_kerbosch_print_cliques.cpp ;
 exe bron_kerbosch_clique_number : bron_kerbosch_clique_number.cpp ;
 exe mcgregor_subgraphs_example : mcgregor_subgraphs_example.cpp ;
 exe grid_graph_example : grid_graph_example.cpp ;
+exe grid_graph_properties : grid_graph_properties.cpp ;
 exe bipartite_example : bipartite_example.cpp ;
 exe fr_layout : fr_layout.cpp ;
 exe canonical_ordering : canonical_ordering.cpp ;
@@ -29,4 +30,28 @@ exe ospf-example : ospf-example.cpp ../build//boost_graph ;
 # exe cc-internet : cc-internet.cpp ../build//boost_graph ;
 exe implicit_graph : implicit_graph.cpp ;
 exe astar_maze : astar_maze.cpp ;
+exe astar-cities : astar-cities.cpp ;
 exe stoer_wagner : stoer_wagner.cpp ;
+exe bfs-example : bfs-example.cpp ;
+exe bfs-example2 : bfs-example2.cpp ;
+exe dfs-example : dfs-example.cpp ;
+exe dijkstra-example : dijkstra-example.cpp ;
+exe dijkstra-example-listS : dijkstra-example-listS.cpp ;
+exe dijkstra-no-color-map-example : dijkstra-no-color-map-example.cpp ;
+exe adjacency_list_io : adjacency_list_io.cpp ;
+exe undirected_adjacency_list : undirected_adjacency_list.cpp ;
+exe directed_graph : directed_graph.cpp ;
+exe undirected_graph : undirected_graph.cpp ;
+exe two_graphs_common_spanning_trees : two_graphs_common_spanning_trees.cpp ;
+exe strong_components : strong_components.cpp ../build//boost_graph ;
+exe strong-components : strong-components.cpp ;
+exe subgraph : subgraph.cpp ;
+exe subgraph_properties : subgraph_properties.cpp ;
+exe vf2_sub_graph_iso_example : vf2_sub_graph_iso_example.cpp ;
+exe vf2_sub_graph_iso_multi_example : vf2_sub_graph_iso_multi_example.cpp ;
+exe sloan_ordering : sloan_ordering.cpp ;
+exe hawick_circuits : hawick_circuits.cpp ;
+exe edge_coloring : edge_coloring.cpp ;
+exe successive_shortest_path_nonnegative_weights_example : successive_shortest_path_nonnegative_weights_example.cpp ;
+exe cycle_canceling_example : cycle_canceling_example.cpp ;
+
diff --git a/example/actor_clustering.cpp b/example/actor_clustering.cpp
index a29256479..9b1b40221 100644
--- a/example/actor_clustering.cpp
+++ b/example/actor_clustering.cpp
@@ -9,7 +9,7 @@
 
 // This program performs betweenness centrality (BC) clustering on the
 // actor collaboration graph available at
-// http://www.nd.edu/~networks/database/index.html and outputs the
+// http://www.nd.edu/~networks/resources/actor/actor.dat.gz and outputs the
 // result of clustering in Pajek format.
 //
 // This program mimics the BC clustering algorithm program implemented
diff --git a/example/astar-cities.cpp b/example/astar-cities.cpp
index d5affd110..48b3260f9 100644
--- a/example/astar-cities.cpp
+++ b/example/astar-cities.cpp
@@ -118,7 +118,6 @@ int main(int argc, char **argv)
   typedef property_map<mygraph_t, edge_weight_t>::type WeightMap;
   typedef mygraph_t::vertex_descriptor vertex;
   typedef mygraph_t::edge_descriptor edge_descriptor;
-  typedef mygraph_t::vertex_iterator vertex_iterator;
   typedef std::pair<int, int> edge;
   
   // specify data
@@ -171,7 +170,7 @@ int main(int argc, char **argv)
   
   
   // pick random start/goal
-  mt19937 gen(time(0));
+  boost::mt19937 gen(time(0));
   vertex start = random_vertex(g, gen);
   vertex goal = random_vertex(g, gen);
   
@@ -192,11 +191,12 @@ int main(int argc, char **argv)
   vector<cost> d(num_vertices(g));
   try {
     // call astar named parameter interface
-    astar_search
+    astar_search_tree
       (g, start,
        distance_heuristic<mygraph_t, cost, location*>
         (locations, goal),
-       predecessor_map(&p[0]).distance_map(&d[0]).
+       predecessor_map(make_iterator_property_map(p.begin(), get(vertex_index, g))).
+       distance_map(make_iterator_property_map(d.begin(), get(vertex_index, g))).
        visitor(astar_goal_visitor<vertex>(goal)));
   
   
diff --git a/example/astar_maze.cpp b/example/astar_maze.cpp
index 20cff4fdd..fad2c208f 100644
--- a/example/astar_maze.cpp
+++ b/example/astar_maze.cpp
@@ -139,7 +139,7 @@ class euclidean_heuristic:
   euclidean_heuristic(vertex_descriptor goal):m_goal(goal) {};
 
   double operator()(vertex_descriptor v) {
-    return sqrt(pow(m_goal[0] - v[0], 2) + pow(m_goal[1] - v[1], 2));
+    return sqrt(pow(double(m_goal[0] - v[0]), 2) + pow(double(m_goal[1] - v[1]), 2));
   }
 
 private:
@@ -221,7 +221,7 @@ std::ostream& operator<<(std::ostream& output, const maze& m) {
       if (x == 0)
         output << BARRIER;
       // Put the character representing this point in the maze grid.
-      vertex_descriptor u = {{x, y}};
+      vertex_descriptor u = {{x, vertices_size_type(y)}};
       if (m.solution_contains(u))
         output << ".";
       else if (m.has_barrier(u))
diff --git a/example/bfs-example.cpp b/example/bfs-example.cpp
index 20e3b8da9..0436204ce 100644
--- a/example/bfs-example.cpp
+++ b/example/bfs-example.cpp
@@ -8,7 +8,7 @@
 #include <boost/graph/adjacency_list.hpp>
 #include <boost/graph/breadth_first_search.hpp>
 #include <boost/pending/indirect_cmp.hpp>
-#include <boost/pending/integer_range.hpp>
+#include <boost/range/irange.hpp>
 
 #include <iostream>
 
@@ -54,15 +54,18 @@ main()
 #endif
 
   // Typedefs
-  typedef graph_traits < graph_t >::vertex_descriptor Vertex;
   typedef graph_traits < graph_t >::vertices_size_type Size;
-  typedef Size* Iiter;
 
   // a vector to hold the discover time property for each vertex
   std::vector < Size > dtime(num_vertices(g));
+  typedef
+    iterator_property_map<std::vector<Size>::iterator,
+                          property_map<graph_t, vertex_index_t>::const_type>
+    dtime_pm_type;
+  dtime_pm_type dtime_pm(dtime.begin(), get(vertex_index, g));
 
   Size time = 0;
-  bfs_time_visitor < Size * >vis(&dtime[0], time);
+  bfs_time_visitor < dtime_pm_type >vis(dtime_pm, time);
   breadth_first_search(g, vertex(s, g), visitor(vis));
 
   // Use std::sort to order the vertices by their discover time
@@ -70,7 +73,7 @@ main()
   integer_range < int >range(0, N);
   std::copy(range.begin(), range.end(), discover_order.begin());
   std::sort(discover_order.begin(), discover_order.end(),
-            indirect_cmp < Iiter, std::less < Size > >(&dtime[0]));
+            indirect_cmp < dtime_pm_type, std::less < Size > >(dtime_pm));
 
   std::cout << "order of discovery: ";
   for (int i = 0; i < N; ++i)
diff --git a/example/bfs-example2.cpp b/example/bfs-example2.cpp
index 8225327ec..bc5d92abd 100644
--- a/example/bfs-example2.cpp
+++ b/example/bfs-example2.cpp
@@ -8,7 +8,8 @@
 #include <boost/graph/adjacency_list.hpp>
 #include <boost/graph/breadth_first_search.hpp>
 #include <boost/pending/indirect_cmp.hpp>
-#include <boost/pending/integer_range.hpp>
+#include <boost/range/irange.hpp>
+#include <boost/property_map/property_map.hpp>
 
 #include <iostream>
 
@@ -30,6 +31,7 @@ template < typename TimeMap > class bfs_time_visitor:public default_bfs_visitor
 struct VertexProps {
   boost::default_color_type color;
   std::size_t discover_time;
+  unsigned int index;
 };
 
 int
@@ -63,9 +65,7 @@ main()
 #endif
 
   // Typedefs
-  typedef graph_traits<graph_t>::vertex_descriptor Vertex;
   typedef graph_traits<graph_t>::vertices_size_type Size;
-  typedef Size* Iiter;
 
   Size time = 0;
   typedef property_map<graph_t, std::size_t VertexProps::*>::type dtime_map_t;
@@ -76,17 +76,28 @@ main()
 
   // a vector to hold the discover time property for each vertex
   std::vector < Size > dtime(num_vertices(g));
+  typedef
+    iterator_property_map<std::vector<Size>::iterator,
+                          property_map<graph_t, unsigned int VertexProps::*>::type>
+    dtime_pm_type;
   graph_traits<graph_t>::vertex_iterator vi, vi_end;
   std::size_t c = 0;
-  for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi, ++c)
+  for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi, ++c) {
     dtime[c] = dtime_map[*vi];
+    put(&VertexProps::index, g, *vi, c);
+  }
+  dtime_pm_type dtime_pm(dtime.begin(), get(&VertexProps::index, g));
 
   // Use std::sort to order the vertices by their discover time
   std::vector<graph_traits<graph_t>::vertices_size_type > discover_order(N);
   integer_range < int >range(0, N);
   std::copy(range.begin(), range.end(), discover_order.begin());
   std::sort(discover_order.begin(), discover_order.end(),
-            indirect_cmp < Iiter, std::less < Size > >(&dtime[0]));
+            make_indirect_cmp(
+              std::less<Size>(),
+              make_iterator_property_map(
+                dtime.begin(),
+                typed_identity_property_map<std::size_t>())));
 
   std::cout << "order of discovery: ";
   for (int i = 0; i < N; ++i)
diff --git a/example/bipartite_example.cpp b/example/bipartite_example.cpp
index 05dd9cd8d..c8e62ad26 100644
--- a/example/bipartite_example.cpp
+++ b/example/bipartite_example.cpp
@@ -31,7 +31,7 @@ void print_bipartite (const Graph& g)
   if (bipartite)
   {
     typedef std::vector <default_color_type> partition_t;
-    typedef vec_adj_list_vertex_id_map <no_property, unsigned int> index_map_t;
+    typedef typename property_map <Graph, vertex_index_t>::type index_map_t;
     typedef iterator_property_map <partition_t::iterator, index_map_t> partition_map_t;
 
     partition_t partition (num_vertices (g));
diff --git a/example/canonical_ordering.cpp b/example/canonical_ordering.cpp
index 770b251e3..947984255 100644
--- a/example/canonical_ordering.cpp
+++ b/example/canonical_ordering.cpp
@@ -54,7 +54,7 @@ int main(int argc, char** argv)
   property_map<graph, edge_index_t>::type e_index = get(edge_index, g);
   graph_traits<graph>::edges_size_type edge_count = 0;
   graph_traits<graph>::edge_iterator ei, ei_end;
-  for(tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
+  for(boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
     put(e_index, *ei, edge_count++);
   
 
@@ -64,7 +64,8 @@ int main(int argc, char** argv)
   std::vector<vec_t> embedding(num_vertices(g));
   if (boyer_myrvold_planarity_test(boyer_myrvold_params::graph = g,
                                    boyer_myrvold_params::embedding = 
-                                       &embedding[0]
+                                       make_iterator_property_map(
+                                         embedding.begin(), get(vertex_index, g))
                                    )
       )
     std::cout << "Input graph is planar" << std::endl;
@@ -75,7 +76,10 @@ int main(int argc, char** argv)
     ordering_storage_t;
   
   ordering_storage_t ordering;
-  planar_canonical_ordering(g, &embedding[0], std::back_inserter(ordering));
+  planar_canonical_ordering(g,
+                            make_iterator_property_map(
+                              embedding.begin(), get(vertex_index, g)),
+                            std::back_inserter(ordering));
 
   ordering_storage_t::iterator oi, oi_end;
   oi_end = ordering.end();
diff --git a/example/closeness_centrality.cpp b/example/closeness_centrality.cpp
index b5aa4776b..ea921114c 100644
--- a/example/closeness_centrality.cpp
+++ b/example/closeness_centrality.cpp
@@ -75,7 +75,7 @@ main(int argc, char *argv[])
 
     // Print the closeness centrality of each vertex.
     graph_traits<Graph>::vertex_iterator i, end;
-    for(tie(i, end) = vertices(g); i != end; ++i) {
+    for(boost::tie(i, end) = vertices(g); i != end; ++i) {
         cout << setw(12) << setiosflags(ios::left)
              << g[*i].name << get(cm, *i) << endl;
     }
diff --git a/example/clustering_coefficient.cpp b/example/clustering_coefficient.cpp
index 70f8e731c..c4a451f13 100644
--- a/example/clustering_coefficient.cpp
+++ b/example/clustering_coefficient.cpp
@@ -58,7 +58,7 @@ main(int argc, char *argv[])
 
     // Print the clustering coefficient of each vertex.
     graph_traits<Graph>::vertex_iterator i, end;
-    for(tie(i, end) = vertices(g); i != end; ++i) {
+    for(boost::tie(i, end) = vertices(g); i != end; ++i) {
         cout << setw(12) << setiosflags(ios::left)
                 << g[*i].name << get(cm, *i) << endl;
     }
diff --git a/example/cycle_canceling_example.cpp b/example/cycle_canceling_example.cpp
new file mode 100644
index 000000000..46e85f149
--- /dev/null
+++ b/example/cycle_canceling_example.cpp
@@ -0,0 +1,28 @@
+//=======================================================================
+// Copyright 2013 University of Warsaw.
+// Authors: Piotr Wygocki 
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//=======================================================================
+
+#include <boost/graph/cycle_canceling.hpp>
+#include <boost/graph/edmonds_karp_max_flow.hpp>
+
+#include "../test/min_cost_max_flow_utils.hpp"
+
+
+int main() {
+    boost::SampleGraph::vertex_descriptor s,t;
+    boost::SampleGraph::Graph g;
+    boost::SampleGraph::getSampleGraph(g, s, t);
+
+    boost::edmonds_karp_max_flow(g, s, t);
+    boost::cycle_canceling(g);
+
+    int cost = boost::find_flow_cost(g);
+    assert(cost == 29);
+    return 0;
+}
+
diff --git a/example/degree_centrality.cpp b/example/degree_centrality.cpp
index 7da764e1b..a8aae31cb 100644
--- a/example/degree_centrality.cpp
+++ b/example/degree_centrality.cpp
@@ -57,7 +57,7 @@ main(int argc, char *argv[])
 
     // Print the degree centrality of each vertex.
     graph_traits<Graph>::vertex_iterator i, end;
-    for(tie(i, end) = vertices(g); i != end; ++i) {
+    for(boost::tie(i, end) = vertices(g); i != end; ++i) {
         cout << setiosflags(ios::left) << setw(12)
              << g[*i].name << cm[*i] << endl;
     }
diff --git a/example/dfs-example.cpp b/example/dfs-example.cpp
index 017053de7..0117b81dc 100644
--- a/example/dfs-example.cpp
+++ b/example/dfs-example.cpp
@@ -7,7 +7,7 @@
 //=======================================================================
 #include <boost/graph/adjacency_list.hpp>
 #include <boost/graph/depth_first_search.hpp>
-#include <boost/pending/integer_range.hpp>
+#include <boost/range/irange.hpp>
 #include <boost/pending/indirect_cmp.hpp>
 
 #include <iostream>
@@ -58,15 +58,17 @@ main()
   graph_t g(edge_array, edge_array + sizeof(edge_array) / sizeof(E), N);
 #endif
 
-  // Typedefs
-  typedef boost::graph_traits < graph_t >::vertex_descriptor Vertex;
-  typedef size_type* Iiter;
-
   // discover time and finish time properties
   std::vector < size_type > dtime(num_vertices(g));
   std::vector < size_type > ftime(num_vertices(g));
+  typedef
+    iterator_property_map<std::vector<size_type>::iterator,
+                          property_map<graph_t, vertex_index_t>::const_type>
+    time_pm_type;
+  time_pm_type dtime_pm(dtime.begin(), get(vertex_index, g));
+  time_pm_type ftime_pm(ftime.begin(), get(vertex_index, g));
   size_type t = 0;
-  dfs_time_visitor < size_type * >vis(&dtime[0], &ftime[0], t);
+  dfs_time_visitor < time_pm_type >vis(dtime_pm, ftime_pm, t);
 
   depth_first_search(g, visitor(vis));
 
@@ -75,7 +77,7 @@ main()
   integer_range < size_type > r(0, N);
   std::copy(r.begin(), r.end(), discover_order.begin());
   std::sort(discover_order.begin(), discover_order.end(),
-            indirect_cmp < Iiter, std::less < size_type > >(&dtime[0]));
+            indirect_cmp < time_pm_type, std::less < size_type > >(dtime_pm));
   std::cout << "order of discovery: ";
   int i;
   for (i = 0; i < N; ++i)
@@ -84,7 +86,7 @@ main()
   std::vector < size_type > finish_order(N);
   std::copy(r.begin(), r.end(), finish_order.begin());
   std::sort(finish_order.begin(), finish_order.end(),
-            indirect_cmp < Iiter, std::less < size_type > >(&ftime[0]));
+            indirect_cmp < time_pm_type, std::less < size_type > >(ftime_pm));
   std::cout << std::endl << "order of finish: ";
   for (i = 0; i < N; ++i)
     std::cout << name[finish_order[i]] << " ";
diff --git a/example/dfs.cpp b/example/dfs.cpp
index 9dd13da8c..e68ba39af 100644
--- a/example/dfs.cpp
+++ b/example/dfs.cpp
@@ -27,12 +27,18 @@
   Tree edge: 0 --> 2
   Tree edge: 2 --> 1
   Back edge: 1 --> 1
+  Finish edge: 1 --> 1
   Tree edge: 1 --> 3
   Back edge: 3 --> 1
+  Finish edge: 3 --> 1
   Tree edge: 3 --> 4
   Back edge: 4 --> 0
+  Finish edge: 4 --> 0
   Back edge: 4 --> 1
+  Finish edge: 4 --> 1
   Forward or cross edge: 2 --> 3
+  Finish edge: 2 --> 3
+  Finish edge: 0 --> 2
   1 10
   3 8
   2 9
@@ -69,6 +75,12 @@ struct edge_categorizer : public dfs_visitor<VisitorList> {
          << " --> " <<  target(e, G) << endl;
     Base::forward_or_cross_edge(e, G);
   }
+  template <class Edge, class Graph> 
+  void finish_edge(Edge e, Graph& G) { 
+    cout << "Finish edge: " << source(e, G) << 
+      " --> " <<  target(e, G) << endl; 
+    Base::finish_edge(e, G); 
+  } 
 };
 template <class VisitorList>
 edge_categorizer<VisitorList>
diff --git a/example/dfs.expected b/example/dfs.expected
index 84aa0c456..b0da6de42 100644
--- a/example/dfs.expected
+++ b/example/dfs.expected
@@ -1,12 +1,18 @@
 Tree edge: 0 --> 2
 Tree edge: 2 --> 1
 Back edge: 1 --> 1
+Finish edge: 1 --> 1
 Tree edge: 1 --> 3
 Back edge: 3 --> 1
+Finish edge: 3 --> 1
 Tree edge: 3 --> 4
 Back edge: 4 --> 0
+Finish edge: 4 --> 0
 Back edge: 4 --> 1
+Finish edge: 4 --> 1
 Forward or cross edge: 2 --> 3
+Finish edge: 2 --> 3
+Finish edge: 0 --> 2
 1 10
 3 8
 2 9
diff --git a/example/dijkstra-example-listS.cpp b/example/dijkstra-example-listS.cpp
index 1c9342072..500f9811b 100644
--- a/example/dijkstra-example-listS.cpp
+++ b/example/dijkstra-example-listS.cpp
@@ -26,7 +26,6 @@ main(int, char *[])
     property<vertex_distance_t, int,
     property<vertex_predecessor_t, vertex_descriptor> > > >, 
     property<edge_weight_t, int> > graph_t;
-  typedef graph_traits<graph_t>::edge_descriptor edge_descriptor;
   typedef std::pair<int, int> Edge;
 
   const int num_nodes = 5;
@@ -38,25 +37,8 @@ main(int, char *[])
   int num_arcs = sizeof(edge_array) / sizeof(Edge);
   graph_traits<graph_t>::vertex_iterator i, iend;
 
-#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
-  graph_t g(num_nodes);
-  property_map<graph_t, edge_weight_t>::type weightmap = get(edge_weight, g);
-
-  std::vector<vertex_descriptor> msvc_vertices;
-  for (boost::tie(i, iend) = vertices(g); i != iend; ++i)
-    msvc_vertices.push_back(*i);
-
-  for (std::size_t j = 0; j < num_arcs; ++j) {
-    edge_descriptor e; bool inserted;
-    boost::tie(e, inserted) = add_edge(msvc_vertices[edge_array[j].first], 
-                                       msvc_vertices[edge_array[j].second], g);
-    weightmap[e] = weights[j];
-  }
-
-#else
   graph_t g(edge_array, edge_array + num_arcs, weights, num_nodes);
   property_map<graph_t, edge_weight_t>::type weightmap = get(edge_weight, g);
-#endif
 
   // Manually intialize the vertex index and name maps
   property_map<graph_t, vertex_index_t>::type indexmap = get(vertex_index, g);
@@ -73,16 +55,7 @@ main(int, char *[])
     d = get(vertex_distance, g);
   property_map<graph_t, vertex_predecessor_t>::type
     p = get(vertex_predecessor, g);
-#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
-  // VC++ has trouble with the named parameters mechanism
-  property_map<graph_t, vertex_index_t>::type indexmap = get(vertex_index, g);
-  dijkstra_shortest_paths(g, s, p, d, weightmap, indexmap, 
-                          std::less<int>(), closed_plus<int>(), 
-                          (std::numeric_limits<int>::max)(), 0,
-                          default_dijkstra_visitor());
-#else
   dijkstra_shortest_paths(g, s, predecessor_map(p).distance_map(d));
-#endif
 
   std::cout << "distances and parents:" << std::endl;
   graph_traits < graph_t >::vertex_iterator vi, vend;
diff --git a/example/dijkstra-example.cpp b/example/dijkstra-example.cpp
index 6a77ddedb..269d2570c 100644
--- a/example/dijkstra-example.cpp
+++ b/example/dijkstra-example.cpp
@@ -12,6 +12,7 @@
 #include <boost/graph/graph_traits.hpp>
 #include <boost/graph/adjacency_list.hpp>
 #include <boost/graph/dijkstra_shortest_paths.hpp>
+#include <boost/property_map/property_map.hpp>
 
 using namespace boost;
 
@@ -21,7 +22,6 @@ main(int, char *[])
   typedef adjacency_list < listS, vecS, directedS,
     no_property, property < edge_weight_t, int > > graph_t;
   typedef graph_traits < graph_t >::vertex_descriptor vertex_descriptor;
-  typedef graph_traits < graph_t >::edge_descriptor edge_descriptor;
   typedef std::pair<int, int> Edge;
 
   const int num_nodes = 5;
@@ -32,32 +32,15 @@ main(int, char *[])
   };
   int weights[] = { 1, 2, 1, 2, 7, 3, 1, 1, 1 };
   int num_arcs = sizeof(edge_array) / sizeof(Edge);
-#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
-  graph_t g(num_nodes);
-  property_map<graph_t, edge_weight_t>::type weightmap = get(edge_weight, g);
-  for (std::size_t j = 0; j < num_arcs; ++j) {
-    edge_descriptor e; bool inserted;
-    boost::tie(e, inserted) = add_edge(edge_array[j].first, edge_array[j].second, g);
-    weightmap[e] = weights[j];
-  }
-#else
   graph_t g(edge_array, edge_array + num_arcs, weights, num_nodes);
   property_map<graph_t, edge_weight_t>::type weightmap = get(edge_weight, g);
-#endif
   std::vector<vertex_descriptor> p(num_vertices(g));
   std::vector<int> d(num_vertices(g));
   vertex_descriptor s = vertex(A, g);
 
-#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
-  // VC++ has trouble with the named parameters mechanism
-  property_map<graph_t, vertex_index_t>::type indexmap = get(vertex_index, g);
-  dijkstra_shortest_paths(g, s, &p[0], &d[0], weightmap, indexmap, 
-                          std::less<int>(), closed_plus<int>(), 
-                          (std::numeric_limits<int>::max)(), 0,
-                          default_dijkstra_visitor());
-#else
-  dijkstra_shortest_paths(g, s, predecessor_map(&p[0]).distance_map(&d[0]));
-#endif
+  dijkstra_shortest_paths(g, s,
+                          predecessor_map(boost::make_iterator_property_map(p.begin(), get(boost::vertex_index, g))).
+                          distance_map(boost::make_iterator_property_map(d.begin(), get(boost::vertex_index, g))));
 
   std::cout << "distances and parents:" << std::endl;
   graph_traits < graph_t >::vertex_iterator vi, vend;
diff --git a/example/dijkstra-no-color-map-example.cpp b/example/dijkstra-no-color-map-example.cpp
index cc89ab4fd..14d196d9f 100644
--- a/example/dijkstra-no-color-map-example.cpp
+++ b/example/dijkstra-no-color-map-example.cpp
@@ -16,6 +16,7 @@
 #include <boost/graph/graph_traits.hpp>
 #include <boost/graph/adjacency_list.hpp>
 #include <boost/graph/dijkstra_shortest_paths_no_color_map.hpp>
+#include <boost/property_map/property_map.hpp>
 
 using namespace boost;
 
@@ -25,7 +26,6 @@ main(int, char *[])
   typedef adjacency_list < listS, vecS, directedS,
     no_property, property < edge_weight_t, int > > graph_t;
   typedef graph_traits < graph_t >::vertex_descriptor vertex_descriptor;
-  typedef graph_traits < graph_t >::edge_descriptor edge_descriptor;
   typedef std::pair<int, int> Edge;
 
   const int num_nodes = 5;
@@ -36,33 +36,15 @@ main(int, char *[])
   };
   int weights[] = { 1, 2, 1, 2, 7, 3, 1, 1, 1 };
   int num_arcs = sizeof(edge_array) / sizeof(Edge);
-#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
-  graph_t g(num_nodes);
-  property_map<graph_t, edge_weight_t>::type weightmap = get(edge_weight, g);
-  for (std::size_t j = 0; j < num_arcs; ++j) {
-    edge_descriptor e; bool inserted;
-    boost::tie(e, inserted) = add_edge(edge_array[j].first, edge_array[j].second, g);
-    weightmap[e] = weights[j];
-  }
-#else
   graph_t g(edge_array, edge_array + num_arcs, weights, num_nodes);
   property_map<graph_t, edge_weight_t>::type weightmap = get(edge_weight, g);
-#endif
   std::vector<vertex_descriptor> p(num_vertices(g));
   std::vector<int> d(num_vertices(g));
   vertex_descriptor s = vertex(A, g);
 
-#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
-  // VC++ has trouble with the named parameters mechanism
-  property_map<graph_t, vertex_index_t>::type indexmap = get(vertex_index, g);
-  dijkstra_shortest_paths_no_color_map(g, s, &p[0], &d[0], weightmap,
-                                       indexmap, std::less<int>(),
-                                       closed_plus<int>(),
-                                       (std::numeric_limits<int>::max)(), 0,
-                                       default_dijkstra_visitor());
-#else
-  dijkstra_shortest_paths_no_color_map(g, s, predecessor_map(&p[0]).distance_map(&d[0]));
-#endif
+  dijkstra_shortest_paths_no_color_map(g, s,
+                                       predecessor_map(boost::make_iterator_property_map(p.begin(), get(boost::vertex_index, g))).
+                                       distance_map(boost::make_iterator_property_map(d.begin(), get(boost::vertex_index, g))));
 
   std::cout << "distances and parents:" << std::endl;
   graph_traits < graph_t >::vertex_iterator vi, vend;
diff --git a/example/directed_graph.cpp b/example/directed_graph.cpp
new file mode 100644
index 000000000..bb308aa59
--- /dev/null
+++ b/example/directed_graph.cpp
@@ -0,0 +1,26 @@
+//=======================================================================
+// Copyright 2012
+// Authors: David Doria
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//=======================================================================
+
+#include <boost/graph/directed_graph.hpp> // A subclass to provide reasonable arguments to adjacency_list for a typical directed graph
+
+int main(int,char*[])
+{
+  // directed_graph is a subclass of adjacency_list which gives you object oriented access to functions
+  // like add_vertex and add_edge, which makes the code easier to understand. However, it hard codes many
+  // of the template parameters, so it is much less flexible.
+
+  typedef boost::directed_graph<> Graph;
+  Graph g;
+  boost::graph_traits<Graph>::vertex_descriptor v0 = g.add_vertex();
+  boost::graph_traits<Graph>::vertex_descriptor v1 = g.add_vertex();
+
+  g.add_edge(v0, v1);
+
+  return 0;
+}
diff --git a/example/edge_coloring.cpp b/example/edge_coloring.cpp
new file mode 100644
index 000000000..81a8a38da
--- /dev/null
+++ b/example/edge_coloring.cpp
@@ -0,0 +1,70 @@
+//=======================================================================
+// Copyright 2013 Maciej Piechotka
+// Authors: Maciej Piechotka
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//=======================================================================
+
+#include <boost/config.hpp>
+#include <boost/graph/adjacency_list.hpp>
+#include <boost/graph/edge_coloring.hpp>
+#include <boost/graph/properties.hpp>
+
+/*
+  Sample output
+  Colored using 5 colors
+    a-d: 4
+    a-f: 0
+    b-c: 2
+    b-e: 3
+    b-g: 1
+    b-j: 0
+    c-d: 0
+    c-e: 1
+    d-f: 2
+    d-i: 1
+    e-g: 4
+    f-g: 3
+    f-h: 1
+    g-h: 0
+*/
+
+int main(int, char *[])
+{
+  using namespace boost;
+  using namespace std;
+  typedef adjacency_list<vecS, vecS, undirectedS, no_property, size_t, no_property> Graph;
+
+  typedef std::pair<std::size_t, std::size_t> Pair;
+  Pair edges[14] = { Pair(0,3), //a-d
+                     Pair(0,5),  //a-f
+                     Pair(1,2),  //b-c
+                     Pair(1,4),  //b-e
+                     Pair(1,6),  //b-g
+                     Pair(1,9),  //b-j
+                     Pair(2,3),  //c-d
+                     Pair(2,4),  //c-e
+                     Pair(3,5),  //d-f
+                     Pair(3,8),  //d-i
+                     Pair(4,6),  //e-g
+                     Pair(5,6),  //f-g
+                     Pair(5,7),  //f-h
+                     Pair(6,7) }; //g-h
+
+  Graph G(10);
+
+  for (size_t i = 0; i < sizeof(edges)/sizeof(edges[0]); i++)
+    add_edge(edges[i].first, edges[i].second, G).first;
+
+  size_t colors = edge_coloring(G, get(edge_bundle, G));
+
+  cout << "Colored using " << colors << " colors" << endl;
+  for (size_t i = 0; i < sizeof(edges)/sizeof(edges[0]); i++) {
+    cout << "  " << (char)('a' + edges[i].first) << "-" << (char)('a' + edges[i].second) << ": " << G[edge(edges[i].first, edges[i].second, G).first] << endl;
+  }
+
+  return 0;
+}
+
diff --git a/example/grid_graph_properties.cpp b/example/grid_graph_properties.cpp
new file mode 100644
index 000000000..37d252a85
--- /dev/null
+++ b/example/grid_graph_properties.cpp
@@ -0,0 +1,40 @@
+//=======================================================================
+// Copyright 2012 David Doria
+// Authors: David Doria
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//=======================================================================
+
+#include <iostream>
+#include <boost/array.hpp>
+#include <boost/graph/grid_graph.hpp>
+
+int main(int argc, char* argv[]) 
+{
+  // A 2D grid graph
+  typedef boost::grid_graph<2> GraphType;
+
+  // Create a 5x5 graph
+  const unsigned int dimension = 5;
+  boost::array<std::size_t, 2> lengths = { { dimension, dimension } };
+  GraphType graph(lengths);
+
+  // Get the index map of the grid graph
+  typedef boost::property_map<GraphType, boost::vertex_index_t>::const_type indexMapType;
+  indexMapType indexMap(get(boost::vertex_index, graph));
+
+  // Create a float for every node in the graph
+  boost::vector_property_map<float, indexMapType> dataMap(num_vertices(graph), indexMap);
+
+  // Associate the value 2.0 with the node at position (0,1) in the grid
+  boost::graph_traits<GraphType>::vertex_descriptor v = { { 0, 1 } };
+  put(dataMap, v, 2.0f);
+
+  // Get the data at the node at position (0,1) in the grid
+  float retrieved = get(dataMap, v);
+  std::cout << "Retrieved value: " << retrieved << std::endl;
+
+  return 0;
+}
diff --git a/example/hawick_circuits.cpp b/example/hawick_circuits.cpp
new file mode 100644
index 000000000..b29467b9e
--- /dev/null
+++ b/example/hawick_circuits.cpp
@@ -0,0 +1,96 @@
+// Copyright Louis Dionne 2013
+
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy
+// at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/assert.hpp>
+#include <boost/graph/directed_graph.hpp>
+#include <boost/graph/graph_traits.hpp>
+#include <boost/graph/hawick_circuits.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/next_prior.hpp>
+#include <boost/property_map/property_map.hpp>
+#include <cstdlib>
+#include <iostream>
+#include <iterator>
+#include <map>
+
+
+template <typename OutputStream>
+struct cycle_printer
+{
+    cycle_printer(OutputStream& stream)
+        : os(stream)
+    { }
+
+    template <typename Path, typename Graph>
+    void cycle(Path const& p, Graph const& g)
+    {
+        if (p.empty())
+            return;
+
+        // Get the property map containing the vertex indices
+        // so we can print them.
+        typedef typename boost::property_map<
+                    Graph, boost::vertex_index_t
+                >::const_type IndexMap;
+
+        IndexMap indices = get(boost::vertex_index, g);
+
+        // Iterate over path printing each vertex that forms the cycle.
+        typename Path::const_iterator i, before_end = boost::prior(p.end());
+        for (i = p.begin(); i != before_end; ++i) {
+            os << get(indices, *i) << " ";
+        }
+        os << get(indices, *i) << '\n';
+    }
+    OutputStream& os;
+};
+
+
+// VertexPairIterator is an iterator over pairs of whitespace separated
+// vertices `u` and `v` representing a directed edge from `u` to `v`.
+template <typename Graph, typename VertexPairIterator>
+void build_graph(Graph& graph, unsigned int const nvertices,
+                 VertexPairIterator first, VertexPairIterator last) {
+    typedef boost::graph_traits<Graph> Traits;
+    typedef typename Traits::vertex_descriptor vertex_descriptor;
+    std::map<unsigned int, vertex_descriptor> vertices;
+
+    for (unsigned int i = 0; i < nvertices; ++i)
+        vertices[i] = add_vertex(graph);
+
+    for (; first != last; ++first) {
+        unsigned int u = *first++;
+
+        BOOST_ASSERT_MSG(first != last,
+            "there is a lonely vertex at the end of the edge list");
+
+        unsigned int v = *first;
+
+        BOOST_ASSERT_MSG(vertices.count(u) == 1 && vertices.count(v) == 1,
+            "specified a vertex over the number of vertices in the graph");
+
+        add_edge(vertices[u], vertices[v], graph);
+    }
+    BOOST_ASSERT(num_vertices(graph) == nvertices);
+}
+
+
+int main(int argc, char const* argv[]) {
+    if (argc < 2) {
+        std::cout << "usage: " << argv[0] << " num_vertices < input\n";
+        return EXIT_FAILURE;
+    }
+
+    unsigned int num_vertices = boost::lexical_cast<unsigned int>(argv[1]);
+    std::istream_iterator<unsigned int> first_vertex(std::cin), last_vertex;
+    boost::directed_graph<> graph;
+    build_graph(graph, num_vertices, first_vertex, last_vertex);
+
+    cycle_printer<std::ostream> visitor(std::cout);
+    boost::hawick_circuits(graph, visitor);
+
+    return EXIT_SUCCESS;
+}
diff --git a/example/implicit_graph.cpp b/example/implicit_graph.cpp
index 6efdeac97..9b42e4d6b 100644
--- a/example/implicit_graph.cpp
+++ b/example/implicit_graph.cpp
@@ -4,7 +4,7 @@
 //    (See accompanying file LICENSE_1_0.txt or copy at
 //          http://www.boost.org/LICENSE_1_0.txt)
 
-
+#include <boost/concept/assert.hpp>
 #include <boost/graph/adjacency_iterator.hpp>
 #include <boost/graph/dijkstra_shortest_paths.hpp>
 #include <boost/graph/graph_concepts.hpp>
@@ -95,6 +95,12 @@ namespace boost {
     typedef edge_weight_map type;
     typedef edge_weight_map const_type;
   };
+
+  template<>
+  struct property_map< const ring_graph, edge_weight_t > {
+    typedef edge_weight_map type;
+    typedef edge_weight_map const_type;
+  };
 }
 
 // Tag values that specify the traversal type in graph::traversal_category.
@@ -374,7 +380,7 @@ edges_size_type num_edges(const ring_graph& g) {
 // AdjacencyMatrix valid expressions
 std::pair<edge_descriptor, bool>
 edge(vertex_descriptor u, vertex_descriptor v, const ring_graph& g) {
-  if (abs(u-v) == 1 &&
+  if ((u == v + 1 || v == u + 1) &&
       u >= 0 && u < num_vertices(g) && v >= 0 && v < num_vertices(g))
     return std::pair<edge_descriptor, bool>(edge_descriptor(u, v), true);
   else
@@ -444,15 +450,15 @@ int main (int argc, char const *argv[]) {
   // Check the concepts that graph models.  This is included to demonstrate
   // how concept checking works, but is not required for a working program
   // since Boost algorithms do their own concept checking.
-  function_requires< BidirectionalGraphConcept<ring_graph> >();
-  function_requires< AdjacencyGraphConcept<ring_graph> >();
-  function_requires< VertexListGraphConcept<ring_graph> >();
-  function_requires< EdgeListGraphConcept<ring_graph> >();
-  function_requires< AdjacencyMatrixConcept<ring_graph> >();
-  function_requires<
-    ReadablePropertyMapConcept<const_edge_weight_map, edge_descriptor> >();
-  function_requires<
-    ReadablePropertyGraphConcept<ring_graph, edge_descriptor, edge_weight_t> >();
+  BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<ring_graph> ));
+  BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<ring_graph> ));
+  BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<ring_graph> ));
+  BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<ring_graph> ));
+  BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept<ring_graph> ));
+  BOOST_CONCEPT_ASSERT((
+    ReadablePropertyMapConcept<const_edge_weight_map, edge_descriptor> ));
+  BOOST_CONCEPT_ASSERT((
+    ReadablePropertyGraphConcept<ring_graph, edge_descriptor, edge_weight_t> ));
 
   // Specify the size of the graph on the command line, or use a default size
   // of 5.
@@ -460,7 +466,6 @@ int main (int argc, char const *argv[]) {
 
   // Create a small ring graph.
   ring_graph g(n);
-  const_edge_weight_map m = get(edge_weight, g);
 
   // Print the outgoing edges of all the vertices.  For n=5 this will print:
   //
@@ -473,18 +478,18 @@ int main (int argc, char const *argv[]) {
   // 5 vertices
   std::cout << "Vertices, outgoing edges, and adjacent vertices" << std::endl;
   vertex_iterator vi, vi_end;
-  for (tie(vi, vi_end) = vertices(g); vi != vi_end; vi++) {
+  for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; vi++) {
     vertex_descriptor u = *vi;
     std::cout << "Vertex " << u << ": ";
     // Adjacenct edges
     out_edge_iterator ei, ei_end;
-    for (tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ei++)
+    for (boost::tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ei++)
       std::cout << *ei << "  ";
     std::cout << " Adjacent vertices ";
     // Adjacent vertices
     // Here we want our adjacency_iterator and not boost::adjacency_iterator.
     ::adjacency_iterator ai, ai_end;
-    for (tie(ai, ai_end) = adjacent_vertices(u, g); ai != ai_end; ai++) {
+    for (boost::tie(ai, ai_end) = adjacent_vertices(u, g); ai != ai_end; ai++) {
       std::cout << *ai << " ";
     }
     std::cout << std::endl;
@@ -503,7 +508,7 @@ int main (int argc, char const *argv[]) {
   // 5 edges
   std::cout << "Edges and weights" << std::endl;
   edge_iterator ei, ei_end;
-  for (tie(ei, ei_end) = edges(g); ei != ei_end; ei++) {
+  for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ei++) {
     edge_descriptor e = *ei;
     std::cout << e << " weight " << get(edge_weight, g, e) << std::endl;
   }
@@ -522,13 +527,19 @@ int main (int argc, char const *argv[]) {
     vertex_descriptor source = 0;
     std::vector<vertex_descriptor> pred(num_vertices(g));
     std::vector<edge_weight_map_value_type> dist(num_vertices(g));
+    iterator_property_map<std::vector<vertex_descriptor>::iterator,
+                          property_map<ring_graph, vertex_index_t>::const_type>
+      pred_pm(pred.begin(), get(vertex_index, g));
+    iterator_property_map<std::vector<edge_weight_map_value_type>::iterator,
+                          property_map<ring_graph, vertex_index_t>::const_type>
+      dist_pm(dist.begin(), get(vertex_index, g));
 
     dijkstra_shortest_paths(g, source,
-                            predecessor_map(&pred[0]).
-                            distance_map(&dist[0]) );
+                            predecessor_map(pred_pm).
+                            distance_map(dist_pm) );
 
     std::cout << "Dijkstra search from vertex " << source << std::endl;
-    for (tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
+    for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
       vertex_descriptor u = *vi;
       std::cout << "Vertex " << u << ": "
                 << "parent "<< pred[*vi] << ", "
diff --git a/example/inclusive_mean_geodesic.cpp b/example/inclusive_mean_geodesic.cpp
index 91d5a0d47..d825a27dc 100644
--- a/example/inclusive_mean_geodesic.cpp
+++ b/example/inclusive_mean_geodesic.cpp
@@ -121,7 +121,7 @@ main(int argc, char *argv[])
     cout << setw(12) << setiosflags(ios::left) << "excluding";
     cout << setw(12) << setiosflags(ios::left) << "including" << endl;
     graph_traits<Graph>::vertex_iterator i, end;
-    for(tie(i, end) = vertices(g); i != end; ++i) {
+    for(boost::tie(i, end) = vertices(g); i != end; ++i) {
         cout << setw(12) << setiosflags(ios::left)
              << g[*i].name
              << setw(12) << get(exmap, *i)
diff --git a/example/influence_prestige.cpp b/example/influence_prestige.cpp
index 348b0d160..e7d26f134 100644
--- a/example/influence_prestige.cpp
+++ b/example/influence_prestige.cpp
@@ -62,7 +62,7 @@ main(int argc, char *argv[])
 
     // Print the degree centrality of each vertex
     graph_traits<Graph>::vertex_iterator i, end;
-    for(tie(i, end) = vertices(g); i != end; ++i) {
+    for(boost::tie(i, end) = vertices(g); i != end; ++i) {
         Vertex v = *i;
         cout << setiosflags(ios::left) << setw(12)
              << g[v].name << "\t"
diff --git a/example/kuratowski_subgraph.cpp b/example/kuratowski_subgraph.cpp
index 5b080f46f..8f55a3e65 100644
--- a/example/kuratowski_subgraph.cpp
+++ b/example/kuratowski_subgraph.cpp
@@ -55,7 +55,7 @@ int main(int argc, char** argv)
   property_map<graph, edge_index_t>::type e_index = get(edge_index, g);
   graph_traits<graph>::edges_size_type edge_count = 0;
   graph_traits<graph>::edge_iterator ei, ei_end;
-  for(tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
+  for(boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
     put(e_index, *ei, edge_count++);
   
 
diff --git a/example/leda-concept-check.cpp b/example/leda-concept-check.cpp
index 21fc16060..f5720e7db 100644
--- a/example/leda-concept-check.cpp
+++ b/example/leda-concept-check.cpp
@@ -7,15 +7,16 @@
 //=======================================================================
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/leda_graph.hpp>
+#include <boost/concept/assert.hpp>
 
 int
 main()
 {
   using namespace boost;
-  typedef leda::GRAPH < int, int >Graph;
-  function_requires < VertexListGraphConcept < Graph > >();
-  function_requires < BidirectionalGraphConcept < Graph > >();
-  function_requires < VertexMutableGraphConcept < Graph > >();
-  function_requires < EdgeMutableGraphConcept < Graph > >();
+  typedef leda::GRAPH<int, int> Graph;
+  BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+  BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept< Graph> ));
+  BOOST_CONCEPT_ASSERT(( VertexMutableGraphConcept< Graph> ));
+  BOOST_CONCEPT_ASSERT(( EdgeMutableGraphConcept<Graph> ));
   return EXIT_SUCCESS;
 }
diff --git a/example/loops_dfs.cpp b/example/loops_dfs.cpp
index c6babb1eb..9536701b9 100644
--- a/example/loops_dfs.cpp
+++ b/example/loops_dfs.cpp
@@ -6,6 +6,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 //=======================================================================
 #include <boost/config.hpp>
+#include <boost/concept/assert.hpp>
 #include <iostream>
 #include <fstream>
 #include <stack>
@@ -47,7 +48,7 @@ find_loops(typename graph_traits < Graph >::vertex_descriptor entry,
            const Graph & g, 
            Loops & loops)    // A container of sets of vertices
 {
-  function_requires < BidirectionalGraphConcept < Graph > >();
+  BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph> ));
   typedef typename graph_traits < Graph >::edge_descriptor Edge;
   typedef typename graph_traits < Graph >::vertex_descriptor Vertex;
   std::vector < Edge > back_edges;
@@ -69,7 +70,7 @@ compute_loop_extent(typename graph_traits <
                     Graph >::edge_descriptor back_edge, const Graph & g,
                     Set & loop_set)
 {
-  function_requires < BidirectionalGraphConcept < Graph > >();
+  BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph> ));
   typedef typename graph_traits < Graph >::vertex_descriptor Vertex;
   typedef color_traits < default_color_type > Color;
 
diff --git a/example/make_biconnected_planar.cpp b/example/make_biconnected_planar.cpp
index 3c4a7745b..d0c0dd8eb 100644
--- a/example/make_biconnected_planar.cpp
+++ b/example/make_biconnected_planar.cpp
@@ -51,7 +51,7 @@ int main(int argc, char** argv)
   property_map<graph, edge_index_t>::type e_index = get(edge_index, g);
   graph_traits<graph>::edges_size_type edge_count = 0;
   graph_traits<graph>::edge_iterator ei, ei_end;
-  for(tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
+  for(boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
     put(e_index, *ei, edge_count++);
   
   
@@ -86,7 +86,7 @@ int main(int argc, char** argv)
 
   // Re-initialize the edge index, since we just added a few edges
   edge_count = 0;
-  for(tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
+  for(boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
     put(e_index, *ei, edge_count++);
 
   // Re-size the storage for the biconnected components, since we
diff --git a/example/make_maximal_planar.cpp b/example/make_maximal_planar.cpp
index 70fd9b3f1..50d42e8de 100644
--- a/example/make_maximal_planar.cpp
+++ b/example/make_maximal_planar.cpp
@@ -74,7 +74,7 @@ int main(int argc, char** argv)
   property_map<graph, edge_index_t>::type e_index = get(edge_index, g);
   graph_traits<graph>::edges_size_type edge_count = 0;
   graph_traits<graph>::edge_iterator ei, ei_end;
-  for(tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
+  for(boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
     put(e_index, *ei, edge_count++);
   
   
@@ -94,7 +94,7 @@ int main(int argc, char** argv)
 
   // Re-initialize the edge index, since we just added a few edges
   edge_count = 0;
-  for(tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
+  for(boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
     put(e_index, *ei, edge_count++);
 
 
@@ -116,7 +116,7 @@ int main(int argc, char** argv)
 
   // Re-initialize the edge index, since we just added a few edges
   edge_count = 0;
-  for(tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
+  for(boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
     put(e_index, *ei, edge_count++);
 
   // Test for planarity one final time; compute the planar embedding as a 
diff --git a/example/matching_example.cpp b/example/matching_example.cpp
old mode 100755
new mode 100644
index f1d47d954..de39f57c5
--- a/example/matching_example.cpp
+++ b/example/matching_example.cpp
@@ -44,6 +44,7 @@ int main()
   // our vertices are stored in a vector, so we can refer to vertices
   // by integers in the range 0..15
 
+  add_edge(1,2,g);
   add_edge(0,4,g);
   add_edge(1,5,g);
   add_edge(2,6,g);
@@ -83,7 +84,7 @@ int main()
   std::cout << "The matching is:" << std::endl;
   
   graph_traits<my_graph>::vertex_iterator vi, vi_end;
-  for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
+  for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
     if (mate[*vi] != graph_traits<my_graph>::null_vertex() && *vi < mate[*vi])
       std::cout << "{" << *vi << ", " << mate[*vi] << "}" << std::endl;
 
@@ -109,7 +110,7 @@ int main()
 
   std::cout << "The matching is:" << std::endl;
   
-  for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
+  for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
     if (mate[*vi] != graph_traits<my_graph>::null_vertex() && *vi < mate[*vi])
       std::cout << "{" << *vi << ", " << mate[*vi] << "}" << std::endl;
 
diff --git a/example/mcgregor_subgraphs_example.cpp b/example/mcgregor_subgraphs_example.cpp
index 35a3b6930..543259fc7 100644
--- a/example/mcgregor_subgraphs_example.cpp
+++ b/example/mcgregor_subgraphs_example.cpp
@@ -76,11 +76,7 @@ int main (int argc, char *argv[]) {
     property<vertex_index_t, unsigned int> >,
     property<edge_name_t, unsigned int> > Graph;
 
-  typedef graph_traits<Graph>::vertex_descriptor Vertex;
-  typedef graph_traits<Graph>::edge_descriptor Edge;
-
   typedef property_map<Graph, vertex_name_t>::type VertexNameMap;
-  typedef property_map<Graph, edge_name_t>::type EdgeNameMap;
 
   // Test maximum and unique variants on known graphs
   Graph graph_simple1, graph_simple2;
diff --git a/example/mean_geodesic.cpp b/example/mean_geodesic.cpp
index f6b6892c0..ca246b0a2 100644
--- a/example/mean_geodesic.cpp
+++ b/example/mean_geodesic.cpp
@@ -77,7 +77,7 @@ main(int argc, char *argv[])
     // Print the mean geodesic distance of each vertex and finally,
     // the graph itself.
     graph_traits<Graph>::vertex_iterator i, end;
-    for(tie(i, end) = vertices(g); i != end; ++i) {
+    for(boost::tie(i, end) = vertices(g); i != end; ++i) {
         cout << setw(12) << setiosflags(ios::left)
              << g[*i].name << get(gm, *i) << endl;
     }
diff --git a/example/min_max_paths.cpp b/example/min_max_paths.cpp
index 42a740b68..f32dd76e2 100644
--- a/example/min_max_paths.cpp
+++ b/example/min_max_paths.cpp
@@ -6,6 +6,9 @@
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //=======================================================================
+
+#error "This example appears to be incorrect; it uses edge weights that are smaller than 0 using the comparison operator passed to Dijkstra's algorithm, which is not allowed."
+
 #include <boost/config.hpp>
 #include <iostream>
 
diff --git a/example/planar_face_traversal.cpp b/example/planar_face_traversal.cpp
index 8d4daab46..fe96d2de4 100644
--- a/example/planar_face_traversal.cpp
+++ b/example/planar_face_traversal.cpp
@@ -94,7 +94,7 @@ int main(int argc, char** argv)
   property_map<graph, edge_index_t>::type e_index = get(edge_index, g);
   graph_traits<graph>::edges_size_type edge_count = 0;
   graph_traits<graph>::edge_iterator ei, ei_end;
-  for(tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
+  for(boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
     put(e_index, *ei, edge_count++);
   
 
diff --git a/example/put-get-helper-eg.cpp b/example/put-get-helper-eg.cpp
index 1134c0293..9c14e1b99 100644
--- a/example/put-get-helper-eg.cpp
+++ b/example/put-get-helper-eg.cpp
@@ -8,6 +8,7 @@
 #include <vector>
 #include <string>
 #include <boost/property_map/property_map.hpp>
+#include <boost/concept/assert.hpp>
 
 #ifdef BOOST_NO_STD_ITERATOR_TRAITS
 #error This examples requires a compiler that provides a working std::iterator_traits
@@ -53,6 +54,6 @@ main()
   typedef foo::iterator_property_map < vec_t::iterator,
     boost::identity_property_map > pmap_t;
   using namespace boost;
-  function_requires < Mutable_LvaluePropertyMapConcept < pmap_t, int > >();
+  BOOST_CONCEPT_ASSERT(( Mutable_LvaluePropertyMapConcept<pmap_t, int> ));
   return 0;
 }
diff --git a/example/scaled_closeness_centrality.cpp b/example/scaled_closeness_centrality.cpp
index 5223da97e..a2ade80c6 100644
--- a/example/scaled_closeness_centrality.cpp
+++ b/example/scaled_closeness_centrality.cpp
@@ -104,7 +104,7 @@ main(int argc, char *argv[])
 
     // Print the scaled closeness centrality of each vertex.
     graph_traits<Graph>::vertex_iterator i, end;
-    for(tie(i, end) = vertices(g); i != end; ++i) {
+    for(boost::tie(i, end) = vertices(g); i != end; ++i) {
         cout << setw(12) << setiosflags(ios::left)
              << g[*i].name << get(cm, *i) << endl;
     }
diff --git a/example/stoer_wagner.cpp b/example/stoer_wagner.cpp
index 792ee2084..09f13006a 100644
--- a/example/stoer_wagner.cpp
+++ b/example/stoer_wagner.cpp
@@ -5,6 +5,7 @@
 
 #include <cassert>
 #include <cstddef>
+#include <cstdlib>
 #include <iostream>
 #include <boost/graph/adjacency_list.hpp>
 #include <boost/graph/graph_traits.hpp>
@@ -19,14 +20,13 @@ struct edge_t
   unsigned long second;
 };
 
-// A graphic of the min-cut is available at <http://www.boost.org/doc/libs/release/libs/graph/doc/stoer_wagner.cpp.gif>
+// A graphic of the min-cut is available at <http://www.boost.org/doc/libs/release/libs/graph/doc/stoer_wagner_imgs/stoer_wagner.cpp.gif>
 int main()
 {
   using namespace std;
   
   typedef boost::adjacency_list<boost::vecS, boost::vecS, boost::undirectedS,
     boost::no_property, boost::property<boost::edge_weight_t, int> > undirected_graph;
-  typedef boost::graph_traits<undirected_graph>::vertex_descriptor vertex_descriptor;
   typedef boost::property_map<undirected_graph, boost::edge_weight_t>::type weight_map_type;
   typedef boost::property_traits<weight_map_type>::value_type weight_type;
   
diff --git a/example/straight_line_drawing.cpp b/example/straight_line_drawing.cpp
index 06d1145fc..15aa82968 100644
--- a/example/straight_line_drawing.cpp
+++ b/example/straight_line_drawing.cpp
@@ -122,7 +122,7 @@ int main(int argc, char** argv)
 
   std::cout << "The straight line drawing is: " << std::endl;
   graph_traits<graph>::vertex_iterator vi, vi_end;
-  for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
+  for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
     {
       coord_t coord(get(straight_line_drawing,*vi));
       std::cout << *vi << " -> (" << coord.x << ", " << coord.y << ")" 
diff --git a/example/strong_components.cpp b/example/strong_components.cpp
index 4b01f8862..089e3ef92 100644
--- a/example/strong_components.cpp
+++ b/example/strong_components.cpp
@@ -46,22 +46,23 @@ int main(int, char*[])
   using namespace boost;
   const char* name = "abcdefghij";
 
-  GraphvizDigraph G;
-  read_graphviz("scc.dot", G);
+  adjacency_list<vecS, vecS, directedS> G;
+  dynamic_properties dp;
+  read_graphviz("scc.dot", G, dp);
 
   std::cout << "A directed graph:" << std::endl;
   print_graph(G, name);
   std::cout << std::endl;
 
-  typedef graph_traits<GraphvizGraph>::vertex_descriptor Vertex;
+  typedef graph_traits<adjacency_list<vecS, vecS, directedS> >::vertex_descriptor Vertex;
     
   std::vector<int> component(num_vertices(G)), discover_time(num_vertices(G));
   std::vector<default_color_type> color(num_vertices(G));
   std::vector<Vertex> root(num_vertices(G));
-  int num = strong_components(G, &component[0], 
-                              root_map(&root[0]).
-                              color_map(&color[0]).
-                              discover_time_map(&discover_time[0]));
+  int num = strong_components(G, make_iterator_property_map(component.begin(), get(vertex_index, G)), 
+                              root_map(make_iterator_property_map(root.begin(), get(vertex_index, G))).
+                              color_map(make_iterator_property_map(color.begin(), get(vertex_index, G))).
+                              discover_time_map(make_iterator_property_map(discover_time.begin(), get(vertex_index, G))));
     
   std::cout << "Total number of components: " << num << std::endl;
   std::vector<int>::size_type i;
diff --git a/example/subgraph.cpp b/example/subgraph.cpp
index a28a6cab8..289ae54d9 100644
--- a/example/subgraph.cpp
+++ b/example/subgraph.cpp
@@ -41,7 +41,6 @@
 int main(int,char*[])
 {
   using namespace boost;
-  typedef adjacency_list_traits<vecS, vecS, directedS> Traits;
   typedef subgraph< adjacency_list<vecS, vecS, directedS,
     property<vertex_color_t, int>, property<edge_index_t, int> > > Graph;
 
diff --git a/example/subgraph_properties.cpp b/example/subgraph_properties.cpp
index 7de21cec9..613d53a3c 100644
--- a/example/subgraph_properties.cpp
+++ b/example/subgraph_properties.cpp
@@ -69,20 +69,20 @@ int main(int,char*[])
   
   std::cout << std::endl << "After initializing properties for G1:" << std::endl;
   std::cout << "  Global and local properties for vertex G0[C]..." << std::endl;
-  std::cout << "    G0[C]= " << boost::get(vertex_name, G0, C) << std::endl;// prints: "G0[C]= C"
-  std::cout << "    G1[A1]= " << boost::get(vertex_name, G1, A1) << std::endl;// prints: "G1[A1]= A1"
+  std::cout << "    G0[C]= " << boost::get(vertex_name, G0, vertex(C, G0)) << std::endl;// prints: "G0[C]= C"
+  std::cout << "    G1[A1]= " << boost::get(vertex_name, G1, vertex(A1, G1)) << std::endl;// prints: "G1[A1]= A1"
   
   name1[B1] = "B1";
   
   std::cout << "  Global and local properties for vertex G0[E]..." << std::endl;
-  std::cout << "    G0[E]= " << boost::get(vertex_name, G0, E) << std::endl;// prints: "G0[E]= E"
-  std::cout << "    G1[B1]= " << boost::get(vertex_name, G1, B1) << std::endl;// prints: "G1[B1]= B1"
+  std::cout << "    G0[E]= " << boost::get(vertex_name, G0, vertex(E, G0)) << std::endl;// prints: "G0[E]= E"
+  std::cout << "    G1[B1]= " << boost::get(vertex_name, G1, vertex(B1, G1)) << std::endl;// prints: "G1[B1]= B1"
   
   name1[C1] = "C1";
   
   std::cout << "  Global and local properties for vertex G0[F]..." << std::endl;
-  std::cout << "    G0[F]= " << boost::get(vertex_name, G0, F) << std::endl;// prints: "G0[F]= F"
-  std::cout << "    G1[C1]= " << boost::get(vertex_name, G1, C1) << std::endl;// prints: "G1[C1]= C1"
+  std::cout << "    G0[F]= " << boost::get(vertex_name, G0, vertex(F, G0)) << std::endl;// prints: "G0[F]= F"
+  std::cout << "    G1[C1]= " << boost::get(vertex_name, G1, vertex(C1, G1)) << std::endl;// prints: "G1[C1]= C1"
   
   Graph& G2 = G0.create_subgraph();
   enum { A2, B2 };              // for conveniently refering to vertices in G2
@@ -95,15 +95,15 @@ int main(int,char*[])
   
   std::cout << std::endl << std::endl << "After initializing properties for G2:" << std::endl;
   std::cout << "  Global and local properties for vertex G0[A]" << std::endl;
-  std::cout << "    G0[A]= " << boost::get(vertex_name, G0, A) << std::endl;// prints: "G0[A]= A"
-  std::cout << "    G2[A2]= " << boost::get(vertex_name, G2, A2) << std::endl;// prints: "G2[A2]= A2"
+  std::cout << "    G0[A]= " << boost::get(vertex_name, G0, vertex(A, G0)) << std::endl;// prints: "G0[A]= A"
+  std::cout << "    G2[A2]= " << boost::get(vertex_name, G2, vertex(A2, G2)) << std::endl;// prints: "G2[A2]= A2"
   
   name2[B2] = "B2";
   
   std::cout << "  Global and local properties for vertex G0[C]..." << std::endl;
-  std::cout << "    G0[C]= " << boost::get(vertex_name, G0, C) << std::endl;// prints: "G0[C]= C"
-  std::cout << "    G1[A1]= " << boost::get(vertex_name, G1, A1) << std::endl;// prints: "G1[A1]= A1"
-  std::cout << "    G2[B2]= " << boost::get(vertex_name, G2, B2) << std::endl;// prints: "G2[B2]= B2"
+  std::cout << "    G0[C]= " << boost::get(vertex_name, G0, vertex(C, G0)) << std::endl;// prints: "G0[C]= C"
+  std::cout << "    G1[A1]= " << boost::get(vertex_name, G1, vertex(A1, G1)) << std::endl;// prints: "G1[A1]= A1"
+  std::cout << "    G2[B2]= " << boost::get(vertex_name, G2, vertex(B2, G2)) << std::endl;// prints: "G2[B2]= B2"
   
   return 0;
 }
diff --git a/example/successive_shortest_path_nonnegative_weights_example.cpp b/example/successive_shortest_path_nonnegative_weights_example.cpp
new file mode 100644
index 000000000..0edc3710f
--- /dev/null
+++ b/example/successive_shortest_path_nonnegative_weights_example.cpp
@@ -0,0 +1,30 @@
+//=======================================================================
+// Copyright 2013 University of Warsaw.
+// Authors: Piotr Wygocki 
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//=======================================================================
+
+#include <boost/graph/successive_shortest_path_nonnegative_weights.hpp>
+#include <boost/graph/find_flow_cost.hpp>
+
+#include "../test/min_cost_max_flow_utils.hpp"
+
+
+int main() {
+    boost::SampleGraph::vertex_descriptor s,t;
+    boost::SampleGraph::Graph g; 
+    boost::SampleGraph::getSampleGraph(g, s, t);
+
+    boost::successive_shortest_path_nonnegative_weights(g, s, t);
+
+    int cost =  boost::find_flow_cost(g);
+    assert(cost == 29);
+
+    return 0;
+}
+
+
+
diff --git a/example/two_graphs_common_spanning_trees.cpp b/example/two_graphs_common_spanning_trees.cpp
new file mode 100644
index 000000000..2fa851798
--- /dev/null
+++ b/example/two_graphs_common_spanning_trees.cpp
@@ -0,0 +1,94 @@
+//          Copyright (C) 2012, Michele Caini.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+//          Two Graphs Common Spanning Trees Algorithm
+//      Based on academic article of Mint, Read and Tarjan
+//     Efficient Algorithm for Common Spanning Tree Problem
+// Electron. Lett., 28 April 1983, Volume 19, Issue 9, p.346-347
+
+
+#include <boost/graph/adjacency_list.hpp>
+#include <boost/graph/two_graphs_common_spanning_trees.hpp>
+#include <exception>
+#include <vector>
+
+
+using namespace std;
+
+typedef
+boost::adjacency_list
+  <
+    boost::vecS,         // OutEdgeList
+    boost::vecS,         // VertexList
+    boost::undirectedS,  // Directed
+    boost::no_property,  // VertexProperties
+    boost::no_property,  // EdgeProperties
+    boost::no_property,  // GraphProperties
+    boost::listS         // EdgeList
+  >
+Graph
+;
+
+typedef
+boost::graph_traits<Graph>::vertex_descriptor
+vertex_descriptor;
+
+typedef
+boost::graph_traits<Graph>::edge_descriptor
+edge_descriptor;
+
+typedef
+boost::graph_traits<Graph>::vertex_iterator
+vertex_iterator;
+
+typedef
+boost::graph_traits<Graph>::edge_iterator
+edge_iterator;
+
+
+int main(int argc, char **argv)
+{
+  Graph iG, vG;
+  vector< edge_descriptor > iG_o;
+  vector< edge_descriptor > vG_o;
+
+  iG_o.push_back(boost::add_edge(0, 1, iG).first);
+  iG_o.push_back(boost::add_edge(0, 2, iG).first);
+  iG_o.push_back(boost::add_edge(0, 3, iG).first);
+  iG_o.push_back(boost::add_edge(0, 4, iG).first);
+  iG_o.push_back(boost::add_edge(1, 2, iG).first);
+  iG_o.push_back(boost::add_edge(3, 4, iG).first);
+
+  vG_o.push_back(boost::add_edge(1, 2, vG).first);
+  vG_o.push_back(boost::add_edge(2, 0, vG).first);
+  vG_o.push_back(boost::add_edge(2, 3, vG).first);
+  vG_o.push_back(boost::add_edge(4, 3, vG).first);
+  vG_o.push_back(boost::add_edge(0, 3, vG).first);
+  vG_o.push_back(boost::add_edge(0, 4, vG).first);
+
+  vector<bool> inL(iG_o.size(), false);
+
+  std::vector< std::vector<bool> > coll;
+  boost::tree_collector<
+      std::vector< std::vector<bool> >,
+      std::vector<bool>
+    > tree_collector(coll);
+  boost::two_graphs_common_spanning_trees
+    (
+      iG,
+      iG_o,
+      vG,
+      vG_o,
+      tree_collector,
+      inL
+    );
+  
+  std::vector< std::vector<bool> >::iterator it;
+  for(it = coll.begin(); it != coll.end(); ++it) {
+    // Here you can play with the trees that the algorithm has found.
+  }
+
+  return 0;
+}
diff --git a/example/undirected.cpp b/example/undirected_adjacency_list.cpp
similarity index 87%
rename from example/undirected.cpp
rename to example/undirected_adjacency_list.cpp
index 97b14d990..49d312021 100644
--- a/example/undirected.cpp
+++ b/example/undirected_adjacency_list.cpp
@@ -26,12 +26,12 @@ undirected_graph_demo1()
   add_edge(zero, two, undigraph);
   add_edge(one, two, undigraph);
 
-  std::cout << "out_edges(0): ";
+  std::cout << "out_edges(0):";
   for (boost::tie(out, out_end) = out_edges(zero, undigraph); out != out_end; ++out)
-    std::cout << *out;
-  std::cout << std::endl << "in_edges(0): ";
+    std::cout << ' ' << *out;
+  std::cout << std::endl << "in_edges(0):";
   for (boost::tie(in, in_end) = in_edges(zero, undigraph); in != in_end; ++in)
-    std::cout << *in;
+    std::cout << ' ' << *in;
   std::cout << std::endl;
 }
 
@@ -91,6 +91,14 @@ undirected_graph_demo2()
 #endif
   std::cout << "weight[(u,v)] = " << get(weight, e1) << std::endl;
   std::cout << "weight[(v,u)] = " << get(weight, e2) << std::endl;
+
+  std::cout << "the edges incident to v: ";
+  typename boost::graph_traits<UndirectedGraph>::out_edge_iterator e, e_end;
+  typename boost::graph_traits<UndirectedGraph>::vertex_descriptor 
+    s = vertex(0, undigraph);
+  for (boost::tie(e, e_end) = out_edges(s, undigraph); e != e_end; ++e)
+    std::cout << "(" << source(*e, undigraph) 
+              << "," << target(*e, undigraph) << ")" << std::endl;
 }
 
 
@@ -103,7 +111,7 @@ main()
   typedef adjacency_list < vecS, vecS, directedS,
     no_property, Weight > DirectedGraph;
   undirected_graph_demo1 < UndirectedGraph > ();
-  undirected_graph_demo2 < UndirectedGraph > ();
   directed_graph_demo < DirectedGraph > ();
+  undirected_graph_demo2 < UndirectedGraph > ();
   return 0;
 }
diff --git a/example/undirected.expected b/example/undirected_adjacency_list.expected
similarity index 79%
rename from example/undirected.expected
rename to example/undirected_adjacency_list.expected
index 015a7afc9..b02c64016 100644
--- a/example/undirected.expected
+++ b/example/undirected_adjacency_list.expected
@@ -1,3 +1,5 @@
+out_edges(0): (0,1) (0,2)
+in_edges(0): (1,0) (2,0)
 in a directed graph is (u,v) == (v,u) ? 0
 weight[(u,v)] = 1.2
 weight[(v,u)] = 2.4
diff --git a/example/undirected_graph.cpp b/example/undirected_graph.cpp
new file mode 100644
index 000000000..d926c7b51
--- /dev/null
+++ b/example/undirected_graph.cpp
@@ -0,0 +1,30 @@
+//=======================================================================
+// Copyright 2012
+// Authors: David Doria
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//=======================================================================
+
+#include <boost/graph/graph_traits.hpp>
+#include <boost/graph/undirected_graph.hpp>
+
+typedef boost::undirected_graph<boost::no_property> Graph;
+
+int main(int,char*[])
+{
+  // Create a graph object
+  Graph g;
+
+  // Add vertices
+  boost::graph_traits<Graph>::vertex_descriptor v0 = g.add_vertex();
+  boost::graph_traits<Graph>::vertex_descriptor v1 = g.add_vertex();
+  boost::graph_traits<Graph>::vertex_descriptor v2 = g.add_vertex();
+
+  // Add edges
+  g.add_edge(v0, v1);
+  g.add_edge(v1, v2);
+
+  return 0;
+}
diff --git a/example/vf2_sub_graph_iso_example.cpp b/example/vf2_sub_graph_iso_example.cpp
new file mode 100755
index 000000000..8e17d2a70
--- /dev/null
+++ b/example/vf2_sub_graph_iso_example.cpp
@@ -0,0 +1,40 @@
+//=======================================================================
+// Copyright (C) 2012 Flavio De Lorenzi (fdlorenzi@gmail.com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//=======================================================================
+
+#include <boost/graph/adjacency_list.hpp>
+#include <boost/graph/vf2_sub_graph_iso.hpp>
+using namespace boost;
+
+
+int main() {
+
+  typedef adjacency_list<setS, vecS, bidirectionalS> graph_type;
+  
+  // Build graph1
+  int num_vertices1 = 8; graph_type graph1(num_vertices1);
+  add_edge(0, 6, graph1); add_edge(0, 7, graph1);
+  add_edge(1, 5, graph1); add_edge(1, 7, graph1);
+  add_edge(2, 4, graph1); add_edge(2, 5, graph1); add_edge(2, 6, graph1);
+  add_edge(3, 4, graph1);
+
+  // Build graph2
+  int num_vertices2 = 9; graph_type graph2(num_vertices2);
+  add_edge(0, 6, graph2); add_edge(0, 8, graph2);
+  add_edge(1, 5, graph2); add_edge(1, 7, graph2);
+  add_edge(2, 4, graph2); add_edge(2, 7, graph2); add_edge(2, 8, graph2);
+  add_edge(3, 4, graph2); add_edge(3, 5, graph2); add_edge(3, 6, graph2);
+
+  // Create callback to print mappings
+  vf2_print_callback<graph_type, graph_type> callback(graph1, graph2);
+
+  // Print out all subgraph isomorphism mappings between graph1 and graph2.
+  // Vertices and edges are assumed to be always equivalent.
+  vf2_subgraph_iso(graph1, graph2, callback);
+
+  return 0;
+}
diff --git a/example/vf2_sub_graph_iso_multi_example.cpp b/example/vf2_sub_graph_iso_multi_example.cpp
new file mode 100755
index 000000000..6f9e34a2a
--- /dev/null
+++ b/example/vf2_sub_graph_iso_multi_example.cpp
@@ -0,0 +1,89 @@
+//=======================================================================
+// Copyright (C) 2012 Flavio De Lorenzi (fdlorenzi@gmail.com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//=======================================================================
+
+#include <boost/graph/adjacency_list.hpp>
+#include <boost/graph/vf2_sub_graph_iso.hpp>
+using namespace boost;
+
+int main() {
+  typedef property<edge_name_t, char> edge_property;
+  typedef property<vertex_name_t, char, property<vertex_index_t, int> > vertex_property;
+
+  // Using a vecS graphs => the index maps are implicit.
+  typedef adjacency_list<vecS, vecS, bidirectionalS, vertex_property, edge_property> graph_type;
+  
+  // Build graph1
+  graph_type graph1;
+  
+  add_vertex(vertex_property('a'), graph1);
+  add_vertex(vertex_property('a'), graph1);
+  add_vertex(vertex_property('a'), graph1);
+  
+  add_edge(0, 1, edge_property('b'), graph1); 
+  add_edge(0, 1, edge_property('b'), graph1); 
+  add_edge(0, 1, edge_property('d'), graph1); 
+  
+  add_edge(1, 2, edge_property('s'), graph1); 
+  
+  add_edge(2, 2, edge_property('l'), graph1); 
+  add_edge(2, 2, edge_property('l'), graph1); 
+  
+  // Build graph2
+  graph_type graph2;
+  
+  add_vertex(vertex_property('a'), graph2);
+  add_vertex(vertex_property('a'), graph2);
+  add_vertex(vertex_property('a'), graph2);
+  add_vertex(vertex_property('a'), graph2);
+  add_vertex(vertex_property('a'), graph2);
+  add_vertex(vertex_property('a'), graph2);
+  
+  add_edge(0, 1, edge_property('a'), graph2); 
+  add_edge(0, 1, edge_property('a'), graph2); 
+  add_edge(0, 1, edge_property('b'), graph2); 
+
+  add_edge(1, 2, edge_property('s'), graph2); 
+  
+  add_edge(2, 3, edge_property('b'), graph2); 
+  add_edge(2, 3, edge_property('d'), graph2); 
+  add_edge(2, 3, edge_property('b'), graph2); 
+  
+  add_edge(3, 4, edge_property('s'), graph2); 
+  
+  add_edge(4, 4, edge_property('l'), graph2); 
+  add_edge(4, 4, edge_property('l'), graph2); 
+
+  add_edge(4, 5, edge_property('c'), graph2); 
+  add_edge(4, 5, edge_property('c'), graph2); 
+  add_edge(4, 5, edge_property('c'), graph2); 
+  
+  add_edge(5, 0, edge_property('s'), graph2); 
+  
+  // create predicates
+  typedef property_map<graph_type, vertex_name_t>::type vertex_name_map_t;
+  typedef property_map_equivalent<vertex_name_map_t, vertex_name_map_t> vertex_comp_t;
+  vertex_comp_t vertex_comp =
+    make_property_map_equivalent(get(vertex_name, graph1), get(vertex_name, graph2));
+  
+  typedef property_map<graph_type, edge_name_t>::type edge_name_map_t;
+  typedef property_map_equivalent<edge_name_map_t, edge_name_map_t> edge_comp_t;
+  edge_comp_t edge_comp =
+    make_property_map_equivalent(get(edge_name, graph1), get(edge_name, graph2));
+ 
+  // Create callback
+  vf2_print_callback<graph_type, graph_type> callback(graph1, graph2);
+
+  // Print out all subgraph isomorphism mappings between graph1 and graph2.
+  // Function vertex_order_by_mult is used to compute the order of 
+  // vertices of graph1. This is the order in which the vertices are examined
+  // during the matching process.
+  vf2_subgraph_iso(graph1, graph2, callback, vertex_order_by_mult(graph1),
+                   edges_equivalent(edge_comp).vertices_equivalent(vertex_comp));
+  
+  return 0;
+}
diff --git a/include/boost/graph/adj_list_serialize.hpp b/include/boost/graph/adj_list_serialize.hpp
index c1ff4111d..01db50282 100644
--- a/include/boost/graph/adj_list_serialize.hpp
+++ b/include/boost/graph/adj_list_serialize.hpp
@@ -61,6 +61,8 @@ inline void save(
     ar << serialization::make_nvp("v" , indices[target(e,graph)]);
     ar << serialization::make_nvp("edge_property", get(edge_all_t(), graph, e) );
   }
+
+  ar << serialization::make_nvp("graph_property", get_property(graph, graph_all_t()) );
 }
 
 
@@ -95,6 +97,7 @@ inline void load(
     boost::tie(e,inserted) = add_edge(verts[u], verts[v], graph);
     ar >> serialization::make_nvp("edge_property", get(edge_all_t(), graph, e) );
   }
+  ar >> serialization::make_nvp("graph_property", get_property(graph, graph_all_t()) );
 }
 
 template<class Archive, class OEL, class VL, class D, class VP, class EP, class GP, class EL>
diff --git a/include/boost/graph/adjacency_list.hpp b/include/boost/graph/adjacency_list.hpp
index 5034fec5a..d7fbc06d8 100644
--- a/include/boost/graph/adjacency_list.hpp
+++ b/include/boost/graph/adjacency_list.hpp
@@ -51,11 +51,6 @@ namespace boost {
   // adjacency_list, and the container_gen traits class which is used
   // to map the selectors to the container type used to implement the
   // graph.
-  //
-  // The main container_gen traits class uses partial specialization,
-  // so we also include a workaround.
-
-#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
 #if !defined BOOST_NO_SLIST
   struct slistS {};
@@ -130,93 +125,6 @@ namespace boost {
     typedef boost::unordered_multiset<ValueType> type;
   };
 
-#else // !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-#if !defined BOOST_NO_SLIST
-  struct slistS {
-    template <class T>
-    struct bind_ { typedef BOOST_STD_EXTENSION_NAMESPACE::slist<T> type; };
-  };
-#endif
-
-  struct vecS  {
-    template <class T>
-    struct bind_ { typedef std::vector<T> type; };
-  };
-
-  struct listS {
-    template <class T>
-    struct bind_ { typedef std::list<T> type; };
-  };
-
-  struct setS  {
-    template <class T>
-    struct bind_ { typedef std::set<T, std::less<T> > type; };
-  };
-
-
-  struct mapS  {
-    template <class T>
-    struct bind_ { typedef std::set<T, std::less<T> > type; };
-  };
-
-  struct multisetS  {
-    template <class T>
-    struct bind_ { typedef std::multiset<T, std::less<T> > type; };
-  };
-
-  struct multimapS  {
-    template <class T>
-    struct bind_ { typedef std::multiset<T, std::less<T> > type; };
-  };
-
-  struct hash_setS {
-    template <class T>
-    struct bind_ { typedef boost::unordered_set<T> type; };
-  };
-
-  struct hash_mapS {
-    template <class T>
-    struct bind_ { typedef boost::unordered_set<T> type; };
-  };
-
-  struct hash_multisetS {
-    template <class T>
-    struct bind_ { typedef boost::unordered_multiset<T> type; };
-  };
-
-  struct hash_multimapS {
-    template <class T>
-    struct bind_ { typedef boost::unordered_multiset<T> type; };
-  };
-
-  template <class Selector> struct container_selector {
-    typedef vecS type;
-  };
-
-#define BOOST_CONTAINER_SELECTOR(NAME) \
-  template <> struct container_selector<NAME>  { \
-    typedef NAME type; \
-  }
-
-  BOOST_CONTAINER_SELECTOR(vecS);
-  BOOST_CONTAINER_SELECTOR(listS);
-  BOOST_CONTAINER_SELECTOR(mapS);
-  BOOST_CONTAINER_SELECTOR(setS);
-  BOOST_CONTAINER_SELECTOR(multisetS);
-  BOOST_CONTAINER_SELECTOR(hash_mapS);
-#if !defined BOOST_NO_SLIST
-  BOOST_CONTAINER_SELECTOR(slistS);
-#endif
-
-  template <class Selector, class ValueType>
-  struct container_gen {
-    typedef typename container_selector<Selector>::type Select;
-    typedef typename Select:: template bind_<ValueType>::type type;
-  };
-
-#endif // !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
   template <class StorageSelector>
   struct parallel_edge_traits { };
 
@@ -280,6 +188,7 @@ namespace boost {
 
   } // namespace detail
 
+  template <typename Selector> struct is_distributed_selector: mpl::false_ {};
 
 
   //===========================================================================
@@ -354,13 +263,7 @@ namespace boost {
       adjacency_list<OutEdgeListS,VertexListS,DirectedS,
                      VertexProperty,EdgeProperty,GraphProperty,EdgeListS>,
       VertexListS, OutEdgeListS, DirectedS,
-#if !defined(BOOST_GRAPH_NO_BUNDLED_PROPERTIES)
-      typename detail::retag_property_list<vertex_bundle_t,
-                                           VertexProperty>::type,
-      typename detail::retag_property_list<edge_bundle_t, EdgeProperty>::type,
-#else
       VertexProperty, EdgeProperty,
-#endif
       GraphProperty, EdgeListS>::type,
       // Support for named vertices
       public graph::maybe_named_graph<
@@ -371,25 +274,14 @@ namespace boost {
         VertexProperty>
   {
       public:
-#if !defined(BOOST_GRAPH_NO_BUNDLED_PROPERTIES)
-    typedef typename graph_detail::graph_prop<GraphProperty>::property graph_property_type;
-    typedef typename graph_detail::graph_prop<GraphProperty>::bundle graph_bundled;
-
-    typedef typename graph_detail::vertex_prop<VertexProperty>::property vertex_property_type;
-    typedef typename graph_detail::vertex_prop<VertexProperty>::bundle vertex_bundled;
-
-    typedef typename graph_detail::edge_prop<EdgeProperty>::property edge_property_type;
-    typedef typename graph_detail::edge_prop<EdgeProperty>::bundle edge_bundled;
-#else
     typedef GraphProperty graph_property_type;
-    typedef no_graph_bundle graph_bundled;
+    typedef typename lookup_one_property<GraphProperty, graph_bundle_t>::type graph_bundled;
 
     typedef VertexProperty vertex_property_type;
-    typedef no_vertex_bundle vertex_bundled;
+    typedef typename lookup_one_property<VertexProperty, vertex_bundle_t>::type vertex_bundled;
 
     typedef EdgeProperty edge_property_type;
-    typedef no_edge_bundle edge_bundled;
-#endif
+    typedef typename lookup_one_property<EdgeProperty, edge_bundle_t>::type edge_bundled;
 
   private:
     typedef adjacency_list self;
@@ -437,7 +329,6 @@ namespace boost {
       : Base(num_vertices), m_property(new graph_property_type(p))
     { }
 
-#if !defined(BOOST_MSVC) || BOOST_MSVC >= 1300
     // Required by Iterator Constructible Graph
     template <class EdgeIterator>
     adjacency_list(EdgeIterator first, EdgeIterator last,
@@ -455,7 +346,6 @@ namespace boost {
                           const GraphProperty& p = GraphProperty())
       : Base(n, first, last, ep_iter), m_property(new graph_property_type(p))
     { }
-#endif
 
     void swap(adjacency_list& x) {
       // Is there a more efficient way to do this?
@@ -502,20 +392,20 @@ namespace boost {
 #define ADJLIST adjacency_list<OEL,VL,D,VP,EP,GP,EL>
 
   template<ADJLIST_PARAMS, typename Tag, typename Value>
-  inline void set_property(ADJLIST& g, Tag, Value const& value) {
-    get_property_value(*g.m_property, Tag()) = value;
+  inline void set_property(ADJLIST& g, Tag tag, Value const& value) {
+    get_property_value(*g.m_property, tag) = value;
   }
 
   template<ADJLIST_PARAMS, typename Tag>
   inline typename graph_property<ADJLIST, Tag>::type&
-  get_property(ADJLIST& g, Tag) {
-    return get_property_value(*g.m_property, Tag());
+  get_property(ADJLIST& g, Tag tag) {
+    return get_property_value(*g.m_property, tag);
   }
 
   template<ADJLIST_PARAMS, typename Tag>
   inline typename graph_property<ADJLIST, Tag>::type const&
-  get_property(ADJLIST const& g, Tag) {
-    return get_property_value(*g.m_property, Tag());
+  get_property(ADJLIST const& g, Tag tag) {
+    return get_property_value(*g.m_property, tag);
   }
 
   // dwa 09/25/00 - needed to be more explicit so reverse_graph would work.
@@ -545,58 +435,6 @@ namespace boost {
     return e.m_target;
   }
 
-  // Support for bundled properties
-#ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES
-  template<typename OutEdgeListS, typename VertexListS, typename DirectedS, typename VertexProperty,
-           typename EdgeProperty, typename GraphProperty, typename EdgeListS, typename T, typename Bundle>
-  inline
-  typename property_map<adjacency_list<OutEdgeListS, VertexListS, DirectedS, VertexProperty, EdgeProperty,
-                                       GraphProperty, EdgeListS>, T Bundle::*>::type
-  get(T Bundle::* p, adjacency_list<OutEdgeListS, VertexListS, DirectedS, VertexProperty, EdgeProperty,
-                                    GraphProperty, EdgeListS>& g)
-  {
-    typedef typename property_map<adjacency_list<OutEdgeListS, VertexListS, DirectedS, VertexProperty,
-                                                 EdgeProperty, GraphProperty, EdgeListS>, T Bundle::*>::type
-      result_type;
-    return result_type(&g, p);
-  }
-
-  template<typename OutEdgeListS, typename VertexListS, typename DirectedS, typename VertexProperty,
-           typename EdgeProperty, typename GraphProperty, typename EdgeListS, typename T, typename Bundle>
-  inline
-  typename property_map<adjacency_list<OutEdgeListS, VertexListS, DirectedS, VertexProperty, EdgeProperty,
-                                       GraphProperty, EdgeListS>, T Bundle::*>::const_type
-  get(T Bundle::* p, adjacency_list<OutEdgeListS, VertexListS, DirectedS, VertexProperty, EdgeProperty,
-                                    GraphProperty, EdgeListS> const & g)
-  {
-    typedef typename property_map<adjacency_list<OutEdgeListS, VertexListS, DirectedS, VertexProperty,
-                                                 EdgeProperty, GraphProperty, EdgeListS>, T Bundle::*>::const_type
-      result_type;
-    return result_type(&g, p);
-  }
-
-  template<typename OutEdgeListS, typename VertexListS, typename DirectedS, typename VertexProperty,
-           typename EdgeProperty, typename GraphProperty, typename EdgeListS, typename T, typename Bundle,
-           typename Key>
-  inline T
-  get(T Bundle::* p, adjacency_list<OutEdgeListS, VertexListS, DirectedS, VertexProperty, EdgeProperty,
-                                    GraphProperty, EdgeListS> const & g, const Key& key)
-  {
-    return get(get(p, g), key);
-  }
-
-  template<typename OutEdgeListS, typename VertexListS, typename DirectedS, typename VertexProperty,
-           typename EdgeProperty, typename GraphProperty, typename EdgeListS, typename T, typename Bundle,
-           typename Key>
-  inline void
-  put(T Bundle::* p, adjacency_list<OutEdgeListS, VertexListS, DirectedS, VertexProperty, EdgeProperty,
-                                    GraphProperty, EdgeListS>& g, const Key& key, const T& value)
-  {
-    put(get(p, g), key, value);
-  }
-
-#endif
-
 // Mutability Traits
 template <ADJLIST_PARAMS>
 struct graph_mutability_traits<ADJLIST> {
diff --git a/include/boost/graph/adjacency_list_io.hpp b/include/boost/graph/adjacency_list_io.hpp
index 91b0b465d..aaba8a43c 100644
--- a/include/boost/graph/adjacency_list_io.hpp
+++ b/include/boost/graph/adjacency_list_io.hpp
@@ -40,7 +40,7 @@ namespace boost {
 template<class Tag, class Value, class Next>
 std::istream& operator >> ( std::istream& in, property<Tag,Value,Next>& p )
 {
-        in >> p.m_value >> *(static_cast<Next*>(&p)); // houpla !!
+        in >> p.m_value >> p.m_base; // houpla !!
         return in;
 }
 
@@ -65,7 +65,7 @@ template<class Tag, class Value, class Next, class V, class Stag>
 void get
 ( property<Tag,Value,Next>& p, const V& v, Stag s )
 {
-        get( *(static_cast<Next*>(&p)),v,s );
+        get( p.m_base,v,s );
 }
 
 template<class Value, class Next, class V, class Stag>
@@ -82,7 +82,7 @@ void getSubset
 ( property<Tag,Value,Next>& p, const property<Stag,Svalue,Snext>& s )
 {
         get( p, s.m_value, Stag() );
-        getSubset( p, Snext(s) );
+        getSubset( p, s.m_base );
 }
 
 template<class Tag, class Value, class Next, 
@@ -215,7 +215,7 @@ struct PropertyPrinter
         template<class Val>
         PropertyPrinter& operator () ( std::ostream& out, const Val& v )
         {
-                typename property_map<Graph,Tag>::type ps = get(Tag(), *graph);
+                typename property_map<Graph,Tag>::const_type ps = get(Tag(), *graph);
                 out << ps[ v ] <<" ";
                 PropertyPrinter<Graph,Next> print(*graph);
                 print(out, v);
@@ -248,7 +248,7 @@ struct PropertyPrinter<Graph, property<Tag, Value, Next> >
         template<class Val>
         PropertyPrinter& operator () ( std::ostream& out, const Val& v )
         {
-                typename property_map<Graph,Tag>::type ps = get(Tag(), *graph);
+                typename property_map<Graph,Tag>::const_type ps = get(Tag(), *graph);
                 out << ps[ v ] <<" ";
                 PropertyPrinter<Graph,Next> print(*graph);
                 print(out, v);
diff --git a/include/boost/graph/adjacency_matrix.hpp b/include/boost/graph/adjacency_matrix.hpp
index 6fb1f4865..b1078d977 100644
--- a/include/boost/graph/adjacency_matrix.hpp
+++ b/include/boost/graph/adjacency_matrix.hpp
@@ -14,13 +14,14 @@
 #include <boost/config.hpp>
 #include <vector>
 #include <memory>
-#include <cassert>
+#include <boost/assert.hpp>
 #include <boost/limits.hpp>
 #include <boost/iterator.hpp>
 #include <boost/graph/graph_traits.hpp>
 #include <boost/graph/graph_mutability_traits.hpp>
 #include <boost/graph/graph_selectors.hpp>
 #include <boost/mpl/if.hpp>
+#include <boost/mpl/bool.hpp>
 #include <boost/graph/adjacency_iterator.hpp>
 #include <boost/graph/detail/edge.hpp>
 #include <boost/iterator/iterator_adaptor.hpp>
@@ -29,7 +30,10 @@
 #include <boost/graph/properties.hpp>
 #include <boost/tuple/tuple.hpp>
 #include <boost/static_assert.hpp>
-#include <boost/type_traits/ice.hpp>
+#include <boost/type_traits.hpp>
+#include <boost/property_map/property_map.hpp>
+#include <boost/property_map/transform_value_property_map.hpp>
+#include <boost/property_map/function_property_map.hpp>
 
 namespace boost {
 
@@ -439,9 +443,7 @@ namespace boost {
     // graph type. Instead, use directedS, which also provides the
     // functionality required for a Bidirectional Graph (in_edges,
     // in_degree, etc.).
-#if !defined(_MSC_VER) || _MSC_VER > 1300
     BOOST_STATIC_ASSERT(type_traits::ice_not<(is_same<Directed, bidirectionalS>::value)>::value);
-#endif
 
     typedef typename mpl::if_<is_directed,
                                     bidirectional_tag, undirected_tag>::type
@@ -476,41 +478,27 @@ namespace boost {
     typedef adjacency_matrix_traits<Directed> Traits;
 
   public:
-#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
     // The bidirectionalS tag is not allowed with the adjacency_matrix
     // graph type. Instead, use directedS, which also provides the
     // functionality required for a Bidirectional Graph (in_edges,
     // in_degree, etc.).
     BOOST_STATIC_ASSERT(!(is_same<Directed, bidirectionalS>::value));
-#endif
-
-#if !defined(BOOST_GRAPH_NO_BUNDLED_PROPERTIES)
-    typedef typename graph_detail::graph_prop<GraphProperty>::property graph_property_type;
-    typedef typename graph_detail::graph_prop<GraphProperty>::bundle graph_bundled;
-
-    typedef typename graph_detail::vertex_prop<VertexProperty>::property vertex_property_type;
-    typedef typename graph_detail::vertex_prop<VertexProperty>::bundle vertex_bundled;
 
-    typedef typename graph_detail::edge_prop<EdgeProperty>::property edge_property_type;
-    typedef typename graph_detail::edge_prop<EdgeProperty>::bundle edge_bundled;
-#else
     typedef GraphProperty graph_property_type;
-    typedef no_graph_bundle graph_bundled;
+    typedef typename lookup_one_property<GraphProperty, graph_bundle_t>::type graph_bundled;
 
     typedef VertexProperty vertex_property_type;
-    typedef no_vertex_bundle vertex_bundled;
+    typedef typename lookup_one_property<VertexProperty, vertex_bundle_t>::type vertex_bundled;
 
     typedef EdgeProperty edge_property_type;
-    typedef no_edge_bundle edge_bundled;
-#endif
+    typedef typename lookup_one_property<EdgeProperty, edge_bundle_t>::type edge_bundled;
 
   public: // should be private
     typedef typename mpl::if_<typename has_property<edge_property_type>::type,
       std::pair<bool, edge_property_type>, char>::type StoredEdge;
-#if (defined(BOOST_MSVC) && BOOST_MSVC <= 1300) || defined(BOOST_NO_STD_ALLOCATOR)
+#if defined(BOOST_NO_STD_ALLOCATOR)
     typedef std::vector<StoredEdge> Matrix;
 #else
-    // This causes internal compiler error for MSVC
     typedef typename Allocator::template rebind<StoredEdge>::other Alloc;
     typedef std::vector<StoredEdge, Alloc> Matrix;
 #endif
@@ -640,16 +628,16 @@ namespace boost {
 #ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES
     // Directly access a vertex or edge bundle
     vertex_bundled& operator[](vertex_descriptor v)
-    { return get(vertex_bundle, *this)[v]; }
+    { return get(vertex_bundle, *this, v); }
 
     const vertex_bundled& operator[](vertex_descriptor v) const
-    { return get(vertex_bundle, *this)[v]; }
+    { return get(vertex_bundle, *this, v); }
 
     edge_bundled& operator[](edge_descriptor e)
-    { return get(edge_bundle, *this)[e]; }
+    { return get(edge_bundle, *this, e); }
 
     const edge_bundled& operator[](edge_descriptor e) const
-    { return get(edge_bundle, *this)[e]; }
+    { return get(edge_bundle, *this, e); }
 
     graph_bundled& operator[](graph_bundle_t)
     { return get_property(*this); }
@@ -982,7 +970,7 @@ namespace boost {
   inline typename adjacency_matrix<D,VP,EP,GP,A>::vertex_descriptor
   add_vertex(adjacency_matrix<D,VP,EP,GP,A>& g) {
     // UNDER CONSTRUCTION
-    assert(false);
+    BOOST_ASSERT(false);
     return *vertices(g).first;
   }
 
@@ -991,7 +979,7 @@ namespace boost {
   inline typename adjacency_matrix<D,VP,EP,GP,A>::vertex_descriptor
   add_vertex(const VP2& /*vp*/, adjacency_matrix<D,VP,EP,GP,A>& g) {
     // UNDER CONSTRUCTION
-    assert(false);
+    BOOST_ASSERT(false);
     return *vertices(g).first;
   }
 
@@ -1001,7 +989,7 @@ namespace boost {
                 adjacency_matrix<D,VP,EP,GP,A>& /*g*/)
   {
     // UNDER CONSTRUCTION
-    assert(false);
+    BOOST_ASSERT(false);
   }
 
   // O(V)
@@ -1035,326 +1023,211 @@ namespace boost {
   //=========================================================================
   // Functions required by the PropertyGraph concept
 
-  // O(1)
-  template <typename D, typename VP, typename EP, typename GP, typename A,
-            typename Tag, typename Value>
-  inline void
-  set_property(adjacency_matrix<D,VP,EP,GP,A>& g, Tag, const Value& value)
-  {
-      get_property_value(g.m_property, Tag()) = value;
-  }
-
   template <typename D, typename VP, typename EP, typename GP, typename A,
-            typename Tag>
-  inline typename graph_property<adjacency_matrix<D,VP,EP,GP,A>, Tag>::type&
-  get_property(adjacency_matrix<D,VP,EP,GP,A>& g, Tag)
-  {
-      return get_property_value(g.m_property, Tag());
-  }
+            typename Prop, typename Kind>
+  struct adj_mat_pm_helper;
 
   template <typename D, typename VP, typename EP, typename GP, typename A,
-            typename Tag>
-  inline const typename graph_property<adjacency_matrix<D,VP,EP,GP,A>, Tag>::type&
-  get_property(const adjacency_matrix<D,VP,EP,GP,A>& g, Tag)
-  {
-      return get_property_value(g.m_property, Tag());
-  }
+            typename Prop>
+  struct adj_mat_pm_helper<D, VP, EP, GP, A, Prop, vertex_property_tag> {
+    typedef typename graph_traits<adjacency_matrix<D, VP, EP, GP, A> >::vertex_descriptor arg_type;
+    typedef typed_identity_property_map<arg_type> vi_map_type;
+    typedef iterator_property_map<typename std::vector<VP>::iterator, vi_map_type> all_map_type;
+    typedef iterator_property_map<typename std::vector<VP>::const_iterator, vi_map_type> all_map_const_type;
+    typedef transform_value_property_map<
+              detail::lookup_one_property_f<VP, Prop>,
+              all_map_type>
+      type;
+    typedef transform_value_property_map<
+              detail::lookup_one_property_f<const VP, Prop>,
+              all_map_const_type>
+      const_type;
+    typedef typename property_traits<type>::reference single_nonconst_type;
+    typedef typename property_traits<const_type>::reference single_const_type;
+
+    static type get_nonconst(adjacency_matrix<D, VP, EP, GP, A>& g, Prop prop) {
+      return type(prop, all_map_type(g.m_vertex_properties.begin(), vi_map_type()));
+    }
 
-  //=========================================================================
-  // Vertex Property Map
+    static const_type get_const(const adjacency_matrix<D, VP, EP, GP, A>& g, Prop prop) {
+      return const_type(prop, all_map_const_type(g.m_vertex_properties.begin(), vi_map_type()));
+    }
 
-  template <typename GraphPtr, typename Vertex, typename T, typename R,
-    typename Tag>
-  class adj_matrix_vertex_property_map
-    : public put_get_helper<R,
-         adj_matrix_vertex_property_map<GraphPtr, Vertex, T, R, Tag> >
-  {
-  public:
-    typedef T value_type;
-    typedef R reference;
-    typedef Vertex key_type;
-    typedef boost::lvalue_property_map_tag category;
-    adj_matrix_vertex_property_map() { }
-    adj_matrix_vertex_property_map(GraphPtr g) : m_g(g) { }
-    inline reference operator[](key_type v) const {
-      return get_property_value(m_g->m_vertex_properties[v], Tag());
+    static single_nonconst_type get_nonconst_one(adjacency_matrix<D, VP, EP, GP, A>& g, Prop prop, arg_type v) {
+      return lookup_one_property<VP, Prop>::lookup(g.m_vertex_properties[v], prop);
     }
-    GraphPtr m_g;
-  };
 
-  template <class Property, class Vertex>
-  struct adj_matrix_vertex_id_map
-    : public boost::put_get_helper<Vertex,
-        adj_matrix_vertex_id_map<Property, Vertex> >
-  {
-    typedef Vertex value_type;
-    typedef Vertex reference;
-    typedef Vertex key_type;
-    typedef boost::readable_property_map_tag category;
-     adj_matrix_vertex_id_map() { }
-    template <class Graph>
-    inline adj_matrix_vertex_id_map(const Graph&) { }
-    inline value_type operator[](key_type v) const { return v; }
+    static single_const_type get_const_one(const adjacency_matrix<D, VP, EP, GP, A>& g, Prop prop, arg_type v) {
+      return lookup_one_property<const VP, Prop>::lookup(g.m_vertex_properties[v], prop);
+    }
   };
 
-  namespace detail {
-
-    struct adj_matrix_any_vertex_pa {
-      template <class Tag, class Graph, class Property>
-      struct bind_ {
-        typedef typename property_value<Property,Tag>::type Value;
-        typedef typename boost::graph_traits<Graph>::vertex_descriptor Vertex;
-
-        typedef adj_matrix_vertex_property_map<Graph*, Vertex, Value, Value&,
-          Tag> type;
-        typedef adj_matrix_vertex_property_map<const Graph*, Vertex, Value,
-          const Value&, Tag> const_type;
-      };
-    };
-    struct adj_matrix_id_vertex_pa {
-      template <class Tag, class Graph, class Property>
-      struct bind_ {
-        typedef typename Graph::vertex_descriptor Vertex;
-        typedef adj_matrix_vertex_id_map<Property, Vertex> type;
-        typedef adj_matrix_vertex_id_map<Property, Vertex> const_type;
-      };
-    };
-
-    template <class Tag>
-    struct adj_matrix_choose_vertex_pa_helper {
-      typedef adj_matrix_any_vertex_pa type;
-    };
-    template <>
-    struct adj_matrix_choose_vertex_pa_helper<vertex_index_t> {
-      typedef adj_matrix_id_vertex_pa type;
-    };
-
-    template <class Tag, class Graph, class Property>
-    struct adj_matrix_choose_vertex_pa {
-      typedef typename adj_matrix_choose_vertex_pa_helper<Tag>::type Helper;
-      typedef typename Helper::template bind_<Tag,Graph,Property> Bind;
-      typedef typename Bind::type type;
-      typedef typename Bind::const_type const_type;
-    };
-
-    struct adj_matrix_vertex_property_selector {
-      template <class Graph, class Property, class Tag>
-      struct bind_ {
-        typedef adj_matrix_choose_vertex_pa<Tag,Graph,Property> Choice;
-        typedef typename Choice::type type;
-        typedef typename Choice::const_type const_type;
-      };
+  template <typename D, typename VP, typename EP, typename GP, typename A,
+            typename Tag>
+  struct adj_mat_pm_helper<D, VP, EP, GP, A, Tag, edge_property_tag> {
+    typedef typename graph_traits<adjacency_matrix<D, VP, EP, GP, A> >::edge_descriptor edge_descriptor;
+
+    template <typename IsConst>
+    struct lookup_property_from_edge {
+      Tag tag;
+      lookup_property_from_edge(Tag tag): tag(tag) {}
+      typedef typename boost::mpl::if_<IsConst, const EP, EP>::type ep_type_nonref;
+      typedef ep_type_nonref& ep_type;
+      typedef typename lookup_one_property<ep_type_nonref, Tag>::type& result_type;
+      result_type operator()(edge_descriptor e) const {
+        return lookup_one_property<ep_type_nonref, Tag>::lookup(*static_cast<ep_type_nonref*>(e.get_property()), tag);
+      }
     };
 
-  } // namespace detail
-
-  template <>
-  struct vertex_property_selector<adjacency_matrix_class_tag> {
-    typedef detail::adj_matrix_vertex_property_selector type;
-  };
+    typedef function_property_map<
+              lookup_property_from_edge<boost::mpl::false_>,
+              typename graph_traits<adjacency_matrix<D, VP, EP, GP, A> >::edge_descriptor> type;
+    typedef function_property_map<
+              lookup_property_from_edge<boost::mpl::true_>,
+              typename graph_traits<adjacency_matrix<D, VP, EP, GP, A> >::edge_descriptor> const_type;
+    typedef edge_descriptor arg_type;
+    typedef typename lookup_property_from_edge<boost::mpl::false_>::result_type single_nonconst_type;
+    typedef typename lookup_property_from_edge<boost::mpl::true_>::result_type single_const_type;
+
+    static type get_nonconst(adjacency_matrix<D, VP, EP, GP, A>& g, Tag tag) {
+      return type(tag);
+    }
 
-  //=========================================================================
-  // Edge Property Map
+    static const_type get_const(const adjacency_matrix<D, VP, EP, GP, A>& g, Tag tag) {
+      return const_type(tag);
+    }
 
+    static single_nonconst_type get_nonconst_one(adjacency_matrix<D, VP, EP, GP, A>& g, Tag tag, edge_descriptor e) {
+      return lookup_one_property<EP, Tag>::lookup(*static_cast<EP*>(e.get_property()), tag);
+    }
 
-  template <typename Directed, typename Property, typename Vertex,
-    typename T, typename R, typename Tag>
-  class adj_matrix_edge_property_map
-    : public put_get_helper<R,
-         adj_matrix_edge_property_map<Directed, Property, Vertex, T, R, Tag> >
-  {
-  public:
-    typedef T value_type;
-    typedef R reference;
-    typedef detail::matrix_edge_desc_impl<Directed, Vertex> key_type;
-    typedef boost::lvalue_property_map_tag category;
-    inline reference operator[](key_type e) const {
-      Property& p = *(Property*)e.get_property();
-      return get_property_value(p, Tag());
+    static single_const_type get_const_one(const adjacency_matrix<D, VP, EP, GP, A>& g, Tag tag, edge_descriptor e) {
+      return lookup_one_property<const EP, Tag>::lookup(*static_cast<const EP*>(e.get_property()), tag);
     }
   };
-  struct adj_matrix_edge_property_selector {
-    template <class Graph, class Property, class Tag>
-    struct bind_ {
-      typedef typename property_value<Property,Tag>::type T;
-      typedef typename Graph::vertex_descriptor Vertex;
-      typedef adj_matrix_edge_property_map<typename Graph::directed_category,
-        Property, Vertex, T, T&, Tag> type;
-      typedef adj_matrix_edge_property_map<typename Graph::directed_category,
-        Property, Vertex, T, const T&, Tag> const_type;
-    };
-  };
-  template <>
-  struct edge_property_selector<adjacency_matrix_class_tag> {
-    typedef adj_matrix_edge_property_selector type;
-  };
 
-  //=========================================================================
-  // Functions required by PropertyGraph
+  template <typename D, typename VP, typename EP, typename GP, typename A,
+            typename Tag>
+  struct property_map<adjacency_matrix<D,VP,EP,GP,A>, Tag>
+    : adj_mat_pm_helper<D, VP, EP, GP, A, Tag,
+                        typename detail::property_kind_from_graph<adjacency_matrix<D, VP, EP, GP, A>, Tag>::type> {};
 
-  namespace detail {
+  template <typename D, typename VP, typename EP, typename GP, typename A,
+            typename Tag>
+  typename property_map<adjacency_matrix<D, VP, EP, GP, A>, Tag>::type
+  get(Tag tag, adjacency_matrix<D, VP, EP, GP, A>& g) {
+    return property_map<adjacency_matrix<D, VP, EP, GP, A>, Tag>::get_nonconst(g, tag);
+  }
 
-    template <typename Property, typename D, typename VP, typename EP,
-              typename GP, typename A>
-    typename boost::property_map<adjacency_matrix<D,VP,EP,GP,A>,
-      Property>::type
-    get_dispatch(adjacency_matrix<D,VP,EP,GP,A>& g, Property,
-                 vertex_property_tag)
-    {
-      typedef adjacency_matrix<D,VP,EP,GP,A> Graph;
-      typedef typename boost::property_map<adjacency_matrix<D,VP,EP,GP,A>,
-        Property>::type PA;
-      return PA(&g);
-    }
-    template <typename Property, typename D, typename VP, typename EP,
-              typename GP, typename A>
-    typename boost::property_map<adjacency_matrix<D,VP,EP,GP,A>,
-      Property>::type
-    get_dispatch(adjacency_matrix<D,VP,EP,GP,A>&, Property,
-                 edge_property_tag)
-    {
-      typedef typename boost::property_map<adjacency_matrix<D,VP,EP,GP,A>,
-        Property>::type PA;
-      return PA();
-    }
-    template <typename Property, typename D, typename VP, typename EP,
-              typename GP, typename A>
-    typename boost::property_map<adjacency_matrix<D,VP,EP,GP,A>,
-      Property>::const_type
-    get_dispatch(const adjacency_matrix<D,VP,EP,GP,A>& g, Property,
-                 vertex_property_tag)
-    {
-      typedef adjacency_matrix<D,VP,EP,GP,A> Graph;
-      typedef typename boost::property_map<adjacency_matrix<D,VP,EP,GP,A>,
-        Property>::const_type PA;
-      return PA(&g);
-    }
-    template <typename Property, typename D, typename VP, typename EP,
-              typename GP, typename A>
-    typename boost::property_map<adjacency_matrix<D,VP,EP,GP,A>,
-      Property>::const_type
-    get_dispatch(const adjacency_matrix<D,VP,EP,GP,A>&, Property,
-                 edge_property_tag)
-    {
-      typedef typename boost::property_map<adjacency_matrix<D,VP,EP,GP,A>,
-        Property>::const_type PA;
-      return PA();
-    }
+  template <typename D, typename VP, typename EP, typename GP, typename A,
+            typename Tag>
+  typename property_map<adjacency_matrix<D, VP, EP, GP, A>, Tag>::const_type
+  get(Tag tag, const adjacency_matrix<D, VP, EP, GP, A>& g) {
+    return property_map<adjacency_matrix<D, VP, EP, GP, A>, Tag>::get_const(g, tag);
+  }
 
-  } // namespace detail
+  template <typename D, typename VP, typename EP, typename GP, typename A,
+            typename Tag>
+  typename property_map<adjacency_matrix<D, VP, EP, GP, A>, Tag>::single_nonconst_type
+  get(Tag tag, adjacency_matrix<D, VP, EP, GP, A>& g, typename property_map<adjacency_matrix<D, VP, EP, GP, A>, Tag>::arg_type a) {
+    return property_map<adjacency_matrix<D, VP, EP, GP, A>, Tag>::get_nonconst_one(g, tag, a);
+  }
 
-  template <typename Property, typename D, typename VP, typename EP,
-            typename GP, typename A>
-  inline
-  typename property_map<adjacency_matrix<D,VP,EP,GP,A>, Property>::type
-  get(Property p, adjacency_matrix<D,VP,EP,GP,A>& g)
-  {
-    typedef typename property_kind<Property>::type Kind;
-    return detail::get_dispatch(g, p, Kind());
+  template <typename D, typename VP, typename EP, typename GP, typename A,
+            typename Tag>
+  typename property_map<adjacency_matrix<D, VP, EP, GP, A>, Tag>::single_const_type
+  get(Tag tag, const adjacency_matrix<D, VP, EP, GP, A>& g, typename property_map<adjacency_matrix<D, VP, EP, GP, A>, Tag>::arg_type a) {
+    return property_map<adjacency_matrix<D, VP, EP, GP, A>, Tag>::get_const_one(g, tag, a);
+  }
+
+  template <typename D, typename VP, typename EP, typename GP, typename A,
+            typename Tag>
+  void
+  put(Tag tag,
+      adjacency_matrix<D, VP, EP, GP, A>& g,
+      typename property_map<adjacency_matrix<D, VP, EP, GP, A>, Tag>::arg_type a,
+      typename property_map<adjacency_matrix<D, VP, EP, GP, A>, Tag>::single_const_type val) {
+    property_map<adjacency_matrix<D, VP, EP, GP, A>, Tag>::get_nonconst_one(g, tag, a) = val;
   }
 
-  template <typename Property, typename D, typename VP, typename EP,
-            typename GP, typename A>
-  inline
-  typename property_map<adjacency_matrix<D,VP,EP,GP,A>, Property>::const_type
-  get(Property p, const adjacency_matrix<D,VP,EP,GP,A>& g)
+  // O(1)
+  template <typename D, typename VP, typename EP, typename GP, typename A,
+            typename Tag, typename Value>
+  inline void
+  set_property(adjacency_matrix<D,VP,EP,GP,A>& g, Tag tag, const Value& value)
   {
-    typedef typename property_kind<Property>::type Kind;
-    return detail::get_dispatch(g, p, Kind());
+      get_property_value(g.m_property, tag) = value;
   }
 
-  template <typename Property, typename D, typename VP, typename EP,
-            typename GP, typename A, typename Key>
-  inline
-  typename property_traits<
-    typename property_map<adjacency_matrix<D,VP,EP,GP,A>, Property>::const_type
-  >::value_type
-  get(Property p, const adjacency_matrix<D,VP,EP,GP,A>& g,
-      const Key& key)
+  template <typename D, typename VP, typename EP, typename GP, typename A,
+            typename Tag>
+  inline typename graph_property<adjacency_matrix<D,VP,EP,GP,A>, Tag>::type&
+  get_property(adjacency_matrix<D,VP,EP,GP,A>& g, Tag tag)
   {
-    return get(get(p, g), key);
+      return get_property_value(g.m_property, tag);
   }
 
-  template <typename Property, typename D, typename VP, typename EP,
-            typename GP, typename A, typename Key, typename Value>
-  inline void
-  put(Property p, adjacency_matrix<D,VP,EP,GP,A>& g,
-      const Key& key, const Value& value)
+  template <typename D, typename VP, typename EP, typename GP, typename A,
+            typename Tag>
+  inline const typename graph_property<adjacency_matrix<D,VP,EP,GP,A>, Tag>::type&
+  get_property(const adjacency_matrix<D,VP,EP,GP,A>& g, Tag tag)
   {
-    typedef adjacency_matrix<D,VP,EP,GP,A> Graph;
-    typedef typename boost::property_map<Graph, Property>::type Map;
-    Map pmap = get(p, g);
-    put(pmap, key, value);
+      return get_property_value(g.m_property, tag);
   }
 
   //=========================================================================
-  // Other Functions
+  // Vertex Property Map
 
   template <typename D, typename VP, typename EP, typename GP, typename A>
-  typename adjacency_matrix<D,VP,EP,GP,A>::vertex_descriptor
-  vertex(typename adjacency_matrix<D,VP,EP,GP,A>::vertices_size_type n,
-         const adjacency_matrix<D,VP,EP,GP,A>&)
-  {
-    return n;
+  struct property_map<adjacency_matrix<D, VP, EP, GP, A>, vertex_index_t> {
+    typedef typename adjacency_matrix<D, VP, EP, GP, A>::vertex_descriptor Vertex;
+    typedef typed_identity_property_map<Vertex> type;
+    typedef type const_type;
+  };
+
+  template <typename D, typename VP, typename EP, typename GP, typename A>
+  typename property_map<adjacency_matrix<D, VP, EP, GP, A>, vertex_index_t>::const_type
+  get(vertex_index_t, adjacency_matrix<D, VP, EP, GP, A>&) {
+    return typename property_map<adjacency_matrix<D, VP, EP, GP, A>, vertex_index_t>::const_type();
   }
 
-  // Support for bundled properties
-#ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES
-  template <typename Directed, typename VertexProperty, typename EdgeProperty, typename GraphProperty,
-            typename Allocator, typename T, typename Bundle>
-  inline
-  typename property_map<adjacency_matrix<Directed, VertexProperty, EdgeProperty, GraphProperty, Allocator>,
-                        T Bundle::*>::type
-  get(T Bundle::* p, adjacency_matrix<Directed, VertexProperty, EdgeProperty, GraphProperty, Allocator>& g)
-  {
-    typedef typename property_map<adjacency_matrix<Directed, VertexProperty, EdgeProperty, GraphProperty, Allocator>,
-                                  T Bundle::*>::type
-      result_type;
-    return result_type(&g, p);
+  template <typename D, typename VP, typename EP, typename GP, typename A>
+  typename adjacency_matrix<D, VP, EP, GP, A>::vertex_descriptor
+  get(vertex_index_t,
+      adjacency_matrix<D, VP, EP, GP, A>&,
+      typename adjacency_matrix<D, VP, EP, GP, A>::vertex_descriptor v) {
+    return v;
   }
 
-  template <typename Directed, typename VertexProperty, typename EdgeProperty, typename GraphProperty,
-            typename Allocator, typename T, typename Bundle>
-  inline
-  typename property_map<adjacency_matrix<Directed, VertexProperty, EdgeProperty, GraphProperty, Allocator>,
-                        T Bundle::*>::const_type
-  get(T Bundle::* p, adjacency_matrix<Directed, VertexProperty, EdgeProperty, GraphProperty, Allocator> const & g)
-  {
-    typedef typename property_map<adjacency_matrix<Directed, VertexProperty, EdgeProperty, GraphProperty, Allocator>,
-                                  T Bundle::*>::const_type
-      result_type;
-    return result_type(&g, p);
+  template <typename D, typename VP, typename EP, typename GP, typename A>
+  typename property_map<adjacency_matrix<D, VP, EP, GP, A>, vertex_index_t>::const_type
+  get(vertex_index_t, const adjacency_matrix<D, VP, EP, GP, A>&) {
+    return typename property_map<adjacency_matrix<D, VP, EP, GP, A>, vertex_index_t>::const_type();
   }
 
-  template <typename Directed, typename VertexProperty, typename EdgeProperty, typename GraphProperty,
-            typename Allocator, typename T, typename Bundle, typename Key>
-  inline T
-  get(T Bundle::* p, adjacency_matrix<Directed, VertexProperty, EdgeProperty, GraphProperty, Allocator> const & g,
-      const Key& key)
-  {
-    return get(get(p, g), key);
+  template <typename D, typename VP, typename EP, typename GP, typename A>
+  typename adjacency_matrix<D, VP, EP, GP, A>::vertex_descriptor
+  get(vertex_index_t,
+      const adjacency_matrix<D, VP, EP, GP, A>&,
+      typename adjacency_matrix<D, VP, EP, GP, A>::vertex_descriptor v) {
+    return v;
   }
 
-  template <typename Directed, typename VertexProperty, typename EdgeProperty, typename GraphProperty,
-            typename Allocator, typename T, typename Bundle, typename Key>
-  inline void
-  put(T Bundle::* p, adjacency_matrix<Directed, VertexProperty, EdgeProperty, GraphProperty, Allocator>& g,
-      const Key& key, const T& value)
+  //=========================================================================
+  // Other Functions
+
+  template <typename D, typename VP, typename EP, typename GP, typename A>
+  typename adjacency_matrix<D,VP,EP,GP,A>::vertex_descriptor
+  vertex(typename adjacency_matrix<D,VP,EP,GP,A>::vertices_size_type n,
+         const adjacency_matrix<D,VP,EP,GP,A>&)
   {
-    put(get(p, g), key, value);
+    return n;
   }
 
-#endif
-
-#define ADJMAT_PARAMS \
-    typename D, typename VP, typename EP, typename GP, typename A
-#define ADJMAT adjacency_matrix<D,VP,EP,GP,A>
-template <ADJMAT_PARAMS>
-struct graph_mutability_traits<ADJMAT> {
-    typedef mutable_edge_property_graph_tag category;
+template <typename D, typename VP, typename EP, typename GP, typename A>
+struct graph_mutability_traits<adjacency_matrix<D, VP, EP, GP, A> > {
+  typedef mutable_edge_property_graph_tag category;
 };
-#undef ADJMAT_PARAMS
-#undef ADJMAT
 
 
 } // namespace boost
diff --git a/include/boost/graph/astar_search.hpp b/include/boost/graph/astar_search.hpp
index ae60113da..435ccf03b 100644
--- a/include/boost/graph/astar_search.hpp
+++ b/include/boost/graph/astar_search.hpp
@@ -22,10 +22,13 @@
 #include <boost/graph/relax.hpp>
 #include <boost/graph/exception.hpp>
 #include <boost/graph/breadth_first_search.hpp>
+#include <boost/graph/iteration_macros.hpp>
 #include <boost/graph/detail/d_ary_heap.hpp>
+#include <boost/graph/property_maps/constant_property_map.hpp>
 #include <boost/property_map/property_map.hpp>
 #include <boost/property_map/vector_property_map.hpp>
-
+#include <boost/property_map/function_property_map.hpp>
+#include <boost/concept/assert.hpp>
 
 namespace boost {
 
@@ -34,7 +37,7 @@ namespace boost {
   struct AStarHeuristicConcept {
     void constraints()
     {
-      function_requires< CopyConstructibleConcept<Heuristic> >();
+      BOOST_CONCEPT_ASSERT(( CopyConstructibleConcept<Heuristic> ));
       h(u);
     }
     Heuristic h;
@@ -58,7 +61,7 @@ namespace boost {
   struct AStarVisitorConcept {
     void constraints()
     {
-      function_requires< CopyConstructibleConcept<Visitor> >();
+      BOOST_CONCEPT_ASSERT(( CopyConstructibleConcept<Visitor> ));
       vis.initialize_vertex(u, g);
       vis.discover_vertex(u, g);
       vis.examine_vertex(u, g);
@@ -158,8 +161,10 @@ namespace boost {
 
       template <class Edge, class Graph>
       void tree_edge(Edge e, const Graph& g) {
-        m_decreased = relax(e, g, m_weight, m_predecessor, m_distance,
-                            m_combine, m_compare);
+        using boost::get;
+        bool m_decreased =
+          relax(e, g, m_weight, m_predecessor, m_distance,
+                m_combine, m_compare);
 
         if(m_decreased) {
           m_vis.edge_relaxed(e, g);
@@ -173,8 +178,10 @@ namespace boost {
 
       template <class Edge, class Graph>
       void gray_target(Edge e, const Graph& g) {
-        m_decreased = relax(e, g, m_weight, m_predecessor, m_distance,
-                            m_combine, m_compare);
+        using boost::get;
+        bool m_decreased =
+          relax(e, g, m_weight, m_predecessor, m_distance,
+                m_combine, m_compare);
 
         if(m_decreased) {
           put(m_cost, target(e, g),
@@ -189,8 +196,10 @@ namespace boost {
 
       template <class Edge, class Graph>
       void black_target(Edge e, const Graph& g) {
-        m_decreased = relax(e, g, m_weight, m_predecessor, m_distance,
-                            m_combine, m_compare);
+        using boost::get;
+        bool m_decreased =
+          relax(e, g, m_weight, m_predecessor, m_distance,
+                m_combine, m_compare);
 
         if(m_decreased) {
           m_vis.edge_relaxed(e, g);
@@ -216,7 +225,6 @@ namespace boost {
       ColorMap m_color;
       BinaryFunction m_combine;
       BinaryPredicate m_compare;
-      bool m_decreased;
       C m_zero;
 
     };
@@ -260,6 +268,77 @@ namespace boost {
     breadth_first_visit(g, s, Q, bfs_vis, color);
   }
 
+  namespace graph_detail {
+    template <typename A, typename B>
+    struct select1st {
+      typedef std::pair<A, B> argument_type;
+      typedef A result_type;
+      A operator()(const std::pair<A, B>& p) const {return p.first;}
+    };
+  }
+
+  template <typename VertexListGraph, typename AStarHeuristic,
+            typename AStarVisitor, typename PredecessorMap,
+            typename CostMap, typename DistanceMap,
+            typename WeightMap,
+            typename CompareFunction, typename CombineFunction,
+            typename CostInf, typename CostZero>
+  inline void
+  astar_search_no_init_tree
+    (const VertexListGraph &g,
+     typename graph_traits<VertexListGraph>::vertex_descriptor s,
+     AStarHeuristic h, AStarVisitor vis,
+     PredecessorMap predecessor, CostMap cost,
+     DistanceMap distance, WeightMap weight,
+     CompareFunction compare, CombineFunction combine,
+     CostInf /*inf*/, CostZero zero)
+  {
+    typedef typename graph_traits<VertexListGraph>::vertex_descriptor
+      Vertex;
+    typedef typename property_traits<DistanceMap>::value_type Distance;
+    typedef d_ary_heap_indirect<
+              std::pair<Distance, Vertex>,
+              4,
+              null_property_map<std::pair<Distance, Vertex>, std::size_t>,
+              function_property_map<graph_detail::select1st<Distance, Vertex>, std::pair<Distance, Vertex> >,
+              CompareFunction>
+      MutableQueue;
+    MutableQueue Q(
+      make_function_property_map<std::pair<Distance, Vertex> >(graph_detail::select1st<Distance, Vertex>()),
+      null_property_map<std::pair<Distance, Vertex>, std::size_t>(),
+      compare);
+
+    vis.discover_vertex(s, g);
+    Q.push(std::make_pair(get(cost, s), s));
+    while (!Q.empty()) {
+      Vertex v;
+      Distance v_rank;
+      boost::tie(v_rank, v) = Q.top();
+      Q.pop();
+      vis.examine_vertex(v, g);
+      BGL_FORALL_OUTEDGES_T(v, e, g, VertexListGraph) {
+        Vertex w = target(e, g);
+        vis.examine_edge(e, g);
+        Distance e_weight = get(weight, e);
+        if (compare(e_weight, zero))
+          BOOST_THROW_EXCEPTION(negative_edge());
+        bool decreased =
+          relax(e, g, weight, predecessor, distance,
+                combine, compare);
+        Distance w_d = combine(get(distance, v), e_weight);
+        if (decreased) {
+          vis.edge_relaxed(e, g);
+          Distance w_rank = combine(get(distance, w), h(w));
+          put(cost, w, w_rank);
+          vis.discover_vertex(w, g);
+          Q.push(std::make_pair(w_rank, w));
+        } else {
+          vis.edge_not_relaxed(e, g);
+        }
+      }
+      vis.finish_vertex(v, g);
+    }
+  }
 
   // Non-named parameter interface
   template <typename VertexListGraph, typename AStarHeuristic,
@@ -300,6 +379,40 @@ namespace boost {
 
   }
 
+  // Non-named parameter interface
+  template <typename VertexListGraph, typename AStarHeuristic,
+            typename AStarVisitor, typename PredecessorMap,
+            typename CostMap, typename DistanceMap,
+            typename WeightMap,
+            typename CompareFunction, typename CombineFunction,
+            typename CostInf, typename CostZero>
+  inline void
+  astar_search_tree
+    (const VertexListGraph &g,
+     typename graph_traits<VertexListGraph>::vertex_descriptor s,
+     AStarHeuristic h, AStarVisitor vis,
+     PredecessorMap predecessor, CostMap cost,
+     DistanceMap distance, WeightMap weight,
+     CompareFunction compare, CombineFunction combine,
+     CostInf inf, CostZero zero)
+  {
+
+    typename graph_traits<VertexListGraph>::vertex_iterator ui, ui_end;
+    for (boost::tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui) {
+      put(distance, *ui, inf);
+      put(cost, *ui, inf);
+      put(predecessor, *ui, *ui);
+      vis.initialize_vertex(*ui, g);
+    }
+    put(distance, s, zero);
+    put(cost, s, h(s));
+
+    astar_search_no_init_tree
+      (g, s, h, vis, predecessor, cost, distance, weight,
+       compare, combine, inf, zero);
+
+  }
+
   // Named parameter interfaces
   template <typename VertexListGraph,
             typename AStarHeuristic,
@@ -325,6 +438,7 @@ namespace boost {
       typename detail::map_maker<VertexListGraph, arg_pack_type, tag::distance_map, W>::map_type
       distance_map_type;
     typedef typename boost::property_traits<distance_map_type>::value_type D;
+    const D inf = arg_pack[_distance_inf || detail::get_max<D>()];
 
     astar_search
       (g, s, h,
@@ -336,8 +450,48 @@ namespace boost {
        detail::override_const_property(arg_pack, _vertex_index_map, g, vertex_index),
        detail::make_color_map_from_arg_pack(g, arg_pack),
        arg_pack[_distance_compare | std::less<D>()],
-       arg_pack[_distance_combine | closed_plus<D>()],
-       arg_pack[_distance_inf | (std::numeric_limits<D>::max)()],
+       arg_pack[_distance_combine | closed_plus<D>(inf)],
+       inf,
+       arg_pack[_distance_zero | D()]);
+  }
+
+  // Named parameter interfaces
+  template <typename VertexListGraph,
+            typename AStarHeuristic,
+            typename P, typename T, typename R>
+  void
+  astar_search_tree
+    (const VertexListGraph &g,
+     typename graph_traits<VertexListGraph>::vertex_descriptor s,
+     AStarHeuristic h, const bgl_named_params<P, T, R>& params)
+  {
+    using namespace boost::graph::keywords;
+    typedef bgl_named_params<P, T, R> params_type;
+    BOOST_GRAPH_DECLARE_CONVERTED_PARAMETERS(params_type, params)
+
+    // Distance type is the value type of the distance map if there is one,
+    // otherwise the value type of the weight map.
+    typedef
+      typename detail::override_const_property_result<
+                 arg_pack_type, tag::weight_map, edge_weight_t, VertexListGraph>::type
+      weight_map_type;
+    typedef typename boost::property_traits<weight_map_type>::value_type W;
+    typedef
+      typename detail::map_maker<VertexListGraph, arg_pack_type, tag::distance_map, W>::map_type
+      distance_map_type;
+    typedef typename boost::property_traits<distance_map_type>::value_type D;
+    const D inf = arg_pack[_distance_inf || detail::get_max<D>()];
+
+    astar_search_tree
+      (g, s, h,
+       arg_pack[_visitor | make_astar_visitor(null_visitor())],
+       arg_pack[_predecessor_map | dummy_property_map()],
+       detail::make_property_map_from_arg_pack_gen<tag::rank_map, D>(D())(g, arg_pack),
+       detail::make_property_map_from_arg_pack_gen<tag::distance_map, W>(W())(g, arg_pack),
+       detail::override_const_property(arg_pack, _weight_map, g, edge_weight),
+       arg_pack[_distance_compare | std::less<D>()],
+       arg_pack[_distance_combine | closed_plus<D>(inf)],
+       inf,
        arg_pack[_distance_zero | D()]);
   }
 
@@ -358,6 +512,7 @@ namespace boost {
                  arg_pack_type, tag::weight_map, edge_weight_t, VertexListGraph>::type
                weight_map_type;
     typedef typename boost::property_traits<weight_map_type>::value_type D;
+    const D inf = arg_pack[_distance_inf || detail::get_max<D>()];
     astar_search_no_init
       (g, s, h,
        arg_pack[_visitor | make_astar_visitor(null_visitor())],
@@ -365,11 +520,42 @@ namespace boost {
        detail::make_property_map_from_arg_pack_gen<tag::rank_map, D>(D())(g, arg_pack),
        detail::make_property_map_from_arg_pack_gen<tag::distance_map, D>(D())(g, arg_pack),
        detail::override_const_property(arg_pack, _weight_map, g, edge_weight),
-       detail::override_const_property(arg_pack, _vertex_index_map, g, vertex_index),
        detail::make_color_map_from_arg_pack(g, arg_pack),
+       detail::override_const_property(arg_pack, _vertex_index_map, g, vertex_index),
+       arg_pack[_distance_compare | std::less<D>()],
+       arg_pack[_distance_combine | closed_plus<D>(inf)],
+       inf,
+       arg_pack[_distance_zero | D()]);
+  }
+
+  template <typename VertexListGraph,
+            typename AStarHeuristic,
+            typename P, typename T, typename R>
+  void
+  astar_search_no_init_tree
+    (const VertexListGraph &g,
+     typename graph_traits<VertexListGraph>::vertex_descriptor s,
+     AStarHeuristic h, const bgl_named_params<P, T, R>& params)
+  {
+    using namespace boost::graph::keywords;
+    typedef bgl_named_params<P, T, R> params_type;
+    BOOST_GRAPH_DECLARE_CONVERTED_PARAMETERS(params_type, params)
+    typedef
+      typename detail::override_const_property_result<
+                 arg_pack_type, tag::weight_map, edge_weight_t, VertexListGraph>::type
+               weight_map_type;
+    typedef typename boost::property_traits<weight_map_type>::value_type D;
+    const D inf = arg_pack[_distance_inf || detail::get_max<D>()];
+    astar_search_no_init_tree
+      (g, s, h,
+       arg_pack[_visitor | make_astar_visitor(null_visitor())],
+       arg_pack[_predecessor_map | dummy_property_map()],
+       detail::make_property_map_from_arg_pack_gen<tag::rank_map, D>(D())(g, arg_pack),
+       detail::make_property_map_from_arg_pack_gen<tag::distance_map, D>(D())(g, arg_pack),
+       detail::override_const_property(arg_pack, _weight_map, g, edge_weight),
        arg_pack[_distance_compare | std::less<D>()],
-       arg_pack[_distance_combine | closed_plus<D>()],
-       arg_pack[_distance_inf | (std::numeric_limits<D>::max)()],
+       arg_pack[_distance_combine | closed_plus<D>(inf)],
+       inf,
        arg_pack[_distance_zero | D()]);
   }
 
diff --git a/include/boost/graph/bandwidth.hpp b/include/boost/graph/bandwidth.hpp
index 0bfeefb99..e8e7bf2cf 100644
--- a/include/boost/graph/bandwidth.hpp
+++ b/include/boost/graph/bandwidth.hpp
@@ -21,15 +21,14 @@ namespace boost {
                 VertexIndexMap index)
   {
     BOOST_USING_STD_MAX();
-    typedef typename graph_traits<Graph>::vertices_size_type size_type;
-    size_type b = 0;
+    using std::abs;
+    typedef typename graph_traits<Graph>::vertices_size_type vertices_size_type;
+    vertices_size_type b = 0;
     typename graph_traits<Graph>::out_edge_iterator e, end;
     for (boost::tie(e, end) = out_edges(i, g); e != end; ++e) {
       int f_i = get(index, i);
       int f_j = get(index, target(*e, g));
-      using namespace std; // to call abs() unqualified
-      if(f_i > f_j)
-          b = max BOOST_PREVENT_MACRO_SUBSTITUTION (b, size_type(f_i - f_j));
+      b = max BOOST_PREVENT_MACRO_SUBSTITUTION (b, vertices_size_type(abs(f_i - f_j)));
     }
     return b;
   }
@@ -47,10 +46,15 @@ namespace boost {
   bandwidth(const Graph& g, VertexIndexMap index)
   {
     BOOST_USING_STD_MAX();
-    typename graph_traits<Graph>::vertices_size_type b = 0;
-    typename graph_traits<Graph>::vertex_iterator i, end;
-    for (boost::tie(i, end) = vertices(g); i != end; ++i)
-        b = max BOOST_PREVENT_MACRO_SUBSTITUTION (b, ith_bandwidth(*i, g, index));
+    using std::abs;
+    typedef typename graph_traits<Graph>::vertices_size_type vertices_size_type;
+    vertices_size_type b = 0;
+    typename graph_traits<Graph>::edge_iterator i, end;
+    for (boost::tie(i, end) = edges(g); i != end; ++i) {
+      int f_i = get(index, source(*i, g));
+      int f_j = get(index, target(*i, g));
+      b = max BOOST_PREVENT_MACRO_SUBSTITUTION (b, vertices_size_type(abs(f_i - f_j)));
+    }
     return b;
   }
 
diff --git a/include/boost/graph/bellman_ford_shortest_paths.hpp b/include/boost/graph/bellman_ford_shortest_paths.hpp
index 8fc02529a..7873067a1 100644
--- a/include/boost/graph/bellman_ford_shortest_paths.hpp
+++ b/include/boost/graph/bellman_ford_shortest_paths.hpp
@@ -29,13 +29,14 @@
 #include <boost/graph/relax.hpp>
 #include <boost/graph/visitors.hpp>
 #include <boost/graph/named_function_params.hpp>
+#include <boost/concept/assert.hpp>
 
 namespace boost {
 
   template <class Visitor, class Graph>
   struct BellmanFordVisitorConcept {
     void constraints() {
-      function_requires< CopyConstructibleConcept<Visitor> >();
+      BOOST_CONCEPT_ASSERT(( CopyConstructibleConcept<Visitor> ));
       vis.examine_edge(e, g);
       vis.edge_relaxed(e, g);
       vis.edge_not_relaxed(e, g);
@@ -95,14 +96,12 @@ namespace boost {
                          BinaryPredicate compare,
                          BellmanFordVisitor v)
   {
-    function_requires<EdgeListGraphConcept<EdgeListGraph> >();
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<EdgeListGraph> ));
     typedef graph_traits<EdgeListGraph> GTraits;
     typedef typename GTraits::edge_descriptor Edge;
     typedef typename GTraits::vertex_descriptor Vertex;
-    function_requires<ReadWritePropertyMapConcept<DistanceMap, Vertex> >();
-    function_requires<ReadablePropertyMapConcept<WeightMap, Edge> >();
-    typedef typename property_traits<DistanceMap>::value_type D_value;
-    typedef typename property_traits<WeightMap>::value_type W_value;
+    BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<DistanceMap, Vertex> ));
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<WeightMap, Edge> ));
 
     typename GTraits::edge_iterator i, end;
 
@@ -170,7 +169,7 @@ namespace boost {
     bool 
     bellman_dispatch2
       (VertexAndEdgeListGraph& g, 
-       detail::error_property_not_found,
+       param_not_found,
        Size N, WeightMap weight, PredecessorMap pred, DistanceMap distance,
        const bgl_named_params<P, T, R>& params)
     {
@@ -229,7 +228,7 @@ namespace boost {
     (VertexAndEdgeListGraph& g, 
      const bgl_named_params<P, T, R>& params)
   {               
-    function_requires<VertexListGraphConcept<VertexAndEdgeListGraph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<VertexAndEdgeListGraph> ));
     return detail::bellman_dispatch
       (g, num_vertices(g),
        choose_const_pmap(get_param(params, edge_weight), g, edge_weight),
diff --git a/include/boost/graph/betweenness_centrality.hpp b/include/boost/graph/betweenness_centrality.hpp
index 052f0633c..d596d5a28 100644
--- a/include/boost/graph/betweenness_centrality.hpp
+++ b/include/boost/graph/betweenness_centrality.hpp
@@ -296,7 +296,6 @@ namespace detail { namespace graph {
                                       ShortestPaths shortest_paths)
   {
     typedef typename graph_traits<Graph>::vertex_iterator vertex_iterator;
-    typedef typename graph_traits<Graph>::edge_iterator edge_iterator;
     typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor;
 
     // Initialize centrality
@@ -421,7 +420,6 @@ namespace detail { namespace graph {
                                            VertexIndexMap vertex_index)
   {
     typedef typename graph_traits<Graph>::degree_size_type degree_size_type;
-    typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor;
     typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor;
     typedef typename mpl::if_c<(is_same<CentralityMap, 
                                         dummy_property_map>::value),
@@ -457,7 +455,6 @@ namespace detail { namespace graph {
                                            VertexIndexMap vertex_index)
   {
     typedef typename graph_traits<Graph>::degree_size_type degree_size_type;
-    typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor;
     typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor;
     typedef typename mpl::if_c<(is_same<CentralityMap, 
                                         dummy_property_map>::value),
@@ -498,14 +495,14 @@ namespace detail { namespace graph {
   };
 
   template<>
-  struct brandes_betweenness_centrality_dispatch1<error_property_not_found>
+  struct brandes_betweenness_centrality_dispatch1<param_not_found>
   {
     template<typename Graph, typename CentralityMap, 
              typename EdgeCentralityMap, typename VertexIndexMap>
     static void 
     run(const Graph& g, CentralityMap centrality, 
         EdgeCentralityMap edge_centrality_map, VertexIndexMap vertex_index,
-        error_property_not_found)
+        param_not_found)
     {
       brandes_betweenness_centrality_dispatch2(g, centrality, edge_centrality_map,
                                                vertex_index);
@@ -532,7 +529,7 @@ brandes_betweenness_centrality(const Graph& g,
 {
   typedef bgl_named_params<Param,Tag,Rest> named_params;
 
-  typedef typename property_value<named_params, edge_weight_t>::type ew;
+  typedef typename get_param_type<edge_weight_t, named_params>::type ew;
   detail::graph::brandes_betweenness_centrality_dispatch1<ew>::run(
     g, 
     choose_param(get_param(params, vertex_centrality), 
diff --git a/include/boost/graph/biconnected_components.hpp b/include/boost/graph/biconnected_components.hpp
index 034596364..1669f6952 100644
--- a/include/boost/graph/biconnected_components.hpp
+++ b/include/boost/graph/biconnected_components.hpp
@@ -20,6 +20,8 @@
 #include <boost/property_map/property_map.hpp>
 #include <boost/graph/depth_first_search.hpp>
 #include <boost/graph/graph_utility.hpp>
+#include <boost/concept/assert.hpp>
+#include <boost/assert.hpp>
 
 namespace boost
 {
@@ -27,27 +29,35 @@ namespace boost
   {
     template<typename ComponentMap, typename DiscoverTimeMap,
              typename LowPointMap, typename PredecessorMap,
-             typename OutputIterator, typename Stack, 
+             typename OutputIterator, typename Stack,
+             typename ArticulationVector, typename IndexMap,
              typename DFSVisitor>
     struct biconnected_components_visitor : public dfs_visitor<>
     {
       biconnected_components_visitor
-        (ComponentMap comp, std::size_t& c, DiscoverTimeMap dtm,
+        (ComponentMap comp, std::size_t& c, 
+         std::size_t& children_of_root, DiscoverTimeMap dtm,
          std::size_t& dfs_time, LowPointMap lowpt, PredecessorMap pred,
-         OutputIterator out, Stack& S, DFSVisitor vis)
-          : comp(comp), c(c), dtm(dtm), dfs_time(dfs_time), lowpt(lowpt),
-            pred(pred), out(out), S(S), vis(vis) { }
+         OutputIterator out, Stack& S,
+         ArticulationVector& is_articulation_point, IndexMap index_map,
+         DFSVisitor vis)
+          : comp(comp), c(c), children_of_root(children_of_root),
+            dtm(dtm), dfs_time(dfs_time), lowpt(lowpt),
+            pred(pred), out(out), S(S),
+            is_articulation_point(is_articulation_point),
+            index_map(index_map), vis(vis) { }
 
       template <typename Vertex, typename Graph>
       void initialize_vertex(const Vertex& u, Graph& g)
       {
+        put(pred, u, u);
         vis.initialize_vertex(u, g);
       }
 
       template <typename Vertex, typename Graph>
       void start_vertex(const Vertex& u, Graph& g)
       {
-        put(pred, u, u);
+        children_of_root = 0;
         vis.start_vertex(u, g);
       }
 
@@ -68,8 +78,14 @@ namespace boost
       template <typename Edge, typename Graph>
       void tree_edge(const Edge& e, Graph& g)
       {
+        typename boost::graph_traits<Graph>::vertex_descriptor src = source(e, g);
+        typename boost::graph_traits<Graph>::vertex_descriptor tgt = target(e, g);
+
         S.push(e);
-        put(pred, target(e, g), source(e, g));
+        put(pred, tgt, src);
+        if ( get(pred, src) == src ) {
+          ++children_of_root;
+        }
         vis.tree_edge(e, g);
       }
 
@@ -78,11 +94,13 @@ namespace boost
       {
         BOOST_USING_STD_MIN();
 
-        if ( target(e, g) != get(pred, source(e, g)) ) {
+        typename boost::graph_traits<Graph>::vertex_descriptor src = source(e, g);
+        typename boost::graph_traits<Graph>::vertex_descriptor tgt = target(e, g);
+        if ( tgt != get(pred, src) ) {
           S.push(e);
-          put(lowpt, source(e, g),
-              min BOOST_PREVENT_MACRO_SUBSTITUTION(get(lowpt, source(e, g)),
-                                                   get(dtm, target(e, g))));
+          put(lowpt, src,
+              min BOOST_PREVENT_MACRO_SUBSTITUTION(get(lowpt, src),
+                                                   get(dtm, tgt)));
         }
         vis.back_edge(e, g);
       }
@@ -98,55 +116,42 @@ namespace boost
       {
         BOOST_USING_STD_MIN();
         Vertex parent = get(pred, u);
-        const std::size_t dtm_of_dubious_parent = get(dtm, parent);
-        bool is_art_point = false;
-        if ( dtm_of_dubious_parent > get(dtm, u) ) {
-          parent = get(pred, parent);
-          is_art_point = true;
-          put(pred, get(pred, u), u);
-          put(pred, u, parent);
-        }
-
-        if ( parent == u ) { // at top
-          if ( get(dtm, u) + 1 == dtm_of_dubious_parent )
-            is_art_point = false;
+        if (parent == u) { // Root of tree is special
+          is_articulation_point[get(index_map, u)] = (children_of_root > 1);
         } else {
           put(lowpt, parent,
               min BOOST_PREVENT_MACRO_SUBSTITUTION(get(lowpt, parent),
-                                                   get(lowpt, u)));
-
-          if (get(lowpt, u) >= get(dtm, parent)) {
-            if ( get(dtm, parent) > get(dtm, get(pred, parent)) ) {
-              put(pred, u, get(pred, parent));
-              put(pred, parent, u);
-            }
-
+                                                 get(lowpt, u)));
+          if ( get(lowpt, u) >= get(dtm, parent) ) {
+            is_articulation_point[get(index_map, parent)] = true;
             while ( get(dtm, source(S.top(), g)) >= get(dtm, u) ) {
               put(comp, S.top(), c);
               S.pop();
             }
+            BOOST_ASSERT (source(S.top(), g) == parent);
+            BOOST_ASSERT (target(S.top(), g) == u);
             put(comp, S.top(), c);
-              S.pop();
+            S.pop();
             ++c;
-            if ( S.empty() ) {
-              put(pred, u, parent);
-              put(pred, parent, u);
-            }
           }
         }
-        if ( is_art_point )
+        if ( is_articulation_point[get(index_map, u)] ) {
           *out++ = u;
+        }
         vis.finish_vertex(u, g);
       }
 
       ComponentMap comp;
       std::size_t& c;
+      std::size_t& children_of_root;
       DiscoverTimeMap dtm;
       std::size_t& dfs_time;
       LowPointMap lowpt;
       PredecessorMap pred;
       OutputIterator out;
       Stack& S;
+      ArticulationVector& is_articulation_point;
+      IndexMap index_map;
       DFSVisitor vis;
     };
 
@@ -160,24 +165,26 @@ namespace boost
   {
     typedef typename graph_traits<Graph>::vertex_descriptor vertex_t;
     typedef typename graph_traits<Graph>::edge_descriptor edge_t;
-    function_requires<VertexListGraphConcept<Graph> >();
-    function_requires<IncidenceGraphConcept<Graph> >();
-    function_requires<WritablePropertyMapConcept<ComponentMap, edge_t> >();
-    function_requires<ReadWritePropertyMapConcept<DiscoverTimeMap,
-                                                  vertex_t> >();
-    function_requires<ReadWritePropertyMapConcept<LowPointMap, vertex_t > >();
-    function_requires<ReadWritePropertyMapConcept<PredecessorMap,
-                                                  vertex_t> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( WritablePropertyMapConcept<ComponentMap, edge_t> ));
+    BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<DiscoverTimeMap,
+                                                  vertex_t> ));
+    BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<LowPointMap, vertex_t > ));
+    BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<PredecessorMap,
+                                                  vertex_t> ));
 
     std::size_t num_components = 0;
+    std::size_t children_of_root;
     std::size_t dfs_time = 0;
-      std::stack<edge_t> S;
+    std::stack<edge_t> S;
+        std::vector<char> is_articulation_point(num_vertices(g));
 
-      biconnected_components_visitor<ComponentMap, DiscoverTimeMap,
-          LowPointMap, PredecessorMap, OutputIterator, std::stack<edge_t>, 
-          DFSVisitor>
-      vis(comp, num_components, dtm, dfs_time, lowpt, pred, out, 
-          S, dfs_vis);
+    biconnected_components_visitor<ComponentMap, DiscoverTimeMap,
+        LowPointMap, PredecessorMap, OutputIterator, std::stack<edge_t>, 
+        std::vector<char>, VertexIndexMap, DFSVisitor>
+    vis(comp, num_components, children_of_root, dtm, dfs_time,
+        lowpt, pred, out, S, is_articulation_point, index_map, dfs_vis);
 
     depth_first_search(g, visitor(vis).vertex_index_map(index_map));
 
@@ -203,7 +210,7 @@ namespace boost
     };
     
     template <>
-    struct bicomp_dispatch3<error_property_not_found>
+    struct bicomp_dispatch3<param_not_found>
     {
       template<typename Graph, typename ComponentMap, typename OutputIterator,
                 typename VertexIndexMap, typename DiscoverTimeMap, 
@@ -212,7 +219,7 @@ namespace boost
           ComponentMap comp, OutputIterator out, VertexIndexMap index_map, 
           DiscoverTimeMap dtm, LowPointMap lowpt, 
           const bgl_named_params<P, T, R>& params, 
-          error_property_not_found)
+          param_not_found)
   {
     typedef typename graph_traits<Graph>::vertex_descriptor vertex_t;
     std::vector<vertex_t> pred(num_vertices(g));
@@ -237,8 +244,7 @@ namespace boost
           DiscoverTimeMap dtm, const bgl_named_params<P, T, R>& params, 
           LowPointMap lowpt)
       {
-        typedef typename property_value< bgl_named_params<P,T,R>,
-            vertex_predecessor_t>::type dispatch_type;
+        typedef typename get_param_type< vertex_predecessor_t, bgl_named_params<P,T,R> >::type dispatch_type;
 
         return bicomp_dispatch3<dispatch_type>::apply
             (g, comp, out, index_map, dtm, lowpt, params, 
@@ -248,7 +254,7 @@ namespace boost
 
 
     template <>
-    struct bicomp_dispatch2<error_property_not_found>
+    struct bicomp_dispatch2<param_not_found>
     {
       template<typename Graph, typename ComponentMap, typename OutputIterator,
                 typename VertexIndexMap, typename DiscoverTimeMap, 
@@ -256,15 +262,14 @@ namespace boost
       static std::pair<std::size_t, OutputIterator> apply (const Graph& g, 
           ComponentMap comp, OutputIterator out, VertexIndexMap index_map, 
           DiscoverTimeMap dtm, const bgl_named_params<P, T, R>& params, 
-          error_property_not_found)
+          param_not_found)
   {
     typedef typename graph_traits<Graph>::vertices_size_type
       vertices_size_type;
     std::vector<vertices_size_type> lowpt(num_vertices(g));
         vertices_size_type vst(0);
 
-        typedef typename property_value< bgl_named_params<P,T,R>,
-            vertex_predecessor_t>::type dispatch_type;
+        typedef typename get_param_type< vertex_predecessor_t, bgl_named_params<P,T,R> >::type dispatch_type;
   
         return bicomp_dispatch3<dispatch_type>::apply
             (g, comp, out, index_map, dtm,
@@ -282,8 +287,7 @@ namespace boost
           ComponentMap comp, OutputIterator out, VertexIndexMap index_map, 
           const bgl_named_params<P, T, R>& params, DiscoverTimeMap dtm)
       {
-        typedef typename property_value< bgl_named_params<P,T,R>,
-            vertex_lowpoint_t>::type dispatch_type;
+        typedef typename get_param_type< vertex_lowpoint_t, bgl_named_params<P,T,R> >::type dispatch_type;
 
         return bicomp_dispatch2<dispatch_type>::apply
             (g, comp, out, index_map, dtm, params, 
@@ -292,21 +296,20 @@ namespace boost
     };
 
     template <>
-    struct bicomp_dispatch1<error_property_not_found>
+    struct bicomp_dispatch1<param_not_found>
     {
       template<typename Graph, typename ComponentMap, typename OutputIterator,
                 typename VertexIndexMap, class P, class T, class R>
       static std::pair<std::size_t, OutputIterator> apply(const Graph& g, 
           ComponentMap comp, OutputIterator out, VertexIndexMap index_map, 
-          const bgl_named_params<P, T, R>& params, error_property_not_found)
+          const bgl_named_params<P, T, R>& params, param_not_found)
       {
         typedef typename graph_traits<Graph>::vertices_size_type
             vertices_size_type;
         std::vector<vertices_size_type> discover_time(num_vertices(g));
     vertices_size_type vst(0);
 
-        typedef typename property_value< bgl_named_params<P,T,R>,
-            vertex_lowpoint_t>::type dispatch_type;
+        typedef typename get_param_type< vertex_lowpoint_t, bgl_named_params<P,T,R> >::type dispatch_type;
 
         return bicomp_dispatch2<dispatch_type>::apply
             (g, comp, out, index_map, 
@@ -323,14 +326,14 @@ namespace boost
   biconnected_components(const Graph& g, ComponentMap comp, 
       OutputIterator out, DiscoverTimeMap dtm, LowPointMap lowpt)
   {
-    typedef detail::error_property_not_found dispatch_type;
+    typedef param_not_found dispatch_type;
 
     return detail::bicomp_dispatch3<dispatch_type>::apply
             (g, comp, out, 
              get(vertex_index, g), 
              dtm, lowpt, 
              bgl_named_params<int, buffer_param_t>(0), 
-             detail::error_property_not_found());
+             param_not_found());
   }
 
   template <typename Graph, typename ComponentMap, typename OutputIterator,
@@ -339,8 +342,7 @@ namespace boost
   biconnected_components(const Graph& g, ComponentMap comp, OutputIterator out, 
       const bgl_named_params<P, T, R>& params)
   {
-    typedef typename property_value< bgl_named_params<P,T,R>,
-        vertex_discover_time_t>::type dispatch_type;
+    typedef typename get_param_type< vertex_discover_time_t, bgl_named_params<P,T,R> >::type dispatch_type;
 
     return detail::bicomp_dispatch1<dispatch_type>::apply(g, comp, out, 
         choose_const_pmap(get_param(params, vertex_index), g, vertex_index), 
diff --git a/include/boost/graph/bipartite.hpp b/include/boost/graph/bipartite.hpp
index f902fd3e7..74316fd53 100644
--- a/include/boost/graph/bipartite.hpp
+++ b/include/boost/graph/bipartite.hpp
@@ -198,7 +198,6 @@ namespace boost {
     /// General types and variables
     typedef typename property_traits <PartitionMap>::value_type partition_color_t;
     typedef typename graph_traits <Graph>::vertex_descriptor vertex_descriptor_t;
-    typedef typename graph_traits <Graph>::vertex_iterator vertex_iterator_t;
 
     /// Declare dfs visitor
     //    detail::empty_recorder recorder;
@@ -212,8 +211,6 @@ namespace boost {
       depth_first_search (graph, vertex_index_map (index_map).visitor (make_dfs_visitor (std::make_pair (
           detail::colorize_bipartition (partition_map), std::make_pair (detail::check_bipartition (partition_map),
               put_property (partition_map, color_traits <partition_color_t>::white (), on_start_vertex ()))))));
-
-      //      depth_first_search (graph, vertex_index_map (index_map).visitor (dfs_visitor));
     }
     catch (detail::bipartite_visitor_error <vertex_descriptor_t> error)
     {
@@ -284,11 +281,9 @@ namespace boost {
     typedef std::vector <vertex_descriptor_t> predecessors_t;
     typedef iterator_property_map <typename predecessors_t::iterator, IndexMap, vertex_descriptor_t,
         vertex_descriptor_t&> predecessor_map_t;
-    typedef predecessor_recorder <predecessor_map_t, IndexMap> predecessor_recorder_t;
 
     predecessors_t predecessors (num_vertices (graph), graph_traits <Graph>::null_vertex ());
     predecessor_map_t predecessor_map (predecessors.begin (), index_map);
-    predecessor_recorder_t predecessor_recorder (predecessor_map);
 
     /// Initialize predecessor map
     for (boost::tie (vertex_iter, vertex_end) = vertices (graph); vertex_iter != vertex_end; ++vertex_iter)
diff --git a/include/boost/graph/boykov_kolmogorov_max_flow.hpp b/include/boost/graph/boykov_kolmogorov_max_flow.hpp
index 8559bd771..1edc1323e 100644
--- a/include/boost/graph/boykov_kolmogorov_max_flow.hpp
+++ b/include/boost/graph/boykov_kolmogorov_max_flow.hpp
@@ -33,7 +33,7 @@
 #define BOOST_BOYKOV_KOLMOGOROV_MAX_FLOW_HPP
 
 #include <boost/config.hpp>
-#include <cassert>
+#include <boost/assert.hpp>
 #include <vector>
 #include <list>
 #include <utility>
@@ -47,6 +47,7 @@
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/named_function_params.hpp>
 #include <boost/graph/lookup_edge.hpp>
+#include <boost/concept/assert.hpp>
 
 // The algorithm impelemented here is described in:
 //
@@ -125,14 +126,14 @@ class bk_max_flow {
         // the residual capacity equal to the capacity
         edge_iterator ei, e_end;
         for(boost::tie(ei, e_end) = edges(m_g); ei != e_end; ++ei) {
-          m_res_cap_map[*ei] = m_cap_map[*ei];
-          assert(m_rev_edge_map[m_rev_edge_map[*ei]] == *ei); //check if the reverse edge map is build up properly
+          put(m_res_cap_map, *ei, get(m_cap_map, *ei));
+          BOOST_ASSERT(get(m_rev_edge_map, get(m_rev_edge_map, *ei)) == *ei); //check if the reverse edge map is build up properly
         }
         //init the search trees with the two terminals
         set_tree(m_source, tColorTraits::black());
         set_tree(m_sink, tColorTraits::white());
-        m_time_map[m_source] = 1;
-        m_time_map[m_sink] = 1;
+        put(m_time_map, m_source, 1);
+        put(m_time_map, m_sink, 1);
       }
 
       tEdgeVal max_flow(){
@@ -168,8 +169,8 @@ class bk_max_flow {
           edge_descriptor from_source = *ei;
           vertex_descriptor current_node = target(from_source, m_g);
           if(current_node == m_sink){
-            tEdgeVal cap = m_res_cap_map[from_source];
-            m_res_cap_map[from_source] = 0;
+            tEdgeVal cap = get(m_res_cap_map, from_source);
+            put(m_res_cap_map, from_source, 0);
             m_flow += cap;
             continue;
           }
@@ -177,52 +178,52 @@ class bk_max_flow {
           bool is_there;
           boost::tie(to_sink, is_there) = lookup_edge(current_node, m_sink, m_g);
           if(is_there){
-            tEdgeVal cap_from_source = m_res_cap_map[from_source];
-            tEdgeVal cap_to_sink = m_res_cap_map[to_sink];
+            tEdgeVal cap_from_source = get(m_res_cap_map, from_source);
+            tEdgeVal cap_to_sink = get(m_res_cap_map, to_sink);
             if(cap_from_source > cap_to_sink){
               set_tree(current_node, tColorTraits::black());
               add_active_node(current_node);
               set_edge_to_parent(current_node, from_source);
-              m_dist_map[current_node] = 1;
-              m_time_map[current_node] = 1;
+              put(m_dist_map, current_node, 1);
+              put(m_time_map, current_node, 1);
               // add stuff to flow and update residuals. we dont need to
               // update reverse_edges, as incoming/outgoing edges to/from
               // source/sink don't count for max-flow
-              m_res_cap_map[from_source] -= cap_to_sink;
-              m_res_cap_map[to_sink] = 0;
+              put(m_res_cap_map, from_source, get(m_res_cap_map, from_source) - cap_to_sink);
+              put(m_res_cap_map, to_sink, 0);
               m_flow += cap_to_sink;
             } else if(cap_to_sink > 0){
               set_tree(current_node, tColorTraits::white());
               add_active_node(current_node);
               set_edge_to_parent(current_node, to_sink);
-              m_dist_map[current_node] = 1;
-              m_time_map[current_node] = 1;
+              put(m_dist_map, current_node, 1);
+              put(m_time_map, current_node, 1);
               // add stuff to flow and update residuals. we dont need to update
               // reverse_edges, as incoming/outgoing edges to/from source/sink
               // don't count for max-flow
-              m_res_cap_map[to_sink] -= cap_from_source;
-              m_res_cap_map[from_source] = 0;
+              put(m_res_cap_map, to_sink, get(m_res_cap_map, to_sink) - cap_from_source);
+              put(m_res_cap_map, from_source, 0);
               m_flow += cap_from_source;
             }
-          } else if(m_res_cap_map[from_source]){
+          } else if(get(m_res_cap_map, from_source)){
             // there is no sink connect, so we can't augment this path, but to
             // avoid adding m_source to the active nodes, we just activate this
             // node and set the approciate things
             set_tree(current_node, tColorTraits::black());
             set_edge_to_parent(current_node, from_source);
-            m_dist_map[current_node] = 1;
-            m_time_map[current_node] = 1;
+            put(m_dist_map, current_node, 1);
+            put(m_time_map, current_node, 1);
             add_active_node(current_node);
           }
         }
         for(boost::tie(ei, e_end) = out_edges(m_sink, m_g); ei != e_end; ++ei){
-          edge_descriptor to_sink = m_rev_edge_map[*ei];
+          edge_descriptor to_sink = get(m_rev_edge_map, *ei);
           vertex_descriptor current_node = source(to_sink, m_g);
-          if(m_res_cap_map[to_sink]){
+          if(get(m_res_cap_map, to_sink)){
             set_tree(current_node, tColorTraits::white());
             set_edge_to_parent(current_node, to_sink);
-            m_dist_map[current_node] = 1;
-            m_time_map[current_node] = 1;
+            put(m_dist_map, current_node, 1);
+            put(m_time_map, current_node, 1);
             add_active_node(current_node);
           }
         }
@@ -235,13 +236,13 @@ class bk_max_flow {
        * target(returnVal, m_g) is the beginning of the path found in the sink-tree
        */
       std::pair<edge_descriptor, bool> grow(){
-        assert(m_orphans.empty());
+        BOOST_ASSERT(m_orphans.empty());
         vertex_descriptor current_node;
         while((current_node = get_next_active_node()) != graph_traits<Graph>::null_vertex()){ //if there is one
-          assert(get_tree(current_node) != tColorTraits::gray() &&
-                (has_parent(current_node) ||
-                  current_node == m_source ||
-                  current_node == m_sink));
+          BOOST_ASSERT(get_tree(current_node) != tColorTraits::gray() &&
+                       (has_parent(current_node) ||
+                         current_node == m_source ||
+                         current_node == m_sink));
 
           if(get_tree(current_node) == tColorTraits::black()){
             //source tree growing
@@ -252,24 +253,24 @@ class bk_max_flow {
             }
             for(; m_last_grow_edge_it != m_last_grow_edge_end; ++m_last_grow_edge_it) {
               edge_descriptor out_edge = *m_last_grow_edge_it;
-              if(m_res_cap_map[out_edge] > 0){ //check if we have capacity left on this edge
+              if(get(m_res_cap_map, out_edge) > 0){ //check if we have capacity left on this edge
                 vertex_descriptor other_node = target(out_edge, m_g);
                 if(get_tree(other_node) == tColorTraits::gray()){ //it's a free node
                   set_tree(other_node, tColorTraits::black()); //aquire other node to our search tree
                   set_edge_to_parent(other_node, out_edge);   //set us as parent
-                  m_dist_map[other_node] = m_dist_map[current_node] + 1;  //and update the distance-heuristic
-                  m_time_map[other_node] = m_time_map[current_node];
+                  put(m_dist_map, other_node, get(m_dist_map, current_node) + 1);  //and update the distance-heuristic
+                  put(m_time_map, other_node, get(m_time_map, current_node));
                   add_active_node(other_node);
                 } else if(get_tree(other_node) == tColorTraits::black()) {
                   // we do this to get shorter paths. check if we are nearer to
                   // the source as its parent is
                   if(is_closer_to_terminal(current_node, other_node)){
                     set_edge_to_parent(other_node, out_edge);
-                    m_dist_map[other_node] = m_dist_map[current_node] + 1;
-                    m_time_map[other_node] = m_time_map[current_node];
+                    put(m_dist_map, other_node, get(m_dist_map, current_node) + 1);
+                    put(m_time_map, other_node, get(m_time_map, current_node));
                   }
                 } else{
-                  assert(get_tree(other_node)==tColorTraits::white());
+                  BOOST_ASSERT(get_tree(other_node)==tColorTraits::white());
                   //kewl, found a path from one to the other search tree, return
                   // the connecting edge in src->sink dir
                   return std::make_pair(out_edge, true);
@@ -278,31 +279,31 @@ class bk_max_flow {
             } //for all out-edges
           } //source-tree-growing
           else{
-            assert(get_tree(current_node) == tColorTraits::white());
+            BOOST_ASSERT(get_tree(current_node) == tColorTraits::white());
             out_edge_iterator ei, e_end;
             if(current_node != m_last_grow_vertex){
               m_last_grow_vertex = current_node;
               boost::tie(m_last_grow_edge_it, m_last_grow_edge_end) = out_edges(current_node, m_g);
             }
             for(; m_last_grow_edge_it != m_last_grow_edge_end; ++m_last_grow_edge_it){
-              edge_descriptor in_edge = m_rev_edge_map[*m_last_grow_edge_it];
-              if(m_res_cap_map[in_edge] > 0){ //check if there is capacity left
+              edge_descriptor in_edge = get(m_rev_edge_map, *m_last_grow_edge_it);
+              if(get(m_res_cap_map, in_edge) > 0){ //check if there is capacity left
                 vertex_descriptor other_node = source(in_edge, m_g);
                 if(get_tree(other_node) == tColorTraits::gray()){ //it's a free node
                   set_tree(other_node, tColorTraits::white());      //aquire that node to our search tree
                   set_edge_to_parent(other_node, in_edge);          //set us as parent
                   add_active_node(other_node);                      //activate that node
-                  m_dist_map[other_node] = m_dist_map[current_node] + 1; //set its distance
-                  m_time_map[other_node] = m_time_map[current_node];     //and time
+                  put(m_dist_map, other_node, get(m_dist_map, current_node) + 1); //set its distance
+                  put(m_time_map, other_node, get(m_time_map, current_node));//and time
                 } else if(get_tree(other_node) == tColorTraits::white()){
                   if(is_closer_to_terminal(current_node, other_node)){
                     //we are closer to the sink than its parent is, so we "adopt" him
                     set_edge_to_parent(other_node, in_edge);
-                    m_dist_map[other_node] = m_dist_map[current_node] + 1;
-                    m_time_map[other_node] = m_time_map[current_node];
+                    put(m_dist_map, other_node, get(m_dist_map, current_node) + 1);
+                    put(m_time_map, other_node, get(m_time_map, current_node));
                   }
                 } else{
-                  assert(get_tree(other_node)==tColorTraits::black());
+                  BOOST_ASSERT(get_tree(other_node)==tColorTraits::black());
                   //kewl, found a path from one to the other search tree,
                   // return the connecting edge in src->sink dir
                   return std::make_pair(in_edge, true);
@@ -332,26 +333,26 @@ class bk_max_flow {
        * and so we process the nearest verts to the terminals first
        */
       void augment(edge_descriptor e) {
-        assert(get_tree(target(e, m_g)) == tColorTraits::white());
-        assert(get_tree(source(e, m_g)) == tColorTraits::black());
-        assert(m_orphans.empty());
+        BOOST_ASSERT(get_tree(target(e, m_g)) == tColorTraits::white());
+        BOOST_ASSERT(get_tree(source(e, m_g)) == tColorTraits::black());
+        BOOST_ASSERT(m_orphans.empty());
 
         const tEdgeVal bottleneck = find_bottleneck(e);
         //now we push the found flow through the path
         //for each edge we saturate we have to look for the verts that belong to that edge, one of them becomes an orphans
         //now process the connecting edge
-        m_res_cap_map[e] -= bottleneck;
-        assert(m_res_cap_map[e] >= 0);
-        m_res_cap_map[m_rev_edge_map[e]] += bottleneck;
+        put(m_res_cap_map, e, get(m_res_cap_map, e) - bottleneck);
+        BOOST_ASSERT(get(m_res_cap_map, e) >= 0);
+        put(m_res_cap_map, get(m_rev_edge_map, e), get(m_res_cap_map, get(m_rev_edge_map, e)) + bottleneck);
 
         //now we follow the path back to the source
         vertex_descriptor current_node = source(e, m_g);
         while(current_node != m_source){
           edge_descriptor pred = get_edge_to_parent(current_node);
-          m_res_cap_map[pred] -= bottleneck;
-          assert(m_res_cap_map[pred] >= 0);
-          m_res_cap_map[m_rev_edge_map[pred]] += bottleneck;
-          if(m_res_cap_map[pred] == 0){
+          put(m_res_cap_map, pred, get(m_res_cap_map, pred) - bottleneck);
+          BOOST_ASSERT(get(m_res_cap_map, pred) >= 0);
+          put(m_res_cap_map, get(m_rev_edge_map, pred), get(m_res_cap_map, get(m_rev_edge_map, pred)) + bottleneck);
+          if(get(m_res_cap_map, pred) == 0){
             set_no_parent(current_node);
             m_orphans.push_front(current_node);
           }
@@ -361,10 +362,10 @@ class bk_max_flow {
         current_node = target(e, m_g);
         while(current_node != m_sink){
           edge_descriptor pred = get_edge_to_parent(current_node);
-          m_res_cap_map[pred] -= bottleneck;
-          assert(m_res_cap_map[pred] >= 0);
-          m_res_cap_map[m_rev_edge_map[pred]] += bottleneck;
-          if(m_res_cap_map[pred] == 0){
+          put(m_res_cap_map, pred, get(m_res_cap_map, pred) - bottleneck);
+          BOOST_ASSERT(get(m_res_cap_map, pred) >= 0);
+          put(m_res_cap_map, get(m_rev_edge_map, pred), get(m_res_cap_map, get(m_rev_edge_map, pred)) + bottleneck);
+          if(get(m_res_cap_map, pred) == 0){
             set_no_parent(current_node);
             m_orphans.push_front(current_node);
           }
@@ -380,19 +381,19 @@ class bk_max_flow {
        */
       inline tEdgeVal find_bottleneck(edge_descriptor e){
         BOOST_USING_STD_MIN();
-        tEdgeVal minimum_cap = m_res_cap_map[e];
+        tEdgeVal minimum_cap = get(m_res_cap_map, e);
         vertex_descriptor current_node = source(e, m_g);
         //first go back in the source tree
         while(current_node != m_source){
           edge_descriptor pred = get_edge_to_parent(current_node);
-          minimum_cap = min BOOST_PREVENT_MACRO_SUBSTITUTION(minimum_cap, m_res_cap_map[pred]);
+          minimum_cap = min BOOST_PREVENT_MACRO_SUBSTITUTION(minimum_cap, get(m_res_cap_map, pred));
           current_node = source(pred, m_g);
         }
         //then go forward in the sink-tree
         current_node = target(e, m_g);
         while(current_node != m_sink){
           edge_descriptor pred = get_edge_to_parent(current_node);
-          minimum_cap = min BOOST_PREVENT_MACRO_SUBSTITUTION(minimum_cap, m_res_cap_map[pred]);
+          minimum_cap = min BOOST_PREVENT_MACRO_SUBSTITUTION(minimum_cap, get(m_res_cap_map, pred));
           current_node = target(pred, m_g);
         }
         return minimum_cap;
@@ -420,13 +421,13 @@ class bk_max_flow {
             edge_descriptor new_parent_edge;
             out_edge_iterator ei, e_end;
             for(boost::tie(ei, e_end) = out_edges(current_node, m_g); ei != e_end; ++ei){
-              const edge_descriptor in_edge = m_rev_edge_map[*ei];
-              assert(target(in_edge, m_g) == current_node); //we should be the target of this edge
-              if(m_res_cap_map[in_edge] > 0){
+              const edge_descriptor in_edge = get(m_rev_edge_map, *ei);
+              BOOST_ASSERT(target(in_edge, m_g) == current_node); //we should be the target of this edge
+              if(get(m_res_cap_map, in_edge) > 0){
                 vertex_descriptor other_node = source(in_edge, m_g);
                 if(get_tree(other_node) == tColorTraits::black() && has_source_connect(other_node)){
-                  if(m_dist_map[other_node] < min_distance){
-                    min_distance = m_dist_map[other_node];
+                  if(get(m_dist_map, other_node) < min_distance){
+                    min_distance = get(m_dist_map, other_node);
                     new_parent_edge = in_edge;
                   }
                 }
@@ -434,18 +435,18 @@ class bk_max_flow {
             }
             if(min_distance != (std::numeric_limits<tDistanceVal>::max)()){
               set_edge_to_parent(current_node, new_parent_edge);
-              m_dist_map[current_node] = min_distance + 1;
-              m_time_map[current_node] = m_time;
+              put(m_dist_map, current_node, min_distance + 1);
+              put(m_time_map, current_node, m_time);
             } else{
-              m_time_map[current_node] = 0;
+              put(m_time_map, current_node, 0);
               for(boost::tie(ei, e_end) = out_edges(current_node, m_g); ei != e_end; ++ei){
-                edge_descriptor in_edge = m_rev_edge_map[*ei];
+                edge_descriptor in_edge = get(m_rev_edge_map, *ei);
                 vertex_descriptor other_node = source(in_edge, m_g);
-                if(get_tree(other_node) == tColorTraits::black() && has_parent(other_node)){
-                  if(m_res_cap_map[in_edge] > 0){
+                if(get_tree(other_node) == tColorTraits::black() && other_node != m_source){
+                  if(get(m_res_cap_map, in_edge) > 0){
                     add_active_node(other_node);
                   }
-                  if(source(get_edge_to_parent(other_node), m_g) == current_node){
+                  if(has_parent(other_node) && source(get_edge_to_parent(other_node), m_g) == current_node){
                     //we are the parent of that node
                     //it has to find a new parent, too
                     set_no_parent(other_node);
@@ -458,35 +459,35 @@ class bk_max_flow {
           } //source-tree-adoption
           else{
             //now we should be in the sink-tree, check that...
-            assert(get_tree(current_node) == tColorTraits::white());
+            BOOST_ASSERT(get_tree(current_node) == tColorTraits::white());
             out_edge_iterator ei, e_end;
             edge_descriptor new_parent_edge;
             tDistanceVal min_distance = (std::numeric_limits<tDistanceVal>::max)();
             for(boost::tie(ei, e_end) = out_edges(current_node, m_g); ei != e_end; ++ei){
               const edge_descriptor out_edge = *ei;
-              if(m_res_cap_map[out_edge] > 0){
+              if(get(m_res_cap_map, out_edge) > 0){
                 const vertex_descriptor other_node = target(out_edge, m_g);
                 if(get_tree(other_node) == tColorTraits::white() && has_sink_connect(other_node))
-                  if(m_dist_map[other_node] < min_distance){
-                    min_distance = m_dist_map[other_node];
+                  if(get(m_dist_map, other_node) < min_distance){
+                    min_distance = get(m_dist_map, other_node);
                     new_parent_edge = out_edge;
                   }
               }
             }
             if(min_distance != (std::numeric_limits<tDistanceVal>::max)()){
               set_edge_to_parent(current_node, new_parent_edge);
-              m_dist_map[current_node] = min_distance + 1;
-              m_time_map[current_node] = m_time;
+              put(m_dist_map, current_node, min_distance + 1);
+              put(m_time_map, current_node, m_time);
             } else{
-              m_time_map[current_node] = 0;
+              put(m_time_map, current_node, 0);
               for(boost::tie(ei, e_end) = out_edges(current_node, m_g); ei != e_end; ++ei){
                 const edge_descriptor out_edge = *ei;
                 const vertex_descriptor other_node = target(out_edge, m_g);
-                if(get_tree(other_node) == tColorTraits::white() && has_parent(other_node)){
-                  if(m_res_cap_map[out_edge] > 0){
+                if(get_tree(other_node) == tColorTraits::white() && other_node != m_sink){
+                  if(get(m_res_cap_map, out_edge) > 0){
                     add_active_node(other_node);
                   }
-                  if(target(get_edge_to_parent(other_node), m_g) == current_node){
+                  if(has_parent(other_node) && target(get_edge_to_parent(other_node), m_g) == current_node){
                     //we were it's parent, so it has to find a new one, too
                     set_no_parent(other_node);
                     m_child_orphans.push(other_node);
@@ -511,9 +512,9 @@ class bk_max_flow {
       //if it has no parent, this node can't be active (if its not source or sink)
       if(!has_parent(v) && v != m_source && v != m_sink){
             m_active_nodes.pop();
-            m_in_active_list_map[v] = false;
+            put(m_in_active_list_map, v, false);
           } else{
-            assert(get_tree(v) == tColorTraits::black() || get_tree(v) == tColorTraits::white());
+            BOOST_ASSERT(get_tree(v) == tColorTraits::black() || get_tree(v) == tColorTraits::white());
             return v;
           }
         }
@@ -523,11 +524,14 @@ class bk_max_flow {
        * adds v as an active vertex, but only if its not in the list already
        */
       inline void add_active_node(vertex_descriptor v){
-        assert(get_tree(v) != tColorTraits::gray());
-        if(m_in_active_list_map[v]){
+        BOOST_ASSERT(get_tree(v) != tColorTraits::gray());
+        if(get(m_in_active_list_map, v)){
+          if (m_last_grow_vertex == v) {
+              m_last_grow_vertex = graph_traits<Graph>::null_vertex();
+          }
           return;
         } else{
-          m_in_active_list_map[v] = true;
+          put(m_in_active_list_map, v, true);
           m_active_nodes.push(v);
         }
       }
@@ -536,9 +540,9 @@ class bk_max_flow {
        * finish_node removes a node from the front of the active queue (its called in grow phase, if no more paths can be found using this node)
        */
       inline void finish_node(vertex_descriptor v){
-        assert(m_active_nodes.front() == v);
+        BOOST_ASSERT(m_active_nodes.front() == v);
         m_active_nodes.pop();
-        m_in_active_list_map[v] = false;
+        put(m_in_active_list_map, v, false);
         m_last_grow_vertex = graph_traits<Graph>::null_vertex();
       }
 
@@ -548,7 +552,7 @@ class bk_max_flow {
        * being no more active)
        */
       inline void remove_active_node(vertex_descriptor v){
-        assert(!has_parent(v));
+        BOOST_ASSERT(!has_parent(v));
       }
 
       /**
@@ -556,7 +560,7 @@ class bk_max_flow {
        * white() for sink tree, gray() for no tree
        */
       inline tColorValue get_tree(vertex_descriptor v) const {
-        return m_tree_map[v];
+        return get(m_tree_map, v);
       }
 
       /**
@@ -564,30 +568,30 @@ class bk_max_flow {
        * for sink tree, gray() for no tree
        */
       inline void set_tree(vertex_descriptor v, tColorValue t){
-        m_tree_map[v] = t;
+        put(m_tree_map, v, t);
       }
 
       /**
        * returns edge to parent vertex of v;
        */
       inline edge_descriptor get_edge_to_parent(vertex_descriptor v) const{
-        return m_pre_map[v];
+        return get(m_pre_map, v);
       }
 
       /**
        * returns true if the edge stored in m_pre_map[v] is a valid entry
        */
       inline bool has_parent(vertex_descriptor v) const{
-        return m_has_parent_map[v];
+        return get(m_has_parent_map, v);
       }
 
       /**
        * sets edge to parent vertex of v;
        */
       inline void set_edge_to_parent(vertex_descriptor v, edge_descriptor f_edge_to_parent){
-        assert(m_res_cap_map[f_edge_to_parent] > 0);
-        m_pre_map[v] = f_edge_to_parent;
-        m_has_parent_map[v] = true;
+        BOOST_ASSERT(get(m_res_cap_map, f_edge_to_parent) > 0);
+        put(m_pre_map, v, f_edge_to_parent);
+        put(m_has_parent_map, v, true);
       }
 
       /**
@@ -595,7 +599,7 @@ class bk_max_flow {
        * entry an additional map)
        */
       inline void set_no_parent(vertex_descriptor v){
-        m_has_parent_map[v] = false;
+        put(m_has_parent_map, v, false);
       }
 
       /**
@@ -607,13 +611,13 @@ class bk_max_flow {
         tDistanceVal current_distance = 0;
         vertex_descriptor current_vertex = v;
         while(true){
-          if(m_time_map[current_vertex] == m_time){
+          if(get(m_time_map, current_vertex) == m_time){
             //we found a node which was already checked this round. use it for distance calculations
-            current_distance += m_dist_map[current_vertex];
+            current_distance += get(m_dist_map, current_vertex);
             break;
           }
           if(current_vertex == m_sink){
-            m_time_map[m_sink] = m_time;
+            put(m_time_map, m_sink, m_time);
             break;
           }
           if(has_parent(current_vertex)){
@@ -626,9 +630,10 @@ class bk_max_flow {
           }
         }
         current_vertex=v;
-        while(m_time_map[current_vertex] != m_time){
-          m_dist_map[current_vertex] = current_distance--;
-          m_time_map[current_vertex] = m_time;
+        while(get(m_time_map, current_vertex) != m_time){
+          put(m_dist_map, current_vertex, current_distance);
+          --current_distance;
+          put(m_time_map, current_vertex, m_time);
           current_vertex = target(get_edge_to_parent(current_vertex), m_g);
         }
         return true;
@@ -643,13 +648,13 @@ class bk_max_flow {
         tDistanceVal current_distance = 0;
         vertex_descriptor current_vertex = v;
         while(true){
-          if(m_time_map[current_vertex] == m_time){
+          if(get(m_time_map, current_vertex) == m_time){
             //we found a node which was already checked this round. use it for distance calculations
-            current_distance += m_dist_map[current_vertex];
+            current_distance += get(m_dist_map, current_vertex);
             break;
           }
           if(current_vertex == m_source){
-            m_time_map[m_source] = m_time;
+            put(m_time_map, m_source, m_time);
             break;
           }
           if(has_parent(current_vertex)){
@@ -662,9 +667,10 @@ class bk_max_flow {
           }
         }
         current_vertex=v;
-        while(m_time_map[current_vertex] != m_time){
-            m_dist_map[current_vertex] = current_distance-- ;
-            m_time_map[current_vertex] = m_time;
+        while(get(m_time_map, current_vertex) != m_time){
+            put(m_dist_map, current_vertex, current_distance);
+            --current_distance;
+            put(m_time_map, current_vertex, m_time);
             current_vertex = source(get_edge_to_parent(current_vertex), m_g);
         }
         return true;
@@ -675,7 +681,8 @@ class bk_max_flow {
        */
       inline bool is_closer_to_terminal(vertex_descriptor p, vertex_descriptor q){
         //checks the timestamps first, to build no cycles, and after that the real distance
-        return (m_time_map[q] <= m_time_map[p] && m_dist_map[q] > m_dist_map[p]+1);
+        return (get(m_time_map, q) <= get(m_time_map, p) &&
+                get(m_dist_map, q) > get(m_dist_map, p)+1);
       }
 
       ////////
@@ -740,17 +747,17 @@ boykov_kolmogorov_max_flow(Graph& g,
   typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor;
 
   //as this method is the last one before we instantiate the solver, we do the concept checks here
-  function_requires<VertexListGraphConcept<Graph> >(); //to have vertices(), num_vertices(),
-  function_requires<EdgeListGraphConcept<Graph> >(); //to have edges()
-  function_requires<IncidenceGraphConcept<Graph> >(); //to have source(), target() and out_edges()
-  function_requires<LvaluePropertyMapConcept<CapacityEdgeMap, edge_descriptor> >(); //read flow-values from edges
-  function_requires<Mutable_LvaluePropertyMapConcept<ResidualCapacityEdgeMap, edge_descriptor> >(); //write flow-values to residuals
-  function_requires<LvaluePropertyMapConcept<ReverseEdgeMap, edge_descriptor> >(); //read out reverse edges
-  function_requires<Mutable_LvaluePropertyMapConcept<PredecessorMap, vertex_descriptor> >(); //store predecessor there
-  function_requires<Mutable_LvaluePropertyMapConcept<ColorMap, vertex_descriptor> >(); //write corresponding tree
-  function_requires<Mutable_LvaluePropertyMapConcept<DistanceMap, vertex_descriptor> >(); //write distance to source/sink
-  function_requires<ReadablePropertyMapConcept<IndexMap, vertex_descriptor> >(); //get index 0...|V|-1
-  assert(num_vertices(g) >= 2 && src != sink);
+  BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> )); //to have vertices(), num_vertices(),
+  BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> )); //to have edges()
+  BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> )); //to have source(), target() and out_edges()
+  BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<CapacityEdgeMap, edge_descriptor> )); //read flow-values from edges
+  BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<ResidualCapacityEdgeMap, edge_descriptor> )); //write flow-values to residuals
+  BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<ReverseEdgeMap, edge_descriptor> )); //read out reverse edges
+  BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<PredecessorMap, vertex_descriptor> )); //store predecessor there
+  BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<ColorMap, vertex_descriptor> )); //write corresponding tree
+  BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<DistanceMap, vertex_descriptor> )); //write distance to source/sink
+  BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<IndexMap, vertex_descriptor> )); //get index 0...|V|-1
+  BOOST_ASSERT(num_vertices(g) >= 2 && src != sink);
 
   detail::bk_max_flow<
     Graph, CapacityEdgeMap, ResidualCapacityEdgeMap, ReverseEdgeMap,
diff --git a/include/boost/graph/breadth_first_search.hpp b/include/boost/graph/breadth_first_search.hpp
index 79fde8cd6..b0d10ad5f 100644
--- a/include/boost/graph/breadth_first_search.hpp
+++ b/include/boost/graph/breadth_first_search.hpp
@@ -24,6 +24,7 @@
 #include <boost/graph/overloading.hpp>
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/two_bit_color_map.hpp>
+#include <boost/concept/assert.hpp>
 
 #ifdef BOOST_GRAPH_USE_MPI
 #include <boost/graph/distributed/concepts.hpp>
@@ -34,7 +35,7 @@ namespace boost {
   template <class Visitor, class Graph>
   struct BFSVisitorConcept {
     void constraints() {
-      function_requires< CopyConstructibleConcept<Visitor> >();
+      BOOST_CONCEPT_ASSERT(( CopyConstructibleConcept<Visitor> ));
       vis.initialize_vertex(u, g);
       vis.discover_vertex(u, g);
       vis.examine_vertex(u, g);
@@ -52,25 +53,28 @@ namespace boost {
   };
 
 
+  // Multiple-source version
   template <class IncidenceGraph, class Buffer, class BFSVisitor,
-            class ColorMap>
+            class ColorMap, class SourceIterator>
   void breadth_first_visit
     (const IncidenceGraph& g,
-     typename graph_traits<IncidenceGraph>::vertex_descriptor s,
+     SourceIterator sources_begin, SourceIterator sources_end,
      Buffer& Q, BFSVisitor vis, ColorMap color)
   {
-    function_requires< IncidenceGraphConcept<IncidenceGraph> >();
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<IncidenceGraph> ));
     typedef graph_traits<IncidenceGraph> GTraits;
     typedef typename GTraits::vertex_descriptor Vertex;
-    typedef typename GTraits::edge_descriptor Edge;
-    function_requires< BFSVisitorConcept<BFSVisitor, IncidenceGraph> >();
-    function_requires< ReadWritePropertyMapConcept<ColorMap, Vertex> >();
+    BOOST_CONCEPT_ASSERT(( BFSVisitorConcept<BFSVisitor, IncidenceGraph> ));
+    BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<ColorMap, Vertex> ));
     typedef typename property_traits<ColorMap>::value_type ColorValue;
     typedef color_traits<ColorValue> Color;
     typename GTraits::out_edge_iterator ei, ei_end;
 
-    put(color, s, Color::gray());             vis.discover_vertex(s, g);
-    Q.push(s);
+    for (; sources_begin != sources_end; ++sources_begin) {
+      Vertex s = *sources_begin;
+      put(color, s, Color::gray());           vis.discover_vertex(s, g);
+      Q.push(s);
+    }
     while (! Q.empty()) {
       Vertex u = Q.top(); Q.pop();            vis.examine_vertex(u, g);
       for (boost::tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei) {
@@ -88,12 +92,25 @@ namespace boost {
     } // end while
   } // breadth_first_visit
 
+  // Single-source version
+  template <class IncidenceGraph, class Buffer, class BFSVisitor,
+            class ColorMap>
+  void breadth_first_visit
+    (const IncidenceGraph& g,
+     typename graph_traits<IncidenceGraph>::vertex_descriptor s,
+     Buffer& Q, BFSVisitor vis, ColorMap color)
+  {
+    typename graph_traits<IncidenceGraph>::vertex_descriptor sources[1] = {s};
+    breadth_first_visit(g, sources, sources + 1, Q, vis, color);
+  }
+
 
-  template <class VertexListGraph, class Buffer, class BFSVisitor,
+  template <class VertexListGraph, class SourceIterator,
+            class Buffer, class BFSVisitor,
             class ColorMap>
   void breadth_first_search
     (const VertexListGraph& g,
-     typename graph_traits<VertexListGraph>::vertex_descriptor s,
+     SourceIterator sources_begin, SourceIterator sources_end,
      Buffer& Q, BFSVisitor vis, ColorMap color)
   {
     // Initialization
@@ -104,7 +121,18 @@ namespace boost {
       vis.initialize_vertex(*i, g);
       put(color, *i, Color::white());
     }
-    breadth_first_visit(g, s, Q, vis, color);
+    breadth_first_visit(g, sources_begin, sources_end, Q, vis, color);
+  }
+
+  template <class VertexListGraph, class Buffer, class BFSVisitor,
+            class ColorMap>
+  void breadth_first_search
+    (const VertexListGraph& g,
+     typename graph_traits<VertexListGraph>::vertex_descriptor s,
+     Buffer& Q, BFSVisitor vis, ColorMap color)
+  {
+    typename graph_traits<VertexListGraph>::vertex_descriptor sources[1] = {s};
+    breadth_first_search(g, sources, sources + 1, Q, vis, color);
   }
 
   namespace graph { struct bfs_visitor_event_not_overridden {}; }
@@ -219,8 +247,7 @@ namespace boost {
        ColorMap color,
        BFSVisitor vis,
        const bgl_named_params<P, T, R>& params,
-       BOOST_GRAPH_ENABLE_IF_MODELS(VertexListGraph, vertex_list_graph_tag,
-                                    void)* = 0)
+       boost::mpl::false_)
     {
       typedef graph_traits<VertexListGraph> Traits;
       // Buffer default
@@ -242,8 +269,7 @@ namespace boost {
        ColorMap color,
        BFSVisitor vis,
        const bgl_named_params<P, T, R>& params,
-       BOOST_GRAPH_ENABLE_IF_MODELS(DistributedGraph, distributed_graph_tag,
-                                    void)* = 0);
+       boost::mpl::true_);
 #endif // BOOST_GRAPH_USE_MPI
 
     //-------------------------------------------------------------------------
@@ -264,18 +290,22 @@ namespace boost {
           (g, s, color,
            choose_param(get_param(params, graph_visitor),
                         make_bfs_visitor(null_visitor())),
-           params);
+           params,
+           boost::mpl::bool_<
+             boost::is_base_and_derived<
+               distributed_graph_tag,
+               typename graph_traits<VertexListGraph>::traversal_category>::value>());
       }
     };
 
     template <>
-    struct bfs_dispatch<detail::error_property_not_found> {
+    struct bfs_dispatch<param_not_found> {
       template <class VertexListGraph, class P, class T, class R>
       static void apply
       (VertexListGraph& g,
        typename graph_traits<VertexListGraph>::vertex_descriptor s,
        const bgl_named_params<P, T, R>& params,
-       detail::error_property_not_found)
+       param_not_found)
       {
         null_visitor null_vis;
 
@@ -287,13 +317,17 @@ namespace boost {
                               g, vertex_index)),
            choose_param(get_param(params, graph_visitor),
                         make_bfs_visitor(null_vis)),
-           params);
+           params,
+           boost::mpl::bool_<
+             boost::is_base_and_derived<
+               distributed_graph_tag,
+               typename graph_traits<VertexListGraph>::traversal_category>::value>());
       }
     };
 
   } // namespace detail
 
-
+#if 1
   // Named Parameter Variant
   template <class VertexListGraph, class P, class T, class R>
   void breadth_first_search
@@ -306,11 +340,11 @@ namespace boost {
     // graph is not really const since we may write to property maps
     // of the graph.
     VertexListGraph& ng = const_cast<VertexListGraph&>(g);
-    typedef typename property_value< bgl_named_params<P,T,R>,
-      vertex_color_t>::type C;
+    typedef typename get_param_type< vertex_color_t, bgl_named_params<P,T,R> >::type C;
     detail::bfs_dispatch<C>::apply(ng, s, params,
                                    get_param(params, vertex_color));
   }
+#endif
 
 
   // This version does not initialize colors, user has to.
@@ -342,6 +376,33 @@ namespace boost {
        );
   }
 
+  namespace graph {
+    namespace detail {
+      template <typename Graph, typename Source>
+      struct breadth_first_search_impl {
+        typedef void result_type;
+        template <typename ArgPack>
+        void operator()(const Graph& g, const Source& source, const ArgPack& arg_pack) {
+          using namespace boost::graph::keywords;
+          typename boost::graph_traits<Graph>::vertex_descriptor sources[1] = {source};
+          boost::queue<typename boost::graph_traits<Graph>::vertex_descriptor> Q;
+          boost::breadth_first_search(g,
+                                      &sources[0],
+                                      &sources[1], 
+                                      boost::unwrap_ref(arg_pack[_buffer | boost::ref(Q)]),
+                                      arg_pack[_visitor | make_bfs_visitor(null_visitor())],
+                                      boost::detail::make_color_map_from_arg_pack(g, arg_pack));
+        }
+      };
+    }
+    BOOST_GRAPH_MAKE_FORWARDING_FUNCTION(breadth_first_search, 2, 4)
+  }
+
+#if 0
+  // Named Parameter Variant
+  BOOST_GRAPH_MAKE_OLD_STYLE_PARAMETER_FUNCTION(breadth_first_search, 2)
+#endif
+
 } // namespace boost
 
 #ifdef BOOST_GRAPH_USE_MPI
diff --git a/include/boost/graph/bron_kerbosch_all_cliques.hpp b/include/boost/graph/bron_kerbosch_all_cliques.hpp
index 35479316a..b663cf95f 100644
--- a/include/boost/graph/bron_kerbosch_all_cliques.hpp
+++ b/include/boost/graph/bron_kerbosch_all_cliques.hpp
@@ -11,6 +11,8 @@
 #include <deque>
 #include <boost/config.hpp>
 
+#include <boost/concept/assert.hpp>
+
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/lookup_edge.hpp>
 
@@ -151,7 +153,7 @@ namespace detail
                                 const Container& in,
                                 Container& out)
     {
-        function_requires< GraphConcept<Graph> >();
+        BOOST_CONCEPT_ASSERT(( GraphConcept<Graph> ));
 
         typename graph_traits<Graph>::directed_category cat;
         typename Container::const_iterator i, end = in.end();
@@ -174,8 +176,8 @@ namespace detail
                         Visitor vis,
                         std::size_t min)
     {
-        function_requires< GraphConcept<Graph> >();
-        function_requires< CliqueVisitorConcept<Visitor,Clique,Graph> >();
+        BOOST_CONCEPT_ASSERT(( GraphConcept<Graph> ));
+        BOOST_CONCEPT_ASSERT(( CliqueVisitorConcept<Visitor,Clique,Graph> ));
         typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
 
         // Is there vertex in nots that is connected to all vertices
@@ -222,7 +224,7 @@ namespace detail
 
         // otherwise, iterate over candidates and and test
         // for maxmimal cliquiness.
-        typename Container::iterator i, j, end = cands.end();
+        typename Container::iterator i, j;
         for(i = cands.begin(); i != cands.end(); ) {
             Vertex candidate = *i;
 
@@ -266,15 +268,14 @@ template <typename Graph, typename Visitor>
 inline void
 bron_kerbosch_all_cliques(const Graph& g, Visitor vis, std::size_t min)
 {
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< VertexIndexGraphConcept<Graph> >();
-    function_requires< AdjacencyMatrixConcept<Graph> >(); // Structural requirement only
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept<Graph> )); // Structural requirement only
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
     typedef typename graph_traits<Graph>::vertex_iterator VertexIterator;
     typedef std::vector<Vertex> VertexSet;
     typedef std::deque<Vertex> Clique;
-    function_requires< CliqueVisitorConcept<Visitor,Clique,Graph> >();
+    BOOST_CONCEPT_ASSERT(( CliqueVisitorConcept<Visitor,Clique,Graph> ));
 
     // NOTE: We're using a deque to implement the clique, because it provides
     // constant inserts and removals at the end and also a constant size.
diff --git a/include/boost/graph/chrobak_payne_drawing.hpp b/include/boost/graph/chrobak_payne_drawing.hpp
index 9e3a2f368..0e1f05255 100644
--- a/include/boost/graph/chrobak_payne_drawing.hpp
+++ b/include/boost/graph/chrobak_payne_drawing.hpp
@@ -11,8 +11,8 @@
 
 #include <vector>
 #include <list>
+#include <stack>
 #include <boost/config.hpp>
-#include <boost/utility.hpp>  //for next and prior
 #include <boost/graph/graph_traits.hpp>
 #include <boost/property_map/property_map.hpp>
 
@@ -34,12 +34,22 @@ namespace boost
                             VertexToVertexMap left,
                             VertexToVertexMap right)
     {
-      if (v != graph_traits<Graph>::null_vertex())
-        {
+      typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor;
+      // Suggestion of explicit stack from Aaron Windsor to avoid system stack
+      // overflows.
+      typedef std::pair<vertex_descriptor, std::size_t> stack_entry;
+      std::stack<stack_entry> st;
+      st.push(stack_entry(v, offset));
+      while (!st.empty()) {
+        vertex_descriptor v = st.top().first;
+        std::size_t offset = st.top().second;
+        st.pop();
+        if (v != graph_traits<Graph>::null_vertex()) {
           x[v] += delta_x[v] + offset;
-          accumulate_offsets(left[v], x[v], g, x, delta_x, left, right);
-          accumulate_offsets(right[v], x[v], g, x, delta_x, left, right);
+          st.push(stack_entry(left[v], x[v]));
+          st.push(stack_entry(right[v], x[v]));
         }
+      }
     }
 
   } /*namespace detail*/ } /*namespace graph*/
@@ -63,7 +73,6 @@ namespace boost
   {
 
     typedef typename graph_traits<Graph>::vertex_descriptor vertex_t;
-    typedef typename graph_traits<Graph>::edge_descriptor edge_t;
     typedef typename graph_traits<Graph>::vertex_iterator vertex_iterator_t;
     typedef typename PlanarEmbedding::value_type::const_iterator 
       edge_permutation_iterator_t;
@@ -230,7 +239,7 @@ namespace boost
       (*ordering_begin,0,g,x,delta_x,left,right);
 
     vertex_iterator_t vi, vi_end;
-    for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
+    for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
       {
         vertex_t v(*vi);
         drawing[v].x = x[v];
diff --git a/include/boost/graph/closeness_centrality.hpp b/include/boost/graph/closeness_centrality.hpp
index 77cea7b0e..3ddf284b5 100644
--- a/include/boost/graph/closeness_centrality.hpp
+++ b/include/boost/graph/closeness_centrality.hpp
@@ -9,6 +9,7 @@
 
 #include <boost/graph/detail/geodesic.hpp>
 #include <boost/graph/exterior_property.hpp>
+#include <boost/concept/assert.hpp>
 
 namespace boost
 {
@@ -25,9 +26,9 @@ struct closeness_measure
 
     result_type operator ()(distance_type d, const Graph&)
     {
-        function_requires< NumericValueConcept<DistanceType> >();
-        function_requires< NumericValueConcept<ResultType> >();
-        function_requires< AdaptableUnaryFunctionConcept<Reciprocal,ResultType,ResultType> >();
+        BOOST_CONCEPT_ASSERT(( NumericValueConcept<DistanceType> ));
+        BOOST_CONCEPT_ASSERT(( NumericValueConcept<ResultType> ));
+        BOOST_CONCEPT_ASSERT(( AdaptableUnaryFunctionConcept<Reciprocal,ResultType,ResultType> ));
         return (d == base_type::infinite_distance())
             ? base_type::zero_result()
             : rec(result_type(d));
@@ -75,12 +76,12 @@ closeness_centrality(const Graph& g,
                      Measure measure,
                      Combinator combine)
 {
-    function_requires< VertexListGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
-    function_requires< ReadablePropertyMapConcept<DistanceMap,Vertex> >();
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMap,Vertex> ));
     typedef typename property_traits<DistanceMap>::value_type Distance;
-    function_requires< NumericValueConcept<Distance> >();
-    function_requires< DistanceMeasureConcept<Measure,Graph> >();
+    BOOST_CONCEPT_ASSERT(( NumericValueConcept<Distance> ));
+    BOOST_CONCEPT_ASSERT(( DistanceMeasureConcept<Measure,Graph> ));
 
     Distance n = detail::combine_distances(g, dist, combine, Distance(0));
     return measure(n, g);
@@ -90,9 +91,9 @@ template <typename Graph, typename DistanceMap, typename Measure>
 inline typename Measure::result_type
 closeness_centrality(const Graph& g, DistanceMap dist, Measure measure)
 {
-    function_requires< GraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( GraphConcept<Graph> ));
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
-    function_requires< ReadablePropertyMapConcept<DistanceMap,Vertex> >();
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMap,Vertex> ));
     typedef typename property_traits<DistanceMap>::value_type Distance;
 
     return closeness_centrality(g, dist, measure, std::plus<Distance>());
@@ -116,17 +117,16 @@ all_closeness_centralities(const Graph& g,
                            CentralityMap cent,
                            Measure measure)
 {
-    function_requires< VertexListGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
-    function_requires< ReadablePropertyMapConcept<DistanceMatrixMap,Vertex> >();
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMatrixMap,Vertex> ));
     typedef typename property_traits<DistanceMatrixMap>::value_type DistanceMap;
-    function_requires< ReadablePropertyMapConcept<DistanceMap,Vertex> >();
-    function_requires< WritablePropertyMapConcept<CentralityMap,Vertex> >();
-    typedef typename property_traits<DistanceMap>::value_type Distance;
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMap,Vertex> ));
+    BOOST_CONCEPT_ASSERT(( WritablePropertyMapConcept<CentralityMap,Vertex> ));
     typedef typename property_traits<CentralityMap>::value_type Centrality;
 
     typename graph_traits<Graph>::vertex_iterator i, end;
-    for(tie(i, end) = vertices(g); i != end; ++i) {
+    for(boost::tie(i, end) = vertices(g); i != end; ++i) {
         DistanceMap dm = get(dist, *i);
         Centrality c = closeness_centrality(g, dm, measure);
         put(cent, *i, c);
@@ -141,12 +141,11 @@ all_closeness_centralities(const Graph& g,
                             DistanceMatrixMap dist,
                             CentralityMap cent)
 {
-    function_requires< GraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( GraphConcept<Graph> ));
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
-    function_requires< ReadablePropertyMapConcept<DistanceMatrixMap,Vertex> >();
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMatrixMap,Vertex> ));
     typedef typename property_traits<DistanceMatrixMap>::value_type DistanceMap;
-    function_requires< ReadablePropertyMapConcept<DistanceMap,Vertex> >();
-    typedef typename property_traits<DistanceMap>::value_type Distance;
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMap,Vertex> ));
     typedef typename property_traits<CentralityMap>::value_type Result;
 
     all_closeness_centralities(g, dist, cent, measure_closeness<Result>(g, DistanceMap()));
diff --git a/include/boost/graph/clustering_coefficient.hpp b/include/boost/graph/clustering_coefficient.hpp
index 15574f041..5345ed999 100644
--- a/include/boost/graph/clustering_coefficient.hpp
+++ b/include/boost/graph/clustering_coefficient.hpp
@@ -7,10 +7,11 @@
 #ifndef BOOST_GRAPH_CLUSTERING_COEFFICIENT_HPP
 #define BOOST_GRAPH_CLUSTERING_COEFFICIENT_HPP
 
-#include <boost/utility.hpp>
+#include <boost/next_prior.hpp>
 #include <boost/graph/graph_traits.hpp>
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/lookup_edge.hpp>
+#include <boost/concept/assert.hpp>
 
 namespace boost
 {
@@ -20,7 +21,7 @@ namespace detail
     inline typename graph_traits<Graph>::degree_size_type
     possible_edges(const Graph& g, std::size_t k, directed_tag)
     {
-        function_requires< GraphConcept<Graph> >();
+        BOOST_CONCEPT_ASSERT(( GraphConcept<Graph> ));
         typedef typename graph_traits<Graph>::degree_size_type T;
         return T(k) * (T(k) - 1);
     }
@@ -37,12 +38,12 @@ namespace detail
     template <class Graph>
     inline typename graph_traits<Graph>::degree_size_type
     count_edges(const Graph& g,
-                typename Graph::vertex_descriptor u,
-                typename Graph::vertex_descriptor v,
+                typename graph_traits<Graph>::vertex_descriptor u,
+                typename graph_traits<Graph>::vertex_descriptor v,
                 directed_tag)
 
     {
-        function_requires< AdjacencyMatrixConcept<Graph> >();
+        BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept<Graph> ));
         return (lookup_edge(u, v, g).second ? 1 : 0) +
                 (lookup_edge(v, u, g).second ? 1 : 0);
     }
@@ -51,11 +52,11 @@ namespace detail
     template <class Graph>
     inline typename graph_traits<Graph>::degree_size_type
     count_edges(const Graph& g,
-                typename Graph::vertex_descriptor u,
-                typename Graph::vertex_descriptor v,
+                typename graph_traits<Graph>::vertex_descriptor u,
+                typename graph_traits<Graph>::vertex_descriptor v,
                 undirected_tag)
     {
-        function_requires< AdjacencyMatrixConcept<Graph> >();
+        BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept<Graph> ));
         return lookup_edge(u, v, g).second ? 1 : 0;
     }
 }
@@ -64,7 +65,7 @@ template <typename Graph, typename Vertex>
 inline typename graph_traits<Graph>::degree_size_type
 num_paths_through_vertex(const Graph& g, Vertex v)
 {
-    function_requires< AdjacencyGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
     typedef typename graph_traits<Graph>::directed_category Directed;
     typedef typename graph_traits<Graph>::adjacency_iterator AdjacencyIterator;
 
@@ -81,8 +82,8 @@ template <typename Graph, typename Vertex>
 inline typename graph_traits<Graph>::degree_size_type
 num_triangles_on_vertex(const Graph& g, Vertex v)
 {
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
     typedef typename graph_traits<Graph>::degree_size_type Degree;
     typedef typename graph_traits<Graph>::directed_category Directed;
     typedef typename graph_traits<Graph>::adjacency_iterator AdjacencyIterator;
@@ -119,10 +120,10 @@ template <typename Graph, typename ClusteringMap>
 inline typename property_traits<ClusteringMap>::value_type
 all_clustering_coefficients(const Graph& g, ClusteringMap cm)
 {
-    function_requires< VertexListGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
     typedef typename graph_traits<Graph>::vertex_iterator VertexIterator;
-    function_requires< WritablePropertyMapConcept<ClusteringMap,Vertex> >();
+    BOOST_CONCEPT_ASSERT(( WritablePropertyMapConcept<ClusteringMap,Vertex> ));
     typedef typename property_traits<ClusteringMap>::value_type Coefficient;
 
     Coefficient sum(0);
@@ -139,10 +140,10 @@ template <typename Graph, typename ClusteringMap>
 inline typename property_traits<ClusteringMap>::value_type
 mean_clustering_coefficient(const Graph& g, ClusteringMap cm)
 {
-    function_requires< VertexListGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
     typedef typename graph_traits<Graph>::vertex_iterator VertexIterator;
-    function_requires< ReadablePropertyMapConcept<ClusteringMap,Vertex> >();
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<ClusteringMap,Vertex> ));
     typedef typename property_traits<ClusteringMap>::value_type Coefficient;
 
     Coefficient cc(0);
diff --git a/include/boost/graph/compressed_sparse_row_graph.hpp b/include/boost/graph/compressed_sparse_row_graph.hpp
index 9b5a4d52c..7b91d4d6c 100644
--- a/include/boost/graph/compressed_sparse_row_graph.hpp
+++ b/include/boost/graph/compressed_sparse_row_graph.hpp
@@ -17,7 +17,7 @@
 #include <utility>
 #include <algorithm>
 #include <climits>
-#include <cassert>
+#include <boost/assert.hpp>
 #include <iterator>
 #if 0
 #include <iostream> // For some debugging code below
@@ -37,16 +37,15 @@
 #include <boost/integer.hpp>
 #include <boost/iterator/iterator_facade.hpp>
 #include <boost/mpl/if.hpp>
+#include <boost/utility/enable_if.hpp>
 #include <boost/graph/graph_selectors.hpp>
+#include <boost/graph/detail/is_distributed_selector.hpp>
 #include <boost/graph/properties.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/functional/hash.hpp>
-#include <boost/utility.hpp>
-
-#ifdef BOOST_GRAPH_NO_BUNDLED_PROPERTIES
-#  error The Compressed Sparse Row graph only supports bundled properties.
-#  error You will need a compiler that conforms better to the C++ standard.
-#endif
+#include <boost/next_prior.hpp>
+#include <boost/property_map/transform_value_property_map.hpp>
+#include <boost/mpl/print.hpp>
 
 namespace boost {
 
@@ -139,7 +138,7 @@ namespace detail {
     typedef boost::iterator_facade<default_construct_iterator<T>, T, std::random_access_iterator_tag, const T&> base_type;
     T saved_value;
     const T& dereference() const {return saved_value;}
-    bool equal(default_construct_iterator i) const {return true;}
+    bool equal(default_construct_iterator /*i*/) const {return true;}
     void increment() {}
     void decrement() {}
     void advance(typename base_type::difference_type) {}
@@ -193,10 +192,15 @@ class compressed_sparse_row_graph<directedS, VertexProperty, EdgeProperty, Graph
                                             VertexProperty, Vertex, typed_identity_property_map<Vertex> >
     inherited_vertex_properties;
 
+  // Some tests to prevent use of "void" is a property type (as was done in some test cases):
+  BOOST_STATIC_ASSERT((!is_same<VertexProperty, void>::value));
+  BOOST_STATIC_ASSERT((!is_same<EdgeProperty, void>::value));
+  BOOST_STATIC_ASSERT((!is_same<GraphProperty, void>::value));
+
  public:
   // For Property Graph
-  typedef typename graph_detail::graph_prop<GraphProperty>::property graph_property_type;
-  typedef typename graph_detail::graph_prop<GraphProperty>::bundle graph_bundled;
+  typedef GraphProperty graph_property_type;
+  typedef typename lookup_one_property<GraphProperty, graph_bundle_t>::type graph_bundled;
 
   typedef detail::compressed_sparse_row_structure<EdgeProperty, Vertex, EdgeIndex> forward_type;
 
@@ -643,8 +647,6 @@ class compressed_sparse_row_graph<directedS, VertexProperty, EdgeProperty, Graph
                      const GlobalToLocal& global_to_local) {
     typedef compressed_sparse_row_graph Graph;
     typedef typename boost::graph_traits<Graph>::vertex_descriptor vertex_t;
-    typedef typename boost::graph_traits<Graph>::vertices_size_type vertex_num;
-    typedef typename boost::graph_traits<Graph>::edges_size_type edge_num;
     typedef std::vector<std::pair<vertex_t, vertex_t> > edge_vector_t;
     edge_vector_t new_edges(first, last);
     if (new_edges.empty()) return;
@@ -667,8 +669,6 @@ class compressed_sparse_row_graph<directedS, VertexProperty, EdgeProperty, Graph
                      const GlobalToLocal& global_to_local) {
     typedef compressed_sparse_row_graph Graph;
     typedef typename boost::graph_traits<Graph>::vertex_descriptor vertex_t;
-    typedef typename boost::graph_traits<Graph>::vertices_size_type vertex_num;
-    typedef typename boost::graph_traits<Graph>::edges_size_type edge_num;
     typedef std::pair<vertex_t, vertex_t> vertex_pair;
     typedef std::vector<
               boost::tuple<vertex_pair,
@@ -746,8 +746,8 @@ class compressed_sparse_row_graph<bidirectionalS, VertexProperty, EdgeProperty,
 
  public:
   // For Property Graph
-  typedef typename graph_detail::graph_prop<GraphProperty>::property graph_property_type;
-  typedef typename graph_detail::graph_prop<GraphProperty>::bundle graph_bundled;
+  typedef GraphProperty graph_property_type;
+  typedef typename lookup_one_property<GraphProperty, graph_bundle_t>::type graph_bundled;
   // typedef GraphProperty graph_property_type;
 
   typedef detail::compressed_sparse_row_structure<EdgeProperty, Vertex, EdgeIndex> forward_type;
@@ -933,6 +933,7 @@ class compressed_sparse_row_graph<bidirectionalS, VertexProperty, EdgeProperty,
   {
     m_forward.assign(g, vi, numverts, numedges);
     inherited_vertex_properties::resize(numverts);
+    set_up_backward_property_links();
   }
 
   // Requires the above, plus VertexListGraph and EdgeListGraph
@@ -946,6 +947,7 @@ class compressed_sparse_row_graph<bidirectionalS, VertexProperty, EdgeProperty,
     vertices_size_type numverts = num_vertices(g);
     m_forward.assign(g, vi, numverts, numedges);
     inherited_vertex_properties::resize(numverts);
+    set_up_backward_property_links();
   }
 
   // Requires the above, plus a vertex_index map.
@@ -959,125 +961,7 @@ class compressed_sparse_row_graph<bidirectionalS, VertexProperty, EdgeProperty,
     vertices_size_type numverts = num_vertices(g);
     m_forward.assign(g, get(vertex_index, g), numverts, numedges);
     inherited_vertex_properties::resize(numverts);
-  }
-
-  // Add edges from a sorted (smallest sources first) range of pairs and edge
-  // properties
-  template <typename BidirectionalIteratorOrig, typename EPIterOrig,
-            typename GlobalToLocal>
-  void
-  add_edges_sorted_internal(
-      BidirectionalIteratorOrig first_sorted,
-      BidirectionalIteratorOrig last_sorted,
-      EPIterOrig ep_iter_sorted,
-      const GlobalToLocal& global_to_local) {
-    m_forward.add_edges_sorted_internal(first_sorted, last_sorted, ep_iter_sorted, global_to_local);
-  }
-
-  template <typename BidirectionalIteratorOrig, typename EPIterOrig>
-  void
-  add_edges_sorted_internal(
-      BidirectionalIteratorOrig first_sorted,
-      BidirectionalIteratorOrig last_sorted,
-      EPIterOrig ep_iter_sorted)  {
-    m_forward.add_edges_sorted_internal(first_sorted, last_sorted, ep_iter_sorted, typed_identity_property_map<Vertex>());
-  }
-
-  // Add edges from a sorted (smallest sources first) range of pairs
-  template <typename BidirectionalIteratorOrig>
-  void
-  add_edges_sorted_internal(
-      BidirectionalIteratorOrig first_sorted,
-      BidirectionalIteratorOrig last_sorted) {
-    m_forward.add_edges_sorted_internal(first_sorted, last_sorted, detail::default_construct_iterator<edge_bundled>());
-  }
-
-  template <typename BidirectionalIteratorOrig, typename GlobalToLocal>
-  void
-  add_edges_sorted_internal_global(
-      BidirectionalIteratorOrig first_sorted,
-      BidirectionalIteratorOrig last_sorted,
-      const GlobalToLocal& global_to_local) {
-    m_forward.add_edges_sorted_internal(first_sorted, last_sorted, detail::default_construct_iterator<edge_bundled>(), global_to_local);
-  }
-
-  template <typename BidirectionalIteratorOrig, typename EPIterOrig,
-            typename GlobalToLocal>
-  void
-  add_edges_sorted_internal_global(
-      BidirectionalIteratorOrig first_sorted,
-      BidirectionalIteratorOrig last_sorted,
-      EPIterOrig ep_iter_sorted,
-      const GlobalToLocal& global_to_local) {
-    m_forward.add_edges_sorted_internal(first_sorted, last_sorted, ep_iter_sorted, global_to_local);
-  }
-
-  // Add edges from a range of (source, target) pairs that are unsorted
-  template <typename InputIterator, typename GlobalToLocal>
-  inline void
-  add_edges_internal(InputIterator first, InputIterator last,
-                     const GlobalToLocal& global_to_local) {
-    typedef compressed_sparse_row_graph Graph;
-    typedef typename boost::graph_traits<Graph>::vertex_descriptor vertex_t;
-    typedef typename boost::graph_traits<Graph>::vertices_size_type vertex_num;
-    typedef typename boost::graph_traits<Graph>::edges_size_type edge_num;
-    typedef std::vector<std::pair<vertex_t, vertex_t> > edge_vector_t;
-    edge_vector_t new_edges(first, last);
-    if (new_edges.empty()) return;
-    std::sort(new_edges.begin(), new_edges.end());
-    this->add_edges_sorted_internal_global(new_edges.begin(), new_edges.end(), global_to_local);
-  }
-
-  template <typename InputIterator>
-  inline void
-  add_edges_internal(InputIterator first, InputIterator last) {
-    this->add_edges_internal(first, last, typed_identity_property_map<Vertex>());
-  }
-
-  // Add edges from a range of (source, target) pairs and edge properties that
-  // are unsorted
-  template <typename InputIterator, typename EPIterator, typename GlobalToLocal>
-  inline void
-  add_edges_internal(InputIterator first, InputIterator last,
-                     EPIterator ep_iter, EPIterator ep_iter_end,
-                     const GlobalToLocal& global_to_local) {
-    typedef compressed_sparse_row_graph Graph;
-    typedef typename boost::graph_traits<Graph>::vertex_descriptor vertex_t;
-    typedef typename boost::graph_traits<Graph>::vertices_size_type vertex_num;
-    typedef typename boost::graph_traits<Graph>::edges_size_type edge_num;
-    typedef std::pair<vertex_t, vertex_t> vertex_pair;
-    typedef std::vector<
-              boost::tuple<vertex_pair,
-                           edge_bundled> >
-      edge_vector_t;
-    edge_vector_t new_edges
-      (boost::make_zip_iterator(boost::make_tuple(first, ep_iter)),
-       boost::make_zip_iterator(boost::make_tuple(last, ep_iter_end)));
-    if (new_edges.empty()) return;
-    std::sort(new_edges.begin(), new_edges.end(),
-              boost::detail::compare_first<
-                std::less<vertex_pair> >());
-    m_forward.add_edges_sorted_internal
-      (boost::make_transform_iterator(
-         new_edges.begin(),
-         boost::detail::my_tuple_get_class<0, vertex_pair>()),
-       boost::make_transform_iterator(
-         new_edges.end(),
-         boost::detail::my_tuple_get_class<0, vertex_pair>()),
-       boost::make_transform_iterator(
-         new_edges.begin(),
-         boost::detail::my_tuple_get_class
-           <1, edge_bundled>()),
-       global_to_local);
-  }
-
-  // Add edges from a range of (source, target) pairs and edge properties that
-  // are unsorted
-  template <typename InputIterator, typename EPIterator>
-  inline void
-  add_edges_internal(InputIterator first, InputIterator last,
-                     EPIterator ep_iter, EPIterator ep_iter_end) {
-    this->add_edges_internal(first, last, ep_iter, ep_iter_end, typed_identity_property_map<Vertex>());
+    set_up_backward_property_links();
   }
 
   using inherited_vertex_properties::operator[];
@@ -1134,7 +1018,6 @@ add_vertices(typename BOOST_DIR_CSR_GRAPH_TYPE::vertices_size_type count, BOOST_
   Vertex old_num_verts_plus_one = g.m_forward.m_rowstart.size();
   EdgeIndex numedges = g.m_forward.m_rowstart.back();
   g.m_forward.m_rowstart.resize(old_num_verts_plus_one + count, numedges);
-  g.m_backward.m_rowstart.resize(old_num_verts_plus_one + count, numedges);
   g.vertex_properties().resize(num_vertices(g));
   return old_num_verts_plus_one - 1;
 }
@@ -1282,7 +1165,6 @@ inline std::pair<typename BOOST_BIDIR_CSR_GRAPH_TYPE::in_edge_iterator,
                  typename BOOST_BIDIR_CSR_GRAPH_TYPE::in_edge_iterator>
 in_edges(Vertex v, const BOOST_BIDIR_CSR_GRAPH_TYPE& g)
 {
-  typedef typename BOOST_BIDIR_CSR_GRAPH_TYPE::edge_descriptor ed;
   typedef typename BOOST_BIDIR_CSR_GRAPH_TYPE::in_edge_iterator it;
   EdgeIndex v_row_start = g.m_backward.m_rowstart[v];
   EdgeIndex next_row_start = g.m_backward.m_rowstart[v + 1];
@@ -1342,7 +1224,7 @@ inline typename BOOST_CSR_GRAPH_TYPE::edge_descriptor
 edge_from_index(EdgeIndex idx, const BOOST_CSR_GRAPH_TYPE& g)
 {
   typedef typename std::vector<EdgeIndex>::const_iterator row_start_iter;
-  assert (idx < num_edges(g));
+  BOOST_ASSERT (idx < num_edges(g));
   row_start_iter src_plus_1 =
     std::upper_bound(g.m_forward.m_rowstart.begin(),
                      g.m_forward.m_rowstart.end(),
@@ -1383,56 +1265,147 @@ edges(const BOOST_CSR_GRAPH_TYPE& g)
 // Graph properties
 template<BOOST_CSR_GRAPH_TEMPLATE_PARMS, class Tag, class Value>
 inline void
-set_property(BOOST_CSR_GRAPH_TYPE& g, Tag, const Value& value)
+set_property(BOOST_CSR_GRAPH_TYPE& g, Tag tag, const Value& value)
 {
-  get_property_value(g.m_property, Tag()) = value;
+  get_property_value(g.m_property, tag) = value;
 }
 
 template<BOOST_CSR_GRAPH_TEMPLATE_PARMS, class Tag>
 inline
 typename graph_property<BOOST_CSR_GRAPH_TYPE, Tag>::type&
-get_property(BOOST_CSR_GRAPH_TYPE& g, Tag)
+get_property(BOOST_CSR_GRAPH_TYPE& g, Tag tag)
 {
-  return get_property_value(g.m_property, Tag());
+  return get_property_value(g.m_property, tag);
 }
 
 template<BOOST_CSR_GRAPH_TEMPLATE_PARMS, class Tag>
 inline
 const
 typename graph_property<BOOST_CSR_GRAPH_TYPE, Tag>::type&
-get_property(const BOOST_CSR_GRAPH_TYPE& g, Tag)
+get_property(const BOOST_CSR_GRAPH_TYPE& g, Tag tag)
 {
-  return get_property_value(g.m_property, Tag());
+  return get_property_value(g.m_property, tag);
+}
+
+template <typename G, typename Tag, typename Kind>
+struct csr_property_map_helper {};
+// Kind == void for invalid property tags, so we can use that to SFINAE out
+
+template <BOOST_CSR_GRAPH_TEMPLATE_PARMS, typename Tag>
+struct csr_property_map_helper<BOOST_CSR_GRAPH_TYPE, Tag, vertex_property_tag> {
+  typedef vertex_all_t all_tag;
+  typedef typename property_traits<typename property_map<BOOST_CSR_GRAPH_TYPE, vertex_all_t>::type>::key_type key_type;
+  typedef VertexProperty plist_type;
+  typedef typename property_map<BOOST_CSR_GRAPH_TYPE, vertex_all_t>::type all_type;
+  typedef typename property_map<BOOST_CSR_GRAPH_TYPE, vertex_all_t>::const_type all_const_type;
+  typedef transform_value_property_map<detail::lookup_one_property_f<plist_type, Tag>, all_type> type;
+  typedef transform_value_property_map<detail::lookup_one_property_f<const plist_type, Tag>, all_const_type> const_type;
+};
+
+template <BOOST_CSR_GRAPH_TEMPLATE_PARMS, typename Tag>
+struct csr_property_map_helper<BOOST_CSR_GRAPH_TYPE, Tag, edge_property_tag> {
+  typedef edge_all_t all_tag;
+  typedef typename property_traits<typename property_map<BOOST_CSR_GRAPH_TYPE, edge_all_t>::type>::key_type key_type;
+  typedef EdgeProperty plist_type;
+  typedef typename property_map<BOOST_CSR_GRAPH_TYPE, edge_all_t>::type all_type;
+  typedef typename property_map<BOOST_CSR_GRAPH_TYPE, edge_all_t>::const_type all_const_type;
+  typedef transform_value_property_map<detail::lookup_one_property_f<plist_type, Tag>, all_type> type;
+  typedef transform_value_property_map<detail::lookup_one_property_f<const plist_type, Tag>, all_const_type> const_type;
+};
+
+template <BOOST_CSR_GRAPH_TEMPLATE_PARMS, typename Tag>
+struct csr_property_map_helper<BOOST_CSR_GRAPH_TYPE, Tag, graph_property_tag> {
+  typedef graph_all_t all_tag;
+  typedef BOOST_CSR_GRAPH_TYPE* key_type;
+  typedef GraphProperty plist_type;
+  typedef typename property_map<BOOST_CSR_GRAPH_TYPE, graph_all_t>::type all_type;
+  typedef typename property_map<BOOST_CSR_GRAPH_TYPE, graph_all_t>::const_type all_const_type;
+  typedef transform_value_property_map<detail::lookup_one_property_f<plist_type, Tag>, all_type> type;
+  typedef transform_value_property_map<detail::lookup_one_property_f<const plist_type, Tag>, all_const_type> const_type;
+};
+
+// disable_if isn't truly necessary but required to avoid ambiguity with specializations below
+template <BOOST_CSR_GRAPH_TEMPLATE_PARMS, typename Tag>
+struct property_map<BOOST_CSR_GRAPH_TYPE, Tag, typename disable_if<detail::is_distributed_selector<Vertex> >::type>:
+  csr_property_map_helper<
+    BOOST_CSR_GRAPH_TYPE,
+    Tag,
+    typename detail::property_kind_from_graph<BOOST_CSR_GRAPH_TYPE, Tag>
+               ::type> {};
+
+template <BOOST_CSR_GRAPH_TEMPLATE_PARMS, typename Tag>
+typename property_map<BOOST_CSR_GRAPH_TYPE, Tag>::type
+get(Tag tag, BOOST_CSR_GRAPH_TYPE& g) {
+  return typename property_map<BOOST_CSR_GRAPH_TYPE, Tag>::type(tag, get(typename property_map<BOOST_CSR_GRAPH_TYPE, Tag>::all_tag(), g));
+}
+
+template <BOOST_CSR_GRAPH_TEMPLATE_PARMS, typename Tag>
+typename property_map<BOOST_CSR_GRAPH_TYPE, Tag>::const_type
+get(Tag tag, const BOOST_CSR_GRAPH_TYPE& g) {
+  return typename property_map<BOOST_CSR_GRAPH_TYPE, Tag>::const_type(tag, get(typename property_map<BOOST_CSR_GRAPH_TYPE, Tag>::all_tag(), g));
+}
+
+template <BOOST_CSR_GRAPH_TEMPLATE_PARMS, typename Tag>
+typename property_traits<typename property_map<BOOST_CSR_GRAPH_TYPE, Tag>::type>::reference
+get(Tag tag, BOOST_CSR_GRAPH_TYPE& g, typename property_map<BOOST_CSR_GRAPH_TYPE, Tag>::key_type k) {
+  typedef typename property_map<BOOST_CSR_GRAPH_TYPE, Tag>::all_tag all_tag;
+  typedef typename property_map<BOOST_CSR_GRAPH_TYPE, all_tag>::type outer_pm;
+  return lookup_one_property<typename property_traits<outer_pm>::value_type, Tag>::lookup(get(all_tag(), g, k), tag);
+}
+
+template <BOOST_CSR_GRAPH_TEMPLATE_PARMS, typename Tag>
+typename property_traits<typename property_map<BOOST_CSR_GRAPH_TYPE, Tag>::const_type>::reference
+get(Tag tag, const BOOST_CSR_GRAPH_TYPE& g, typename property_map<BOOST_CSR_GRAPH_TYPE, Tag>::key_type k) {
+  typedef typename property_map<BOOST_CSR_GRAPH_TYPE, Tag>::all_tag all_tag;
+  typedef typename property_map<BOOST_CSR_GRAPH_TYPE, all_tag>::const_type outer_pm;
+  return lookup_one_property<const typename property_traits<outer_pm>::value_type, Tag>::lookup(get(all_tag(), g, k), tag);
+}
+
+template <BOOST_CSR_GRAPH_TEMPLATE_PARMS, typename Tag>
+void
+put(Tag tag,
+    BOOST_CSR_GRAPH_TYPE& g,
+    typename property_map<BOOST_CSR_GRAPH_TYPE, Tag>::key_type k,
+    typename lookup_one_property<typename property_map<BOOST_CSR_GRAPH_TYPE, Tag>::plist_type, Tag>::type val) {
+  typedef typename property_map<BOOST_CSR_GRAPH_TYPE, Tag>::all_tag all_tag;
+  lookup_one_property<typename property_map<BOOST_CSR_GRAPH_TYPE, Tag>::plist_type, Tag>::lookup(get(all_tag(), g, k), tag) = val;
 }
 
 template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
-struct property_map<BOOST_CSR_GRAPH_TYPE, vertex_index_t>
+struct property_map<BOOST_CSR_GRAPH_TYPE, vertex_index_t, typename disable_if<detail::is_distributed_selector<Vertex> >::type>
 {
   typedef typed_identity_property_map<Vertex> type;
   typedef type const_type;
 };
 
 template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
-struct property_map<BOOST_CSR_GRAPH_TYPE, edge_index_t>
+struct property_map<BOOST_CSR_GRAPH_TYPE, edge_index_t, typename disable_if<detail::is_distributed_selector<Vertex> >::type>
 {
   typedef detail::csr_edge_index_map<Vertex, EdgeIndex> type;
   typedef type const_type;
 };
 
 template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
-struct property_map<BOOST_CSR_GRAPH_TYPE, vertex_bundle_t>
+struct property_map<BOOST_CSR_GRAPH_TYPE, vertex_all_t, typename disable_if<detail::is_distributed_selector<Vertex> >::type>
 {
   typedef typename BOOST_CSR_GRAPH_TYPE::inherited_vertex_properties::vertex_map_type type;
   typedef typename BOOST_CSR_GRAPH_TYPE::inherited_vertex_properties::const_vertex_map_type const_type;
 };
 
 template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
-struct property_map<BOOST_CSR_GRAPH_TYPE, edge_bundle_t>
+struct property_map<BOOST_CSR_GRAPH_TYPE, edge_all_t, typename disable_if<detail::is_distributed_selector<Vertex> >::type>
 {
   typedef typename BOOST_CSR_GRAPH_TYPE::forward_type::inherited_edge_properties::edge_map_type type;
   typedef typename BOOST_CSR_GRAPH_TYPE::forward_type::inherited_edge_properties::const_edge_map_type const_type;
 };
 
+template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
+struct property_map<BOOST_CSR_GRAPH_TYPE, graph_all_t, typename disable_if<detail::is_distributed_selector<Vertex> >::type>
+{
+  typedef boost::ref_property_map<BOOST_CSR_GRAPH_TYPE*, typename BOOST_CSR_GRAPH_TYPE::graph_property_type> type;
+  typedef boost::ref_property_map<BOOST_CSR_GRAPH_TYPE*, const typename BOOST_CSR_GRAPH_TYPE::graph_property_type> const_type;
+};
+
 template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
 inline typed_identity_property_map<Vertex>
 get(vertex_index_t, const BOOST_CSR_GRAPH_TYPE&)
@@ -1448,6 +1421,21 @@ get(vertex_index_t,
   return v;
 }
 
+template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
+inline typed_identity_property_map<Vertex>
+get(vertex_index_t, BOOST_CSR_GRAPH_TYPE&)
+{
+  return typed_identity_property_map<Vertex>();
+}
+
+template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
+inline Vertex
+get(vertex_index_t,
+    BOOST_CSR_GRAPH_TYPE&, Vertex v)
+{
+  return v;
+}
+
 template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
 inline typename property_map<BOOST_CSR_GRAPH_TYPE, edge_index_t>::const_type
 get(edge_index_t, const BOOST_CSR_GRAPH_TYPE&)
@@ -1466,125 +1454,144 @@ get(edge_index_t, const BOOST_CSR_GRAPH_TYPE&,
 }
 
 template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
-inline typename property_map<BOOST_CSR_GRAPH_TYPE, vertex_bundle_t>::type
-get(vertex_bundle_t, BOOST_CSR_GRAPH_TYPE& g)
+inline typename property_map<BOOST_CSR_GRAPH_TYPE, edge_index_t>::const_type
+get(edge_index_t, BOOST_CSR_GRAPH_TYPE&)
+{
+  typedef typename property_map<BOOST_CSR_GRAPH_TYPE, edge_index_t>::const_type
+    result_type;
+  return result_type();
+}
+
+template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
+inline EdgeIndex
+get(edge_index_t, BOOST_CSR_GRAPH_TYPE&,
+    typename BOOST_CSR_GRAPH_TYPE::edge_descriptor e)
+{
+  return e.idx;
+}
+
+template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
+inline typename property_map<BOOST_CSR_GRAPH_TYPE, vertex_all_t>::type
+get(vertex_all_t, BOOST_CSR_GRAPH_TYPE& g)
 {
   return g.get_vertex_bundle(get(vertex_index, g));
 }
 
 template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
-inline typename property_map<BOOST_CSR_GRAPH_TYPE, vertex_bundle_t>::const_type
-get(vertex_bundle_t, const BOOST_CSR_GRAPH_TYPE& g)
+inline typename property_map<BOOST_CSR_GRAPH_TYPE, vertex_all_t>::const_type
+get(vertex_all_t, const BOOST_CSR_GRAPH_TYPE& g)
 {
   return g.get_vertex_bundle(get(vertex_index, g));
 }
 
 template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
 inline VertexProperty&
-get(vertex_bundle_t,
+get(vertex_all_t,
     BOOST_CSR_GRAPH_TYPE& g, Vertex v)
 {
-  return get(vertex_bundle, g)[v];
+  return get(vertex_all, g)[v];
 }
 
 template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
 inline const VertexProperty&
-get(vertex_bundle_t,
+get(vertex_all_t,
     const BOOST_CSR_GRAPH_TYPE& g, Vertex v)
 {
-  return get(vertex_bundle, g)[v];
+  return get(vertex_all, g)[v];
 }
 
 template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
 inline void
-put(vertex_bundle_t,
+put(vertex_all_t,
     BOOST_CSR_GRAPH_TYPE& g,
     Vertex v,
     const VertexProperty& val)
 {
-  put(get(vertex_bundle, g), v, val);
+  put(get(vertex_all, g), v, val);
 }
 
 template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
-inline typename property_map<BOOST_CSR_GRAPH_TYPE, edge_bundle_t>::type
-get(edge_bundle_t, BOOST_CSR_GRAPH_TYPE& g)
+inline typename property_map<BOOST_CSR_GRAPH_TYPE, edge_all_t>::type
+get(edge_all_t, BOOST_CSR_GRAPH_TYPE& g)
 {
   return g.m_forward.get_edge_bundle(get(edge_index, g));
 }
 
 template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
-inline typename property_map<BOOST_CSR_GRAPH_TYPE, edge_bundle_t>::const_type
-get(edge_bundle_t, const BOOST_CSR_GRAPH_TYPE& g)
+inline typename property_map<BOOST_CSR_GRAPH_TYPE, edge_all_t>::const_type
+get(edge_all_t, const BOOST_CSR_GRAPH_TYPE& g)
 {
   return g.m_forward.get_edge_bundle(get(edge_index, g));
 }
 
 template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
 inline EdgeProperty&
-get(edge_bundle_t,
+get(edge_all_t,
     BOOST_CSR_GRAPH_TYPE& g,
     const typename BOOST_CSR_GRAPH_TYPE::edge_descriptor& e)
 {
-  return get(edge_bundle, g)[e];
+  return get(edge_all, g)[e];
 }
 
 template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
 inline const EdgeProperty&
-get(edge_bundle_t,
+get(edge_all_t,
     const BOOST_CSR_GRAPH_TYPE& g,
     const typename BOOST_CSR_GRAPH_TYPE::edge_descriptor& e)
 {
-  return get(edge_bundle, g)[e];
+  return get(edge_all, g)[e];
 }
 
 template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
 inline void
-put(edge_bundle_t,
+put(edge_all_t,
     BOOST_CSR_GRAPH_TYPE& g,
     const typename BOOST_CSR_GRAPH_TYPE::edge_descriptor& e,
     const EdgeProperty& val)
 {
-  put(get(edge_bundle, g), e, val);
+  put(get(edge_all, g), e, val);
 }
 
-template<BOOST_CSR_GRAPH_TEMPLATE_PARMS, typename T, typename Bundle>
-inline
-typename property_map<BOOST_CSR_GRAPH_TYPE, T Bundle::*>::type
-get(T Bundle::* p, BOOST_CSR_GRAPH_TYPE& g)
+template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
+inline typename property_map<BOOST_CSR_GRAPH_TYPE, graph_all_t>::type
+get(graph_all_t, BOOST_CSR_GRAPH_TYPE& g)
 {
-  typedef typename property_map<BOOST_CSR_GRAPH_TYPE,
-                                T Bundle::*>::type
-    result_type;
-  return result_type(&g, p);
+  return typename property_map<BOOST_CSR_GRAPH_TYPE, graph_all_t>::type(g.m_property);
 }
 
-template<BOOST_CSR_GRAPH_TEMPLATE_PARMS, typename T, typename Bundle>
-inline
-typename property_map<BOOST_CSR_GRAPH_TYPE, T Bundle::*>::const_type
-get(T Bundle::* p, BOOST_CSR_GRAPH_TYPE const & g)
+template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
+inline typename property_map<BOOST_CSR_GRAPH_TYPE, graph_all_t>::const_type
+get(graph_all_t, const BOOST_CSR_GRAPH_TYPE& g)
 {
-  typedef typename property_map<BOOST_CSR_GRAPH_TYPE,
-                                T Bundle::*>::const_type
-    result_type;
-  return result_type(&g, p);
+  return typename property_map<BOOST_CSR_GRAPH_TYPE, graph_all_t>::const_type(g.m_property);
 }
 
-template<BOOST_CSR_GRAPH_TEMPLATE_PARMS, typename T, typename Bundle,
-         typename Key>
-inline T
-get(T Bundle::* p, BOOST_CSR_GRAPH_TYPE const & g,
-    const Key& key)
+template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
+inline GraphProperty&
+get(graph_all_t,
+    BOOST_CSR_GRAPH_TYPE& g,
+    BOOST_CSR_GRAPH_TYPE*)
 {
-  return get(get(p, g), key);
+  return g.m_property;
 }
 
-template<BOOST_CSR_GRAPH_TEMPLATE_PARMS, typename T, typename Bundle,
-         typename Key>
+template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
+inline const GraphProperty&
+get(graph_all_t,
+    const BOOST_CSR_GRAPH_TYPE& g,
+    BOOST_CSR_GRAPH_TYPE*)
+{
+  return g.m_property;
+}
+
+template<BOOST_CSR_GRAPH_TEMPLATE_PARMS>
 inline void
-put(T Bundle::* p, BOOST_CSR_GRAPH_TYPE& g,
-    const Key& key, const T& value)
+put(graph_all_t,
+    BOOST_CSR_GRAPH_TYPE& g,
+    BOOST_CSR_GRAPH_TYPE*,
+    const GraphProperty& val)
 {
-  put(get(p, g), key, value);
+  g.m_property = val;
 }
 
 #undef BOOST_CSR_GRAPH_TYPE
diff --git a/include/boost/graph/connected_components.hpp b/include/boost/graph/connected_components.hpp
index 90015e670..9279110f1 100644
--- a/include/boost/graph/connected_components.hpp
+++ b/include/boost/graph/connected_components.hpp
@@ -17,6 +17,7 @@
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/overloading.hpp>
 #include <boost/static_assert.hpp>
+#include <boost/concept/assert.hpp>
 
 namespace boost {
 
@@ -64,7 +65,7 @@ namespace boost {
     if (num_vertices(g) == 0) return 0;
 
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
-    function_requires< WritablePropertyMapConcept<ComponentMap, Vertex> >();
+    BOOST_CONCEPT_ASSERT(( WritablePropertyMapConcept<ComponentMap, Vertex> ));
     typedef typename boost::graph_traits<Graph>::directed_category directed;
     BOOST_STATIC_ASSERT((boost::is_same<directed, undirected_tag>::value));
 
@@ -84,8 +85,8 @@ namespace boost {
     if (num_vertices(g) == 0) return 0;
 
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
-    function_requires< WritablePropertyMapConcept<ComponentMap, Vertex> >();
-    typedef typename boost::graph_traits<Graph>::directed_category directed;
+    BOOST_CONCEPT_ASSERT(( WritablePropertyMapConcept<ComponentMap, Vertex> ));
+    // typedef typename boost::graph_traits<Graph>::directed_category directed;
     // BOOST_STATIC_ASSERT((boost::is_same<directed, undirected_tag>::value));
 
     typedef typename property_traits<ComponentMap>::value_type comp_type;
diff --git a/include/boost/graph/copy.hpp b/include/boost/graph/copy.hpp
index 402e75f24..21bb0fb01 100644
--- a/include/boost/graph/copy.hpp
+++ b/include/boost/graph/copy.hpp
@@ -44,6 +44,7 @@
 #include <boost/config.hpp>
 #include <vector>
 #include <boost/graph/graph_traits.hpp>
+#include <boost/graph/reverse_graph.hpp>
 #include <boost/property_map/property_map.hpp>
 #include <boost/graph/named_function_params.hpp>
 #include <boost/graph/breadth_first_search.hpp>
@@ -53,6 +54,48 @@ namespace boost {
 
   namespace detail {
 
+    // Hack to make transpose_graph work with the same interface as before
+    template <typename Graph, typename Desc>
+    struct remove_reverse_edge_descriptor {
+      typedef Desc type;
+      static Desc convert(const Desc& d, const Graph&) {return d;}
+    };
+
+    template <typename Graph, typename Desc>
+    struct remove_reverse_edge_descriptor<Graph, reverse_graph_edge_descriptor<Desc> > {
+      typedef Desc type;
+      static Desc convert(const reverse_graph_edge_descriptor<Desc>& d, const Graph& g) {
+        return get(edge_underlying, g, d);
+      }
+    };
+
+    // Add a reverse_graph_edge_descriptor wrapper if the Graph is a
+    // reverse_graph but the edge descriptor is from the original graph (this
+    // case comes from the fact that transpose_graph uses reverse_graph
+    // internally but doesn't expose the different edge descriptor type to the
+    // user).
+    template <typename Desc, typename Graph>
+    struct add_reverse_edge_descriptor {
+      typedef Desc type;
+      static Desc convert(const Desc& d) {return d;}
+    };
+
+    template <typename Desc, typename G, typename GR>
+    struct add_reverse_edge_descriptor<Desc, boost::reverse_graph<G, GR> > {
+      typedef reverse_graph_edge_descriptor<Desc> type;
+      static reverse_graph_edge_descriptor<Desc> convert(const Desc& d) {
+        return reverse_graph_edge_descriptor<Desc>(d);
+      }
+    };
+
+    template <typename Desc, typename G, typename GR>
+    struct add_reverse_edge_descriptor<reverse_graph_edge_descriptor<Desc>, boost::reverse_graph<G, GR> > {
+      typedef reverse_graph_edge_descriptor<Desc> type;
+      static reverse_graph_edge_descriptor<Desc> convert(const reverse_graph_edge_descriptor<Desc>& d) {
+        return d;
+      }
+    };
+
     // Default edge and vertex property copiers
 
     template <typename Graph1, typename Graph2>
@@ -63,7 +106,7 @@ namespace boost {
 
       template <typename Edge1, typename Edge2>
       void operator()(const Edge1& e1, Edge2& e2) const {
-        put(edge_all_map2, e2, get(edge_all_map1, e1));
+        put(edge_all_map2, e2, get(edge_all_map1, add_reverse_edge_descriptor<Edge1, Graph1>::convert(e1)));
       }
       typename property_map<Graph1, edge_all_t>::const_type edge_all_map1;
       mutable typename property_map<Graph2, edge_all_t>::type edge_all_map2;
@@ -112,6 +155,7 @@ namespace boost {
                         CopyVertex copy_vertex, CopyEdge copy_edge,
                         Orig2CopyVertexIndexMap orig2copy, IndexMap)
       {
+        typedef remove_reverse_edge_descriptor<Graph, typename graph_traits<Graph>::edge_descriptor> cvt;
         typename graph_traits<Graph>::vertex_iterator vi, vi_end;
         for (boost::tie(vi, vi_end) = vertices(g_in); vi != vi_end; ++vi) {
           typename graph_traits<MutableGraph>::vertex_descriptor
@@ -126,7 +170,7 @@ namespace boost {
           boost::tie(new_e, inserted) = add_edge(get(orig2copy, source(*ei, g_in)), 
                                                  get(orig2copy, target(*ei, g_in)),
                                                  g_out);
-          copy_edge(*ei, new_e);
+          copy_edge(cvt::convert(*ei, g_in), new_e);
         }
       }
     };
@@ -141,6 +185,7 @@ namespace boost {
                         CopyVertex copy_vertex, CopyEdge copy_edge,
                         Orig2CopyVertexIndexMap orig2copy, IndexMap)
       {
+        typedef remove_reverse_edge_descriptor<Graph, typename graph_traits<Graph>::edge_descriptor> cvt;
         typename graph_traits<Graph>::vertex_iterator vi, vi_end;
         for (boost::tie(vi, vi_end) = vertices(g_in); vi != vi_end; ++vi) {
           typename graph_traits<MutableGraph>::vertex_descriptor
@@ -156,7 +201,7 @@ namespace boost {
             boost::tie(new_e, inserted) = add_edge(get(orig2copy, source(*ei, g_in)), 
                                                    get(orig2copy, target(*ei, g_in)),
                                                    g_out);
-            copy_edge(*ei, new_e);
+            copy_edge(cvt::convert(*ei, g_in), new_e);
           }
         }
       }
@@ -173,6 +218,7 @@ namespace boost {
                         Orig2CopyVertexIndexMap orig2copy,
                         IndexMap index_map)
       {
+        typedef remove_reverse_edge_descriptor<Graph, typename graph_traits<Graph>::edge_descriptor> cvt;
         typedef color_traits<default_color_type> Color;
         std::vector<default_color_type> 
           color(num_vertices(g_in), Color::white());
@@ -192,7 +238,7 @@ namespace boost {
               boost::tie(new_e, inserted) = add_edge(get(orig2copy, source(*ei,g_in)),
                                                      get(orig2copy, target(*ei,g_in)),
                                                      g_out);
-              copy_edge(*ei, new_e);
+              copy_edge(cvt::convert(*ei, g_in), new_e);
             }
           }
           color[get(index_map, *vi)] = Color::black();
@@ -234,7 +280,7 @@ namespace boost {
       typedef choose_copier_parameter type;
     };
     template <>
-    struct choose_edge_copy<detail::error_property_not_found> {
+    struct choose_edge_copy<param_not_found> {
       typedef choose_default_edge_copier type;
     };
     template <class Param, class G1, class G2>
@@ -268,7 +314,7 @@ namespace boost {
       typedef choose_copier_parameter type;
     };
     template <>
-    struct choose_vertex_copy<detail::error_property_not_found> {
+    struct choose_vertex_copy<param_not_found> {
       typedef choose_default_vertex_copier type;
     };
     template <class Param, class G1, class G2>
@@ -350,15 +396,28 @@ namespace boost {
         : g_out(graph), orig2copy(c), copy_vertex(cv), copy_edge(ce) { }
 
       template <class Vertex, class Graph>
-      void examine_vertex(Vertex u, const Graph& g_in) const {
+      typename graph_traits<NewGraph>::vertex_descriptor copy_one_vertex(Vertex u) const {
         typename graph_traits<NewGraph>::vertex_descriptor
           new_u = add_vertex(g_out);
         put(orig2copy, u, new_u);
         copy_vertex(u, new_u);
+        return new_u;
+      }
+      
+      template <class Edge, class Graph>
+      void tree_edge(Edge e, const Graph& g_in) const {
+        // For a tree edge, the target vertex has not been copied yet.
+        typename graph_traits<NewGraph>::edge_descriptor new_e;
+        bool inserted;
+        boost::tie(new_e, inserted) = add_edge(get(orig2copy, source(e, g_in)), 
+                                               this->copy_one_vertex(target(e, g_in)),
+                                               g_out);
+        copy_edge(e, new_e);
       }
       
       template <class Edge, class Graph>
-      void examine_edge(Edge e, const Graph& g_in) const {
+      void non_tree_edge(Edge e, const Graph& g_in) const {
+        // For a non-tree edge, the target vertex has already been copied.
         typename graph_traits<NewGraph>::edge_descriptor new_e;
         bool inserted;
         boost::tie(new_e, inserted) = add_edge(get(orig2copy, source(e, g_in)), 
@@ -387,8 +446,10 @@ namespace boost {
     {
       graph_copy_visitor<MutableGraph, Orig2CopyVertexIndexMap, 
         CopyVertex, CopyEdge> vis(g_out, orig2copy, copy_vertex, copy_edge);
+      typename graph_traits<MutableGraph>::vertex_descriptor src_copy
+        = vis.copy_one_vertex(src);
       breadth_first_search(g_in, src, params.visitor(vis));
-      return get(orig2copy, src);
+      return src_copy;
     }
 
   } // namespace detail
diff --git a/include/boost/graph/core_numbers.hpp b/include/boost/graph/core_numbers.hpp
index 7ef08261c..9384f5d66 100644
--- a/include/boost/graph/core_numbers.hpp
+++ b/include/boost/graph/core_numbers.hpp
@@ -11,10 +11,10 @@
 #ifndef BOOST_GRAPH_CORE_NUMBERS_HPP
 #define BOOST_GRAPH_CORE_NUMBERS_HPP
 
-#include <boost/pending/mutable_queue.hpp>
-#include <boost/pending/indirect_cmp.hpp>
+#include <boost/graph/detail/d_ary_heap.hpp>
 #include <boost/graph/breadth_first_search.hpp>
 #include <boost/iterator/reverse_iterator.hpp>
+#include <boost/concept/assert.hpp>
 
 /*
  * core_numbers
@@ -46,7 +46,7 @@ namespace boost {
     struct CoreNumbersVisitorConcept {
         void constraints()
         {
-            function_requires< CopyConstructibleConcept<Visitor> >();
+            BOOST_CONCEPT_ASSERT(( CopyConstructibleConcept<Visitor> ));
             vis.examine_vertex(u,g);
             vis.finish_vertex(u,g);
             vis.examine_edge(e,g);
@@ -158,7 +158,8 @@ namespace boost {
                     if (get(c,u) > v_cn) {
                         // remove the edge
                         put(c,u,get(c,u)-get(wm,*oi));
-                        Q.update(u);
+                        if (Q.contains(u))
+                          Q.update(u);
                     }
                 }
                 vis.finish_vertex(v,g);
@@ -174,13 +175,14 @@ namespace boost {
         {
             typedef typename property_traits<CoreMap>::value_type D;
             typedef std::less<D> Cmp;
-            typedef indirect_cmp<CoreMap,Cmp > IndirectCmp;
-            IndirectCmp icmp(c, Cmp());
             // build the mutable queue
             typedef typename graph_traits<Graph>::vertex_descriptor vertex;
-            typedef mutable_queue<vertex, std::vector<vertex>, IndirectCmp,
-                IndexMap> MutableQueue;
-            MutableQueue Q(num_vertices(g), icmp, im);
+            std::vector<std::size_t> index_in_heap_data(num_vertices(g));
+            typedef iterator_property_map<std::vector<std::size_t>::iterator, IndexMap>
+              index_in_heap_map_type;
+            index_in_heap_map_type index_in_heap_map(index_in_heap_data.begin(), im);
+            typedef d_ary_heap_indirect<vertex, 4, index_in_heap_map_type, CoreMap, Cmp> MutableQueue;
+            MutableQueue Q(c, index_in_heap_map, Cmp());
             typename graph_traits<Graph>::vertex_iterator vi,vi_end;
             for (boost::tie(vi,vi_end) = vertices(g); vi!=vi_end; ++vi) {
                 Q.push(*vi);
@@ -314,7 +316,6 @@ namespace boost {
     core_numbers(Graph& g, CoreMap c, EdgeWeightMap wm, VertexIndexMap vim,
         CoreNumVisitor vis)
     {
-        typedef typename graph_traits<Graph>::vertices_size_type size_type;
         detail::compute_in_degree_map(g,c,wm);
         return detail::core_numbers_dispatch(g,c,wm,vim,vis);
     }
diff --git a/include/boost/graph/cuthill_mckee_ordering.hpp b/include/boost/graph/cuthill_mckee_ordering.hpp
index 52dc982a1..e16595c6c 100644
--- a/include/boost/graph/cuthill_mckee_ordering.hpp
+++ b/include/boost/graph/cuthill_mckee_ordering.hpp
@@ -75,7 +75,6 @@ namespace boost {
   {
 
     //create queue, visitor...don't forget namespaces!
-    typedef typename property_traits<DegreeMap>::value_type ds_type;
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
     typedef typename boost::sparse::sparse_ordering_queue<Vertex> queue;
     typedef typename detail::bfs_rcm_visitor<OutputIterator, queue, DegreeMap> Visitor;
@@ -137,7 +136,6 @@ namespace boost {
       return permutation;
 
     typedef typename boost::graph_traits<Graph>::vertex_descriptor Vertex;
-    typedef typename boost::graph_traits<Graph>::vertex_iterator   VerIter;
     typedef typename property_traits<ColorMap>::value_type ColorValue;
     typedef color_traits<ColorValue> Color;
 
@@ -172,7 +170,6 @@ namespace boost {
     if (boost::graph::has_no_vertices(G))
       return permutation;
     
-    typedef out_degree_property_map<Graph> DegreeMap;
     std::vector<default_color_type> colors(num_vertices(G));
     return cuthill_mckee_ordering(G, permutation, 
                                   make_iterator_property_map(&colors[0], 
diff --git a/include/boost/graph/cycle_canceling.hpp b/include/boost/graph/cycle_canceling.hpp
new file mode 100644
index 000000000..46a4b864c
--- /dev/null
+++ b/include/boost/graph/cycle_canceling.hpp
@@ -0,0 +1,181 @@
+//=======================================================================
+// Copyright 2013 University of Warsaw.
+// Authors: Piotr Wygocki 
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//=======================================================================
+//
+//
+//This algorithm is described in "Network Flows: Theory, Algorithms, and Applications"
+// by Ahuja, Magnanti, Orlin.
+
+#ifndef BOOST_GRAPH_CYCLE_CANCELING_HPP
+#define BOOST_GRAPH_CYCLE_CANCELING_HPP 
+
+#include <numeric>
+
+#include <boost/property_map/property_map.hpp>
+#include <boost/graph/graph_traits.hpp>
+#include <boost/graph/graph_concepts.hpp>
+#include <boost/pending/indirect_cmp.hpp>
+#include <boost/pending/relaxed_heap.hpp>
+#include <boost/graph/bellman_ford_shortest_paths.hpp>
+#include <boost/graph/iteration_macros.hpp>
+#include <boost/graph/detail/augment.hpp>
+#include <boost/graph/find_flow_cost.hpp>
+
+namespace boost {
+
+
+namespace detail {
+
+template <typename PredEdgeMap, typename Vertex>
+class RecordEdgeMapAndCycleVertex 
+    : public bellman_visitor<edge_predecessor_recorder<PredEdgeMap, on_edge_relaxed> > {
+        typedef edge_predecessor_recorder<PredEdgeMap, on_edge_relaxed> PredRec;
+public:
+    RecordEdgeMapAndCycleVertex(PredEdgeMap pred, Vertex & v) : 
+        bellman_visitor<PredRec>(PredRec(pred)), m_v(v), m_pred(pred) {}
+
+    template <typename Graph, typename Edge>
+    void edge_not_minimized(Edge e, const Graph & g) const {
+        typename graph_traits<Graph>::vertices_size_type n = num_vertices(g) + 1;
+
+        //edge e is not minimized but does not have to be on the negative weight cycle
+        //to find vertex on negative wieight cycle we move n+1 times backword in the PredEdgeMap graph.
+        while(n > 0) {
+            e = get(m_pred, source(e, g));
+            --n;
+        }
+        m_v = source(e, g);
+    }
+private:
+    Vertex & m_v;
+    PredEdgeMap m_pred;
+};
+
+} //detail
+
+
+template <class Graph, class Pred, class Distance, class Reversed, class ResidualCapacity, class Weight>
+void cycle_canceling(const Graph &g, Weight weight, Reversed rev, ResidualCapacity residual_capacity, Pred pred, Distance distance) {
+    typedef filtered_graph<const Graph, is_residual_edge<ResidualCapacity> > ResGraph;
+    ResGraph gres = detail::residual_graph(g, residual_capacity);
+    
+    typedef graph_traits<ResGraph> ResGTraits;
+    typedef graph_traits<Graph> GTraits;
+    typedef typename ResGTraits::edge_descriptor edge_descriptor;
+    typedef typename ResGTraits::vertex_descriptor vertex_descriptor;
+    
+    typename GTraits::vertices_size_type N = num_vertices(g);
+    
+    BGL_FORALL_VERTICES_T(v, g, Graph) {
+        put(pred, v, edge_descriptor());
+        put(distance, v, 0);
+    }
+
+    vertex_descriptor cycleStart;
+    while(!bellman_ford_shortest_paths(gres, N, 
+            weight_map(weight).
+            distance_map(distance).
+            visitor(detail::RecordEdgeMapAndCycleVertex<Pred, vertex_descriptor>(pred, cycleStart)))) {
+
+        detail::augment(g, cycleStart, cycleStart, pred, residual_capacity, rev);
+        
+        BGL_FORALL_VERTICES_T(v, g, Graph) {
+            put(pred, v, edge_descriptor());
+            put(distance, v, 0);
+        }
+    }
+}
+
+
+//in this namespace argument dispatching takes place
+namespace detail {
+
+template <class Graph, class P, class T, class R, class ResidualCapacity, class Weight, class Reversed, class Pred, class Distance>
+void cycle_canceling_dispatch2(
+        const Graph &g, 
+        Weight weight,
+        Reversed rev,
+        ResidualCapacity residual_capacity,
+        Pred pred,
+        Distance dist,
+        const bgl_named_params<P, T, R>& params) {
+    cycle_canceling(g, weight, rev, residual_capacity, pred, dist);
+}
+
+//setting default distance map
+template <class Graph, class P, class T, class R, class Pred, class ResidualCapacity, class Weight, class Reversed>
+void cycle_canceling_dispatch2(
+        Graph &g, 
+        Weight weight,
+        Reversed rev,
+        ResidualCapacity residual_capacity,
+        Pred pred,
+        param_not_found,
+        const bgl_named_params<P, T, R>& params) {
+    typedef typename property_traits<Weight>::value_type D;
+
+    std::vector<D> d_map(num_vertices(g));
+
+    cycle_canceling(g, weight, rev, residual_capacity, pred, 
+                    make_iterator_property_map(d_map.begin(), choose_const_pmap(get_param(params, vertex_index), g, vertex_index)));
+}
+
+template <class Graph, class P, class T, class R, class ResidualCapacity, class Weight, class Reversed, class Pred>
+void cycle_canceling_dispatch1(
+        Graph &g, 
+        Weight weight, 
+        Reversed rev,
+        ResidualCapacity residual_capacity,
+        Pred pred,
+        const bgl_named_params<P, T, R>& params) {
+    cycle_canceling_dispatch2(g, weight, rev,residual_capacity,  pred, 
+                                get_param(params, vertex_distance), params);
+}
+
+//setting default predecessors map
+template <class Graph, class P, class T, class R, class ResidualCapacity, class Weight, class Reversed>
+void cycle_canceling_dispatch1(
+        Graph &g, 
+        Weight weight, 
+        Reversed rev,
+        ResidualCapacity residual_capacity,
+        param_not_found,
+        const bgl_named_params<P, T, R>& params) {
+    typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor;
+    std::vector<edge_descriptor> p_map(num_vertices(g));
+
+    cycle_canceling_dispatch2(g, weight, rev, residual_capacity,
+                              make_iterator_property_map(p_map.begin(), choose_const_pmap(get_param(params, vertex_index), g, vertex_index)),
+                                get_param(params, vertex_distance), params); 
+}
+
+}//detail
+
+template <class Graph, class  P, class T, class R>
+void cycle_canceling(Graph &g,
+        const bgl_named_params<P, T, R>& params) {
+    cycle_canceling_dispatch1(g, 
+           choose_const_pmap(get_param(params, edge_weight), g, edge_weight),
+           choose_const_pmap(get_param(params, edge_reverse), g, edge_reverse),
+           choose_pmap(get_param(params, edge_residual_capacity), 
+                       g, edge_residual_capacity),
+           get_param(params, vertex_predecessor), 
+           params);
+}
+
+template <class Graph>
+void cycle_canceling(Graph &g) {
+    bgl_named_params<int, buffer_param_t> params(0);
+    cycle_canceling(g, params);
+}
+
+
+}
+
+#endif /* BOOST_GRAPH_CYCLE_CANCELING_HPP */
+
diff --git a/include/boost/graph/dag_shortest_paths.hpp b/include/boost/graph/dag_shortest_paths.hpp
index a46de9145..325d1516c 100644
--- a/include/boost/graph/dag_shortest_paths.hpp
+++ b/include/boost/graph/dag_shortest_paths.hpp
@@ -88,14 +88,16 @@ namespace boost {
     {
       typedef typename property_traits<DistanceMap>::value_type D;
       dummy_property_map p_map;
+      D inf =
+        choose_param(get_param(params, distance_inf_t()), 
+                     (std::numeric_limits<D>::max)());
       dag_shortest_paths
         (g, s, distance, weight, color, 
          choose_param(get_param(params, vertex_predecessor), p_map),
          vis, 
          choose_param(get_param(params, distance_compare_t()), std::less<D>()),
-         choose_param(get_param(params, distance_combine_t()), closed_plus<D>()),
-         choose_param(get_param(params, distance_inf_t()), 
-                      (std::numeric_limits<D>::max)()),
+         choose_param(get_param(params, distance_combine_t()), closed_plus<D>(inf)),
+         inf,
          choose_param(get_param(params, distance_zero_t()), 
                       D()));
     }
diff --git a/include/boost/graph/degree_centrality.hpp b/include/boost/graph/degree_centrality.hpp
index 24ecb6c51..f6cc7a22f 100644
--- a/include/boost/graph/degree_centrality.hpp
+++ b/include/boost/graph/degree_centrality.hpp
@@ -8,6 +8,7 @@
 #define BOOST_GRAPH_DEGREE_CENTRALITY_HPP
 
 #include <boost/graph/graph_concepts.hpp>
+#include <boost/concept/assert.hpp>
 
 namespace boost {
 
@@ -28,7 +29,7 @@ struct influence_measure
 
     inline degree_type operator ()(vertex_type v, const Graph& g)
     {
-        function_requires< IncidenceGraphConcept<Graph> >();
+        BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
         return out_degree(v, g);
     }
 };
@@ -49,7 +50,7 @@ struct prestige_measure
 
     inline degree_type operator ()(vertex_type v, const Graph& g)
     {
-        function_requires< BidirectionalGraphConcept<Graph> >();
+        BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph> ));
         return in_degree(v, g);
     }
 };
@@ -64,7 +65,7 @@ template <typename Graph, typename Vertex, typename Measure>
 inline typename Measure::degree_type
 degree_centrality(const Graph& g, Vertex v, Measure measure)
 {
-    function_requires< DegreeMeasureConcept<Measure, Graph> >();
+    BOOST_CONCEPT_ASSERT(( DegreeMeasureConcept<Measure, Graph> ));
     return measure(v, g);
 }
 
@@ -94,14 +95,14 @@ template <typename Graph, typename CentralityMap, typename Measure>
 inline void
 all_degree_centralities(const Graph& g, CentralityMap cent, Measure measure)
 {
-    function_requires< VertexListGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
     typedef typename graph_traits<Graph>::vertex_iterator VertexIterator;
-    function_requires< WritablePropertyMapConcept<CentralityMap,Vertex> >();
+    BOOST_CONCEPT_ASSERT(( WritablePropertyMapConcept<CentralityMap,Vertex> ));
     typedef typename property_traits<CentralityMap>::value_type Centrality;
 
     VertexIterator i, end;
-    for(tie(i, end) = vertices(g); i != end; ++i) {
+    for(boost::tie(i, end) = vertices(g); i != end; ++i) {
         Centrality c = degree_centrality(g, *i, measure);
         put(cent, *i, c);
     }
diff --git a/include/boost/graph/depth_first_search.hpp b/include/boost/graph/depth_first_search.hpp
index 74fe2c029..b002d3674 100644
--- a/include/boost/graph/depth_first_search.hpp
+++ b/include/boost/graph/depth_first_search.hpp
@@ -21,6 +21,10 @@
 #include <boost/graph/named_function_params.hpp>
 #include <boost/ref.hpp>
 #include <boost/implicit_cast.hpp>
+#include <boost/optional.hpp>
+#include <boost/parameter.hpp>
+#include <boost/concept/assert.hpp>
+#include <boost/tti/has_member_function.hpp>
 
 #include <vector>
 #include <utility>
@@ -31,7 +35,7 @@ namespace boost {
   class DFSVisitorConcept {
   public:
     void constraints() {
-      function_requires< CopyConstructibleConcept<Visitor> >();
+      BOOST_CONCEPT_ASSERT(( CopyConstructibleConcept<Visitor> ));
       vis.initialize_vertex(u, g);
       vis.start_vertex(u, g);
       vis.discover_vertex(u, g);
@@ -39,6 +43,7 @@ namespace boost {
       vis.tree_edge(e, g);
       vis.back_edge(e, g);
       vis.forward_or_cross_edge(e, g);
+      // vis.finish_edge(e, g); // Optional for user
       vis.finish_vertex(u, g);
     }
   private:
@@ -55,6 +60,25 @@ namespace boost {
       bool operator()(const T&, const T2&) const { return false; }
     };
 
+    BOOST_TTI_HAS_MEMBER_FUNCTION(finish_edge)
+
+    template <bool IsCallable> struct do_call_finish_edge {
+      template <typename E, typename G, typename Vis>
+      static void call_finish_edge(Vis& vis, const E& e, const G& g) {
+        vis.finish_edge(e, g);
+      }
+    };
+
+    template <> struct do_call_finish_edge<false> {
+      template <typename E, typename G, typename Vis>
+      static void call_finish_edge(Vis&, const E&, const G&) {}
+    };
+
+    template <typename E, typename G, typename Vis>
+    void call_finish_edge(Vis& vis, const E& e, const G& g) { // Only call if method exists
+      do_call_finish_edge<has_member_function_finish_edge<Vis, void>::value>::call_finish_edge(vis, e, g);
+    }
+
 
 // Define BOOST_RECURSIVE_DFS to use older, recursive version.
 // It is retained for a while in order to perform performance
@@ -80,39 +104,38 @@ namespace boost {
        DFSVisitor& vis,
        ColorMap color, TerminatorFunc func = TerminatorFunc())
     {
-      function_requires<IncidenceGraphConcept<IncidenceGraph> >();
-      function_requires<DFSVisitorConcept<DFSVisitor, IncidenceGraph> >();
+      BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<IncidenceGraph> ));
+      BOOST_CONCEPT_ASSERT(( DFSVisitorConcept<DFSVisitor, IncidenceGraph> ));
       typedef typename graph_traits<IncidenceGraph>::vertex_descriptor Vertex;
-      function_requires< ReadWritePropertyMapConcept<ColorMap, Vertex> >();
+      typedef typename graph_traits<IncidenceGraph>::edge_descriptor Edge;
+      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<ColorMap, Vertex> ));
       typedef typename property_traits<ColorMap>::value_type ColorValue;
-      function_requires< ColorValueConcept<ColorValue> >();
+      BOOST_CONCEPT_ASSERT(( ColorValueConcept<ColorValue> ));
       typedef color_traits<ColorValue> Color;
       typedef typename graph_traits<IncidenceGraph>::out_edge_iterator Iter;
-      typedef std::pair<Vertex, std::pair<Iter, Iter> > VertexInfo;
+      typedef std::pair<Vertex, std::pair<boost::optional<Edge>, std::pair<Iter, Iter> > > VertexInfo;
 
+      boost::optional<Edge> src_e;
       Iter ei, ei_end;
       std::vector<VertexInfo> stack;
 
       // Possible optimization for vector
       //stack.reserve(num_vertices(g));
 
-      typedef typename unwrap_reference<TerminatorFunc>::type TF;
-
       put(color, u, Color::gray());
       vis.discover_vertex(u, g);
       boost::tie(ei, ei_end) = out_edges(u, g);
-      // Variable is needed to workaround a borland bug.
-      TF& fn = static_cast<TF&>(func);
-      if (fn(u, g)) {
+      if (func(u, g)) {
           // If this vertex terminates the search, we push empty range
-          stack.push_back(std::make_pair(u, std::make_pair(ei_end, ei_end)));
+          stack.push_back(std::make_pair(u, std::make_pair(boost::optional<Edge>(), std::make_pair(ei_end, ei_end))));
       } else {
-          stack.push_back(std::make_pair(u, std::make_pair(ei, ei_end)));
+          stack.push_back(std::make_pair(u, std::make_pair(boost::optional<Edge>(), std::make_pair(ei, ei_end))));
       }
       while (!stack.empty()) {
         VertexInfo& back = stack.back();
         u = back.first;
-        boost::tie(ei, ei_end) = back.second;
+        src_e = back.second.first;
+        boost::tie(ei, ei_end) = back.second.second;
         stack.pop_back();
         while (ei != ei_end) {
           Vertex v = target(*ei, g);
@@ -120,24 +143,28 @@ namespace boost {
           ColorValue v_color = get(color, v);
           if (v_color == Color::white()) {
             vis.tree_edge(*ei, g);
-            stack.push_back(std::make_pair(u, std::make_pair(++ei, ei_end)));
+            src_e = *ei;
+            stack.push_back(std::make_pair(u, std::make_pair(src_e, std::make_pair(++ei, ei_end))));
             u = v;
             put(color, u, Color::gray());
             vis.discover_vertex(u, g);
             boost::tie(ei, ei_end) = out_edges(u, g);
-            if (fn(u, g)) {
+            if (func(u, g)) {
                 ei = ei_end;
             }
-          } else if (v_color == Color::gray()) {
-            vis.back_edge(*ei, g);
-            ++ei;
           } else {
-            vis.forward_or_cross_edge(*ei, g);
+            if (v_color == Color::gray()) {
+              vis.back_edge(*ei, g);
+            } else {
+              vis.forward_or_cross_edge(*ei, g);
+            }
+            call_finish_edge(vis, *ei, g);
             ++ei;
           }
         }
         put(color, u, Color::black());
         vis.finish_vertex(u, g);
+        if (src_e) call_finish_edge(vis, src_e.get(), g);
       }
     }
 
@@ -151,21 +178,18 @@ namespace boost {
        DFSVisitor& vis,  // pass-by-reference here, important!
        ColorMap color, TerminatorFunc func)
     {
-      function_requires<IncidenceGraphConcept<IncidenceGraph> >();
-      function_requires<DFSVisitorConcept<DFSVisitor, IncidenceGraph> >();
+      BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<IncidenceGraph> ));
+      BOOST_CONCEPT_ASSERT(( DFSVisitorConcept<DFSVisitor, IncidenceGraph> ));
       typedef typename graph_traits<IncidenceGraph>::vertex_descriptor Vertex;
-      function_requires< ReadWritePropertyMapConcept<ColorMap, Vertex> >();
+      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<ColorMap, Vertex> ));
       typedef typename property_traits<ColorMap>::value_type ColorValue;
-      function_requires< ColorValueConcept<ColorValue> >();
+      BOOST_CONCEPT_ASSERT(( ColorValueConcept<ColorValue> ));
       typedef color_traits<ColorValue> Color;
       typename graph_traits<IncidenceGraph>::out_edge_iterator ei, ei_end;
 
       put(color, u, Color::gray());          vis.discover_vertex(u, g);
 
-      typedef typename unwrap_reference<TerminatorFunc>::type TF;
-      // Variable is needed to workaround a borland bug.
-      TF& fn = static_cast<TF&>(func);
-      if (!fn(u, g))
+      if (!func(u, g))
         for (boost::tie(ei, ei_end) = out_edges(u, g); ei != ei_end; ++ei) {
           Vertex v = target(*ei, g);           vis.examine_edge(*ei, g);
           ColorValue v_color = get(color, v);
@@ -173,6 +197,7 @@ namespace boost {
           depth_first_visit_impl(g, v, vis, color, func);
           } else if (v_color == Color::gray()) vis.back_edge(*ei, g);
           else                                 vis.forward_or_cross_edge(*ei, g);
+          call_finish_edge(vis, *ei, g);
         }
       put(color, u, Color::black());         vis.finish_vertex(u, g);
     }
@@ -187,7 +212,7 @@ namespace boost {
                      typename graph_traits<VertexListGraph>::vertex_descriptor start_vertex)
   {
     typedef typename graph_traits<VertexListGraph>::vertex_descriptor Vertex;
-    function_requires<DFSVisitorConcept<DFSVisitor, VertexListGraph> >();
+    BOOST_CONCEPT_ASSERT(( DFSVisitorConcept<DFSVisitor, VertexListGraph> ));
     typedef typename property_traits<ColorMap>::value_type ColorValue;
     typedef color_traits<ColorValue> Color;
 
@@ -197,7 +222,7 @@ namespace boost {
       put(color, u, Color::white()); vis.initialize_vertex(u, g);
     }
 
-    if (start_vertex != implicit_cast<Vertex>(*vertices(g).first)){ vis.start_vertex(start_vertex, g);
+    if (start_vertex != detail::get_default_starting_vertex(g)){ vis.start_vertex(start_vertex, g);
       detail::depth_first_visit_impl(g, start_vertex, vis, color,
                                      detail::nontruth2());
     }
@@ -220,7 +245,7 @@ namespace boost {
     if (verts.first == verts.second)
       return;
 
-    depth_first_search(g, vis, color, *verts.first);
+    depth_first_search(g, vis, color, detail::get_default_starting_vertex(g));
   }
 
   template <class Visitors = null_visitor>
@@ -257,6 +282,10 @@ namespace boost {
     void forward_or_cross_edge(Edge u, const Graph& g) {
       invoke_visitors(m_vis, u, g, ::boost::on_forward_or_cross_edge());
     }
+    template <class Edge, class Graph>
+    void finish_edge(Edge u, const Graph& g) {
+      invoke_visitors(m_vis, u, g, ::boost::on_finish_edge());
+    }
     template <class Vertex, class Graph>
     void finish_vertex(Vertex u, const Graph& g) {
       invoke_visitors(m_vis, u, g, ::boost::on_finish_vertex());
@@ -269,6 +298,7 @@ namespace boost {
     BOOST_GRAPH_EVENT_STUB(on_tree_edge,dfs)
     BOOST_GRAPH_EVENT_STUB(on_back_edge,dfs)
     BOOST_GRAPH_EVENT_STUB(on_forward_or_cross_edge,dfs)
+    BOOST_GRAPH_EVENT_STUB(on_finish_edge,dfs)
     BOOST_GRAPH_EVENT_STUB(on_finish_vertex,dfs)
 
   protected:
@@ -281,27 +311,27 @@ namespace boost {
   }
   typedef dfs_visitor<> default_dfs_visitor;
 
-  // Named Parameter Variant
-  template <class VertexListGraph, class P, class T, class R>
-  void
-  depth_first_search(const VertexListGraph& g,
-                     const bgl_named_params<P, T, R>& params)
-  {
-    typedef typename boost::graph_traits<VertexListGraph>::vertex_iterator vi;
-    std::pair<vi, vi> verts = vertices(g);
-    if (verts.first == verts.second)
-      return;
-    using namespace boost::graph::keywords;
-    typedef bgl_named_params<P, T, R> params_type;
-    BOOST_GRAPH_DECLARE_CONVERTED_PARAMETERS(params_type, params)
-    depth_first_search
-      (g,
-       arg_pack[_visitor | make_dfs_visitor(null_visitor())],
-       boost::detail::make_color_map_from_arg_pack(g, arg_pack),
-       arg_pack[_root_vertex | *vertices(g).first]
-      );
+  // Boost.Parameter named parameter variant
+  namespace graph {
+    namespace detail {
+      template <typename Graph>
+      struct depth_first_search_impl {
+        typedef void result_type;
+        template <typename ArgPack>
+        void operator()(const Graph& g, const ArgPack& arg_pack) const {
+          using namespace boost::graph::keywords;
+          boost::depth_first_search(g,
+                                    arg_pack[_visitor | make_dfs_visitor(null_visitor())],
+                                    boost::detail::make_color_map_from_arg_pack(g, arg_pack),
+                                    arg_pack[_root_vertex || boost::detail::get_default_starting_vertex_t<Graph>(g)]);
+        }
+      };
+    }
+    BOOST_GRAPH_MAKE_FORWARDING_FUNCTION(depth_first_search, 1, 4)
   }
 
+  BOOST_GRAPH_MAKE_OLD_STYLE_PARAMETER_FUNCTION(depth_first_search, 1)
+
   template <class IncidenceGraph, class DFSVisitor, class ColorMap>
   void depth_first_visit
     (const IncidenceGraph& g,
diff --git a/include/boost/graph/detail/adjacency_list.hpp b/include/boost/graph/detail/adjacency_list.hpp
index 0cbf5f4e9..9e6b623ee 100644
--- a/include/boost/graph/detail/adjacency_list.hpp
+++ b/include/boost/graph/detail/adjacency_list.hpp
@@ -17,6 +17,7 @@
 #include <boost/detail/workaround.hpp>
 #include <boost/operators.hpp>
 #include <boost/property_map/property_map.hpp>
+#include <boost/pending/container_traits.hpp>
 #include <boost/range/irange.hpp>
 #include <boost/graph/graph_traits.hpp>
 #include <memory>
@@ -35,11 +36,13 @@
 #include <boost/pending/property.hpp>
 #include <boost/graph/adjacency_iterator.hpp>
 #include <boost/static_assert.hpp>
+#include <boost/assert.hpp>
 
-// Symbol truncation problems with MSVC, trying to shorten names.
-#define stored_edge se_
-#define stored_edge_property sep_
-#define stored_edge_iter sei_
+#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
+#define BOOST_GRAPH_MOVE_IF_POSSIBLE(x) (x)
+#else
+#define BOOST_GRAPH_MOVE_IF_POSSIBLE(x) (std::move((x)))
+#endif
 
 /*
   Outline for this file:
@@ -66,11 +69,6 @@
  */
 
 
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-// Stay out of the way of the concept checking class
-# define Graph Graph_
-#endif
-
 namespace boost {
 
   namespace detail {
@@ -259,6 +257,7 @@ namespace boost {
     template <class Vertex>
     no_property stored_edge<Vertex>::s_prop;
 
+#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) || defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS)
     template <class Vertex, class Property>
     class stored_edge_property : public stored_edge<Vertex> {
       typedef stored_edge_property self;
@@ -285,6 +284,25 @@ namespace boost {
       // a perfect fit for the job, but it is darn close.
       std::auto_ptr<Property> m_property;
     };
+#else
+    template <class Vertex, class Property>
+    class stored_edge_property : public stored_edge<Vertex> {
+      typedef stored_edge_property self;
+      typedef stored_edge<Vertex> Base;
+    public:
+      typedef Property property_type;
+      inline stored_edge_property() { }
+      inline stored_edge_property(Vertex target,
+                                  const Property& p = Property())
+        : stored_edge<Vertex>(target), m_property(new Property(p)) { }
+      stored_edge_property(self&& x) = default;
+      self& operator=(self&& x) = default;
+      inline Property& get_property() { return *m_property; }
+      inline const Property& get_property() const { return *m_property; }
+    protected:
+      std::unique_ptr<Property> m_property;
+    };
+#endif
 
 
     template <class Vertex, class Iter, class Property>
@@ -318,14 +336,16 @@ namespace boost {
     public:
       typedef Property property_type;
       inline stored_ra_edge_iter() { }
-      inline stored_ra_edge_iter(Vertex v, Iter i = Iter(),
-                                 EdgeVec* edge_vec = 0)
+      inline explicit stored_ra_edge_iter(Vertex v) // Only used for comparisons
+        : stored_edge<Vertex>(v), m_i(0), m_vec(0){ }
+      inline stored_ra_edge_iter(Vertex v, Iter i, EdgeVec* edge_vec)
         : stored_edge<Vertex>(v), m_i(i - edge_vec->begin()), m_vec(edge_vec){ }
-      inline Property& get_property() { return (*m_vec)[m_i].get_property(); }
+      inline Property& get_property() { BOOST_ASSERT ((m_vec != 0)); return (*m_vec)[m_i].get_property(); }
       inline const Property& get_property() const {
+        BOOST_ASSERT ((m_vec != 0));
         return (*m_vec)[m_i].get_property();
       }
-      inline Iter get_iter() const { return m_vec->begin() + m_i; }
+      inline Iter get_iter() const { BOOST_ASSERT ((m_vec != 0)); return m_vec->begin() + m_i; }
     protected:
       std::size_t m_i;
       EdgeVec* m_vec;
@@ -390,7 +410,7 @@ namespace boost {
         if (first != last)
           for (++i; i != last; ++i)
             if (!pred(*i)) {
-              *first.base() = *i.base();
+              *first.base() = BOOST_GRAPH_MOVE_IF_POSSIBLE(*i.base());
               ++first;
             }
         el.erase(first.base(), el.end());
@@ -438,7 +458,7 @@ namespace boost {
               self_loop_removed = false;
             }
             else if (!pred(*i)) {
-              *first.base() = *i.base();
+              *first.base() = BOOST_GRAPH_MOVE_IF_POSSIBLE(*i.base());
               ++first;
             } else {
               if (source(*i, g) == target(*i, g)) self_loop_removed = true;
@@ -641,7 +661,6 @@ namespace boost {
                     directed_graph_helper<Config>& g_)
     {
       typedef typename Config::graph_type graph_type;
-      typedef typename Config::edge_parallel_category Cat;
       graph_type& g = static_cast<graph_type&>(g_);
       g.out_edge_list(u).clear();
       // clear() should be a req of Sequence and AssociativeContainer,
@@ -726,8 +745,10 @@ namespace boost {
 
           typename Config::OutEdgeList& out_el = g.out_edge_list(source(e, g));
           typename Config::OutEdgeList::iterator out_i = out_el.begin();
+          typename Config::EdgeIter edge_iter_to_erase;
           for (; out_i != out_el.end(); ++out_i)
             if (&(*out_i).get_property() == &p) {
+              edge_iter_to_erase = (*out_i).get_iter();
               out_el.erase(out_i);
               break;
             }
@@ -735,10 +756,10 @@ namespace boost {
           typename Config::OutEdgeList::iterator in_i = in_el.begin();
           for (; in_i != in_el.end(); ++in_i)
             if (&(*in_i).get_property() == &p) {
-              g.m_edges.erase((*in_i).get_iter());
               in_el.erase(in_i);
-              return;
+              break;
             }
+          g.m_edges.erase(edge_iter_to_erase);
         }
       };
 
@@ -759,8 +780,10 @@ namespace boost {
           no_property* p = (no_property*)e.get_property();
           typename Config::OutEdgeList& out_el = g.out_edge_list(source(e, g));
           typename Config::OutEdgeList::iterator out_i = out_el.begin();
+          typename Config::EdgeIter edge_iter_to_erase;
           for (; out_i != out_el.end(); ++out_i)
             if (&(*out_i).get_property() == p) {
+              edge_iter_to_erase = (*out_i).get_iter();
               out_el.erase(out_i);
               break;
             }
@@ -768,10 +791,10 @@ namespace boost {
           typename Config::OutEdgeList::iterator in_i = in_el.begin();
           for (; in_i != in_el.end(); ++in_i)
             if (&(*in_i).get_property() == p) {
-              g.m_edges.erase((*in_i).get_iter());
               in_el.erase(in_i);
-              return;
+              break;
             }
+          g.m_edges.erase(edge_iter_to_erase);
         }
       };
 
@@ -784,7 +807,6 @@ namespace boost {
         typedef typename Graph::global_edgelist_selector EdgeListS;
         BOOST_STATIC_ASSERT((!is_same<EdgeListS, vecS>::value));
 
-        typedef typename EdgeList::value_type StoredEdge;
         typename EdgeList::iterator i = el.begin(), end = el.end();
         for (; i != end; ++i) {
           if ((*i).get_target() == v) {
@@ -988,26 +1010,13 @@ namespace boost {
       BOOST_STATIC_ASSERT((!is_same<EdgeListS, vecS>::value));
 
       typedef typename Config::graph_type graph_type;
-      typedef typename Config::edge_parallel_category Cat;
       graph_type& g = static_cast<graph_type&>(g_);
-      typename Config::OutEdgeList& el = g.out_edge_list(u);
-      typename Config::OutEdgeList::iterator
-        ei = el.begin(), ei_end = el.end();
-      for (; ei != ei_end; /* Increment below */ ) {
-        bool is_self_loop = (*ei).get_target() == u;
-        // Don't erase from our own incidence list in the case of a self-loop
-        // since we're clearing it anyway.
-        if (!is_self_loop) {
-          detail::erase_from_incidence_list
-            (g.out_edge_list((*ei).get_target()), u, Cat());
-          typename Config::OutEdgeList::iterator ei_copy = ei;
-          ++ei;
-          if (!is_self_loop) g.m_edges.erase((*ei_copy).get_iter());
-        } else {
-          ++ei;
-        }
+      while (true) {
+        typename Config::out_edge_iterator ei, ei_end;
+        boost::tie(ei, ei_end) = out_edges(u, g);
+        if (ei == ei_end) break;
+        remove_edge(*ei, g);
       }
-      g.out_edge_list(u).clear();
     }
     // O(1) for allow_parallel_edge_tag
     // O(log(E/V)) for disallow_parallel_edge_tag
@@ -1216,7 +1225,7 @@ namespace boost {
         std::pair<out_edge_iterator, out_edge_iterator> rng =
           get_parallel_edge_sublist(e, g, (OutEdgeListS*)(0));
         rng.first = std::find(rng.first, rng.second, e);
-        assert(rng.first != rng.second);
+        BOOST_ASSERT(rng.first != rng.second);
         remove_edge(rng.first);
       }
 
@@ -1510,10 +1519,16 @@ namespace boost {
       typedef typename Config::edges_size_type edges_size_type;
       typedef typename Config::degree_size_type degree_size_type;
       typedef typename Config::StoredEdge StoredEdge;
+      typedef typename Config::vertex_property_type vertex_property_type;
       typedef typename Config::edge_property_type edge_property_type;
+      typedef typename Config::graph_property_type graph_property_type;
 
       typedef typename Config::global_edgelist_selector
         global_edgelist_selector;
+
+      typedef typename lookup_one_property<vertex_property_type, vertex_bundle_t>::type vertex_bundled;
+      typedef typename lookup_one_property<edge_property_type, edge_bundle_t>::type edge_bundled;
+      typedef typename lookup_one_property<graph_property_type, graph_bundle_t>::type graph_bundled;
     };
 
     template <class Config, class Base>
@@ -1596,7 +1611,6 @@ namespace boost {
       typedef typename Config::graph_type Graph;
       typedef typename Config::StoredEdge StoredEdge;
       const Graph& cg = static_cast<const Graph&>(g_);
-      typedef typename Config::out_edge_iterator out_edge_iterator;
       const typename Config::OutEdgeList& el = cg.out_edge_list(u);
       typename Config::OutEdgeList::const_iterator it = graph_detail::
         find(el, StoredEdge(v));
@@ -1622,8 +1636,7 @@ namespace boost {
       typename Config::OutEdgeList::iterator first, last;
       typename Config::EdgeContainer fake_edge_container;
       boost::tie(first, last) = graph_detail::
-        equal_range(el, StoredEdge(v, fake_edge_container.end(),
-                                   &fake_edge_container));
+        equal_range(el, StoredEdge(v));
       return std::make_pair(out_edge_iterator(first, u),
                             out_edge_iterator(last, u));
     }
@@ -1644,43 +1657,43 @@ namespace boost {
       inline
       typename boost::property_map<typename Config::graph_type,
         Property>::type
-      get_dispatch(adj_list_helper<Config,Base>&, Property,
+      get_dispatch(adj_list_helper<Config,Base>&, Property p,
                    boost::edge_property_tag) {
         typedef typename Config::graph_type Graph;
         typedef typename boost::property_map<Graph, Property>::type PA;
-        return PA();
+        return PA(p);
       }
       template <class Config, class Base, class Property>
       inline
       typename boost::property_map<typename Config::graph_type,
         Property>::const_type
-      get_dispatch(const adj_list_helper<Config,Base>&, Property,
+      get_dispatch(const adj_list_helper<Config,Base>&, Property p,
                    boost::edge_property_tag) {
         typedef typename Config::graph_type Graph;
         typedef typename boost::property_map<Graph, Property>::const_type PA;
-        return PA();
+        return PA(p);
       }
 
       template <class Config, class Base, class Property>
       inline
       typename boost::property_map<typename Config::graph_type,
         Property>::type
-      get_dispatch(adj_list_helper<Config,Base>& g, Property,
+      get_dispatch(adj_list_helper<Config,Base>& g, Property p,
                    boost::vertex_property_tag) {
         typedef typename Config::graph_type Graph;
         typedef typename boost::property_map<Graph, Property>::type PA;
-        return PA(&static_cast<Graph&>(g));
+        return PA(&static_cast<Graph&>(g), p);
       }
       template <class Config, class Base, class Property>
       inline
       typename boost::property_map<typename Config::graph_type,
         Property>::const_type
-      get_dispatch(const adj_list_helper<Config, Base>& g, Property,
+      get_dispatch(const adj_list_helper<Config, Base>& g, Property p,
                    boost::vertex_property_tag) {
         typedef typename Config::graph_type Graph;
         typedef typename boost::property_map<Graph, Property>::const_type PA;
         const Graph& cg = static_cast<const Graph&>(g);
-        return PA(&cg);
+        return PA(&cg, p);
       }
 
     } // namespace detail
@@ -1690,7 +1703,7 @@ namespace boost {
     inline
     typename boost::property_map<typename Config::graph_type, Property>::type
     get(Property p, adj_list_helper<Config, Base>& g) {
-      typedef typename property_kind<Property>::type Kind;
+      typedef typename detail::property_kind_from_graph<adj_list_helper<Config, Base>, Property>::type Kind;
       return detail::get_dispatch(g, p, Kind());
     }
     template <class Config, class Base, class Property>
@@ -1698,7 +1711,7 @@ namespace boost {
     typename boost::property_map<typename Config::graph_type,
       Property>::const_type
     get(Property p, const adj_list_helper<Config, Base>& g) {
-      typedef typename property_kind<Property>::type Kind;
+      typedef typename detail::property_kind_from_graph<adj_list_helper<Config, Base>, Property>::type Kind;
       return detail::get_dispatch(g, p, Kind());
     }
 
@@ -1911,7 +1924,7 @@ namespace boost {
     {
       typedef typename Config::stored_vertex stored_vertex;
       Derived& g = static_cast<Derived&>(g_);
-      g.removing_vertex(u);
+      g.removing_vertex(u, boost::graph_detail::iterator_stability(g_.m_vertices));
       stored_vertex* su = (stored_vertex*)u;
       g.m_vertices.erase(su->m_position);
       delete su;
@@ -2211,7 +2224,7 @@ namespace boost {
     {
       typedef typename Config::directed_category Cat;
       Graph& g = static_cast<Graph&>(g_);
-      g.removing_vertex(v);
+      g.removing_vertex(v, boost::graph_detail::iterator_stability(g_.m_vertices));
       detail::remove_vertex_dispatch(g, v, Cat());
     }
     // O(1)
@@ -2426,15 +2439,15 @@ namespace boost {
       typedef Reference reference;
       typedef typename Graph::vertex_descriptor key_type;
       typedef boost::lvalue_property_map_tag category;
-      inline adj_list_vertex_property_map() { }
-      inline adj_list_vertex_property_map(const Graph*) { }
+      inline adj_list_vertex_property_map(const Graph* = 0, Tag tag = Tag()): m_tag(tag) { }
       inline Reference operator[](key_type v) const {
         StoredVertex* sv = (StoredVertex*)v;
-        return get_property_value(sv->m_property, Tag());
+        return get_property_value(sv->m_property, m_tag);
       }
       inline Reference operator()(key_type v) const {
         return this->operator[](v);
       }
+      Tag m_tag;
     };
 
     template <class Graph, class Property, class PropRef>
@@ -2448,8 +2461,7 @@ namespace boost {
       typedef PropRef reference;
       typedef typename Graph::vertex_descriptor key_type;
       typedef boost::lvalue_property_map_tag category;
-      inline adj_list_vertex_all_properties_map() { }
-      inline adj_list_vertex_all_properties_map(const Graph*) { }
+      inline adj_list_vertex_all_properties_map(const Graph* = 0, vertex_all_t = vertex_all_t()) { }
       inline PropRef operator[](key_type v) const {
         StoredVertex* sv = (StoredVertex*)v;
         return sv->m_property;
@@ -2472,15 +2484,15 @@ namespace boost {
       typedef Reference reference;
       typedef typename boost::graph_traits<Graph>::vertex_descriptor key_type;
       typedef boost::lvalue_property_map_tag category;
-      vec_adj_list_vertex_property_map() { }
-      vec_adj_list_vertex_property_map(GraphPtr g) : m_g(g) { }
+      vec_adj_list_vertex_property_map(GraphPtr g = 0, Tag tag = Tag()) : m_g(g), m_tag(tag) { }
       inline Reference operator[](key_type v) const {
-        return get_property_value(m_g->m_vertices[v].m_property,  Tag());
+        return get_property_value(m_g->m_vertices[v].m_property, m_tag);
       }
       inline Reference operator()(key_type v) const {
         return this->operator[](v);
       }
       GraphPtr m_g;
+      Tag m_tag;
     };
 
     template <class Graph, class GraphPtr, class Property, class PropertyRef>
@@ -2494,8 +2506,7 @@ namespace boost {
       typedef PropertyRef reference;
       typedef typename boost::graph_traits<Graph>::vertex_descriptor key_type;
       typedef boost::lvalue_property_map_tag category;
-      vec_adj_list_vertex_all_properties_map() { }
-      vec_adj_list_vertex_all_properties_map(GraphPtr g) : m_g(g) { }
+      vec_adj_list_vertex_all_properties_map(GraphPtr g = 0, vertex_all_t = vertex_all_t()) : m_g(g) { }
       inline PropertyRef operator[](key_type v) const {
         return m_g->m_vertices[v].m_property;
       }
@@ -2541,7 +2552,7 @@ namespace boost {
       typedef boost::readable_property_map_tag category;
       inline vec_adj_list_vertex_id_map() { }
       template <class Graph>
-      inline vec_adj_list_vertex_id_map(const Graph&) { }
+      inline vec_adj_list_vertex_id_map(const Graph&, vertex_index_t) { }
       inline value_type operator[](key_type v) const { return v; }
       inline value_type operator()(key_type v) const { return v; }
     };
@@ -2578,21 +2589,14 @@ namespace boost {
       };
     };
   namespace detail {
-    template <class Tag>
-    struct adj_list_choose_vertex_pa_helper {
-      typedef adj_list_any_vertex_pa type;
-    };
-    template <>
-    struct adj_list_choose_vertex_pa_helper<vertex_all_t> {
-      typedef adj_list_all_vertex_pa type;
-    };
     template <class Tag, class Graph, class Property>
-    struct adj_list_choose_vertex_pa {
-      typedef typename adj_list_choose_vertex_pa_helper<Tag>::type Helper;
-      typedef typename Helper::template bind_<Tag,Graph,Property> Bind;
-      typedef typename Bind::type type;
-      typedef typename Bind::const_type const_type;
-    };
+    struct adj_list_choose_vertex_pa
+      : boost::mpl::if_<
+          boost::is_same<Tag, vertex_all_t>,
+          adj_list_all_vertex_pa,
+          adj_list_any_vertex_pa>::type
+        ::template bind_<Tag, Graph, Property>
+    {};
 
 
     template <class Tag>
@@ -2608,12 +2612,9 @@ namespace boost {
       typedef vec_adj_list_all_vertex_pa type;
     };
     template <class Tag, class Graph, class Property>
-    struct vec_adj_list_choose_vertex_pa {
-      typedef typename vec_adj_list_choose_vertex_pa_helper<Tag>::type Helper;
-      typedef typename Helper::template bind_<Tag,Graph,Property> Bind;
-      typedef typename Bind::type type;
-      typedef typename Bind::const_type const_type;
-    };
+    struct vec_adj_list_choose_vertex_pa
+      : vec_adj_list_choose_vertex_pa_helper<Tag>::type::template bind_<Tag,Graph,Property>
+    {};
   } // namespace detail
 
     //=========================================================================
@@ -2628,13 +2629,16 @@ namespace boost {
             Tag>
         >
     {
+      Tag tag;
+      explicit adj_list_edge_property_map(Tag tag = Tag()): tag(tag) {}
+
       typedef Value value_type;
       typedef Ref reference;
       typedef detail::edge_desc_impl<Directed, Vertex> key_type;
       typedef boost::lvalue_property_map_tag category;
       inline Ref operator[](key_type e) const {
         Property& p = *(Property*)e.get_property();
-        return get_property_value(p, Tag());
+        return get_property_value(p, tag);
       }
       inline Ref operator()(key_type e) const {
         return this->operator[](e);
@@ -2649,6 +2653,7 @@ namespace boost {
             PropPtr, Vertex>
         >
     {
+      explicit adj_list_edge_all_properties_map(edge_all_t = edge_all_t()) {}
       typedef Property value_type;
       typedef PropRef reference;
       typedef detail::edge_desc_impl<Directed, Vertex> key_type;
@@ -2700,19 +2705,12 @@ namespace boost {
       typedef adj_list_all_edge_pmap type;
     };
     template <class Tag, class Graph, class Property>
-    struct adj_list_choose_edge_pmap {
-      typedef typename adj_list_choose_edge_pmap_helper<Tag>::type Helper;
-      typedef typename Helper::template bind_<Graph,Property,Tag> Bind;
-      typedef typename Bind::type type;
-      typedef typename Bind::const_type const_type;
-    };
+    struct adj_list_choose_edge_pmap
+      : adj_list_choose_edge_pmap_helper<Tag>::type::template bind_<Graph, Property, Tag>
+      {};
     struct adj_list_edge_property_selector {
       template <class Graph, class Property, class Tag>
-      struct bind_ {
-        typedef adj_list_choose_edge_pmap<Tag,Graph,Property> Choice;
-        typedef typename Choice::type type;
-        typedef typename Choice::const_type const_type;
-      };
+      struct bind_: adj_list_choose_edge_pmap<Tag, Graph, Property> {};
     };
   } // namespace detail
 
@@ -2729,11 +2727,9 @@ namespace boost {
 
   struct adj_list_vertex_property_selector {
     template <class Graph, class Property, class Tag>
-    struct bind_ {
-      typedef detail::adj_list_choose_vertex_pa<Tag,Graph,Property> Choice;
-      typedef typename Choice::type type;
-      typedef typename Choice::const_type const_type;
-    };
+    struct bind_
+      : detail::adj_list_choose_vertex_pa<Tag,Graph,Property>
+    {};
   };
   template <>
   struct vertex_property_selector<adj_list_tag> {
@@ -2742,11 +2738,7 @@ namespace boost {
 
   struct vec_adj_list_vertex_property_selector {
     template <class Graph, class Property, class Tag>
-    struct bind_ {
-      typedef detail::vec_adj_list_choose_vertex_pa<Tag,Graph,Property> Choice;
-      typedef typename Choice::type type;
-      typedef typename Choice::const_type const_type;
-    };
+    struct bind_: detail::vec_adj_list_choose_vertex_pa<Tag,Graph,Property> {};
   };
   template <>
   struct vertex_property_selector<vec_adj_list_tag> {
@@ -2755,20 +2747,8 @@ namespace boost {
 
 } // namespace boost
 
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 namespace boost {
 
-  #if BOOST_WORKAROUND( _STLPORT_VERSION, >= 0x500 )
-  // STLport 5 already defines a hash<void*> specialization.
-  #else
-  template <>
-  struct hash< void* > // Need this when vertex_descriptor=void*
-  {
-    std::size_t
-    operator()(void* v) const { return (std::size_t)v; }
-  };
-  #endif
-
   template <typename V>
   struct hash< boost::detail::stored_edge<V> >
   {
@@ -2800,18 +2780,8 @@ namespace boost {
   };
 
 }
-#endif
 
 
-#undef stored_edge
-#undef stored_edge_property
-#undef stored_edge_iter
-
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-// Stay out of the way of the concept checking class
-#undef Graph
-#endif
-
 #endif // BOOST_GRAPH_DETAIL_DETAIL_ADJACENCY_LIST_CCT
 
 /*
diff --git a/include/boost/graph/detail/augment.hpp b/include/boost/graph/detail/augment.hpp
new file mode 100644
index 000000000..3b20dcc4a
--- /dev/null
+++ b/include/boost/graph/detail/augment.hpp
@@ -0,0 +1,63 @@
+//=======================================================================
+// Copyright 2013 University of Warsaw.
+// Authors: Piotr Wygocki 
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//=======================================================================
+
+#ifndef BOOST_GRAPH_AUGMENT_HPP
+#define BOOST_GRAPH_AUGMENT_HPP
+
+#include <boost/graph/filtered_graph.hpp>
+
+namespace boost {
+namespace detail {
+
+template <class Graph, class ResCapMap>
+filtered_graph<const Graph, is_residual_edge<ResCapMap> >
+residual_graph(const Graph& g, ResCapMap residual_capacity) {
+    return filtered_graph<const Graph, is_residual_edge<ResCapMap> >
+        (g, is_residual_edge<ResCapMap>(residual_capacity));
+}
+
+template <class Graph, class PredEdgeMap, class ResCapMap,
+         class RevEdgeMap>
+inline void
+augment(const Graph& g, 
+        typename graph_traits<Graph>::vertex_descriptor src,
+        typename graph_traits<Graph>::vertex_descriptor sink,
+        PredEdgeMap p, 
+        ResCapMap residual_capacity,
+        RevEdgeMap reverse_edge)
+{
+    typename graph_traits<Graph>::edge_descriptor e;
+    typename graph_traits<Graph>::vertex_descriptor u;
+    typedef typename property_traits<ResCapMap>::value_type FlowValue;
+
+    // find minimum residual capacity along the augmenting path
+    FlowValue delta = (std::numeric_limits<FlowValue>::max)();
+    e = get(p, sink);
+    do {
+        BOOST_USING_STD_MIN();
+        delta = min BOOST_PREVENT_MACRO_SUBSTITUTION(delta, get(residual_capacity, e));
+        u = source(e, g);
+        e = get(p, u);
+    } while (u != src);
+
+    // push delta units of flow along the augmenting path
+    e = get(p, sink);
+    do {
+        put(residual_capacity, e, get(residual_capacity, e) - delta);
+        put(residual_capacity, get(reverse_edge, e), get(residual_capacity, get(reverse_edge, e)) + delta);
+        u = source(e, g);
+        e = get(p, u);
+    } while (u != src);
+}
+
+} // namespace detail
+} //namespace boost
+
+#endif /* BOOST_GRAPH_AUGMENT_HPP */
+
diff --git a/include/boost/graph/detail/compressed_sparse_row_struct.hpp b/include/boost/graph/detail/compressed_sparse_row_struct.hpp
index 4fb3c2269..6e7b60d74 100644
--- a/include/boost/graph/detail/compressed_sparse_row_struct.hpp
+++ b/include/boost/graph/detail/compressed_sparse_row_struct.hpp
@@ -21,7 +21,7 @@
 #include <utility>
 #include <algorithm>
 #include <climits>
-#include <cassert>
+#include <boost/assert.hpp>
 #include <iterator>
 #if 0
 #include <iostream> // For some debugging code below
@@ -44,7 +44,6 @@
 #include <boost/graph/graph_selectors.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/functional/hash.hpp>
-#include <boost/utility.hpp>
 
 namespace boost {
 
@@ -219,8 +218,6 @@ namespace detail {
       // the user has supplied the number of edges.
       edges_size_type numedges = numedges_or_zero;
       if (numedges == 0) {
-        typedef typename std::iterator_traits<InputIterator>::iterator_category
-          category;
         numedges = boost::graph::detail::reserve_count_for_single_pass(edge_begin, edge_end);
       }
       m_column.clear();
@@ -255,7 +252,7 @@ namespace detail {
                                            std::vector<vertex_descriptor>& targets,
                                            vertices_size_type numverts,
                                            GlobalToLocal global_to_local) {
-      assert (sources.size() == targets.size());
+      BOOST_ASSERT (sources.size() == targets.size());
       // Do an in-place histogram sort (at least that's what I think it is) to
       // sort sources and targets
       m_rowstart.clear();
@@ -281,8 +278,8 @@ namespace detail {
                                            std::vector<typename inherited_edge_properties::edge_bundled>& edge_props,
                                            vertices_size_type numverts,
                                            GlobalToLocal global_to_local) {
-      assert (sources.size() == targets.size());
-      assert (sources.size() == edge_props.size());
+      BOOST_ASSERT (sources.size() == targets.size());
+      BOOST_ASSERT (sources.size() == edge_props.size());
       // Do an in-place histogram sort (at least that's what I think it is) to
       // sort sources and targets
       m_rowstart.clear();
@@ -314,7 +311,6 @@ namespace detail {
       inherited_edge_properties::resize(numedges);
       EdgeIndex current_edge = 0;
       typedef typename boost::graph_traits<Graph>::vertex_descriptor g_vertex;
-      typedef typename boost::graph_traits<Graph>::edge_descriptor g_edge;
       typedef typename boost::graph_traits<Graph>::out_edge_iterator
         g_out_edge_iter;
 
@@ -348,7 +344,6 @@ namespace detail {
       // Flip sequence
       BidirectionalIterator first(last_sorted);
       BidirectionalIterator last(first_sorted);
-      typedef Vertex vertex_t;
       typedef Vertex vertex_num;
       typedef EdgeIndex edge_num;
       edge_num new_edge_count = std::distance(first, last);
diff --git a/include/boost/graph/detail/d_ary_heap.hpp b/include/boost/graph/detail/d_ary_heap.hpp
index c3b3ef7fd..cf930fc18 100644
--- a/include/boost/graph/detail/d_ary_heap.hpp
+++ b/include/boost/graph/detail/d_ary_heap.hpp
@@ -15,11 +15,16 @@
 #include <cstddef>
 #include <algorithm>
 #include <utility>
-#include <cassert>
+#include <boost/assert.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/shared_array.hpp>
 #include <boost/property_map/property_map.hpp>
 
+// WARNING: it is not safe to copy a d_ary_heap_indirect and then modify one of
+// the copies.  The class is required to be copyable so it can be passed around
+// (without move support from C++11), but it deep-copies the heap contents yet
+// shallow-copies the index_in_heap_map.
+
 namespace boost {
 
   // Swap two elements in a property map without assuming they model
@@ -121,18 +126,21 @@ namespace boost {
     }
 
     Value& top() {
+      BOOST_ASSERT (!this->empty());
       return data[0];
     }
 
     const Value& top() const {
+      BOOST_ASSERT (!this->empty());
       return data[0];
     }
 
     void pop() {
+      BOOST_ASSERT (!this->empty());
       put(index_in_heap, data[0], (size_type)(-1));
       if (data.size() != 1) {
         data[0] = data.back();
-        put(index_in_heap, data[0], 0);
+        put(index_in_heap, data[0], (size_type)(0));
         data.pop_back();
         preserve_heap_property_down();
         verify_heap();
@@ -213,7 +221,7 @@ namespace boost {
 #if 0
       for (size_t i = 1; i < data.size(); ++i) {
         if (compare_indirect(data[i], data[parent(i)])) {
-          assert (!"Element is smaller than its parent");
+          BOOST_ASSERT (!"Element is smaller than its parent");
         }
       }
 #endif
diff --git a/include/boost/graph/detail/edge.hpp b/include/boost/graph/detail/edge.hpp
index da085973a..badf28d4f 100644
--- a/include/boost/graph/detail/edge.hpp
+++ b/include/boost/graph/detail/edge.hpp
@@ -11,11 +11,7 @@
 #ifndef BOOST_GRAPH_DETAIL_EDGE_HPP
 #define BOOST_GRAPH_DETAIL_EDGE_HPP
 
-#if __GNUC__ < 3
-#include <iostream>
-#else
 #include <iosfwd>
-#endif
 
 namespace boost {
 
@@ -100,15 +96,6 @@ namespace boost {
 } // namespace boost
 
 namespace std {
-
-#if __GNUC__ < 3
-  template <class D, class V>
-  std::ostream& 
-  operator<<(std::ostream& os, const boost::detail::edge_desc_impl<D,V>& e)
-  {
-    return os << "(" << e.m_source << "," << e.m_target << ")";
-  }
-#else
   template <class Char, class Traits, class D, class V>
   std::basic_ostream<Char, Traits>& 
   operator<<(std::basic_ostream<Char, Traits>& os,
@@ -116,8 +103,16 @@ namespace std {
   {
     return os << "(" << e.m_source << "," << e.m_target << ")";
   }
-#endif
+}
 
+// Boost's functional/hash
+namespace boost {
+  template<typename D, typename V>
+  struct hash<boost::detail::edge_desc_impl<D, V> >
+  {
+    std::size_t operator()(const boost::detail::edge_desc_impl<D, V> & x) const
+    { return hash_value(x.get_property()); }
+  };
 }
 
 
diff --git a/include/boost/graph/detail/geodesic.hpp b/include/boost/graph/detail/geodesic.hpp
index 99edaf9e3..adcb17f0a 100644
--- a/include/boost/graph/detail/geodesic.hpp
+++ b/include/boost/graph/detail/geodesic.hpp
@@ -11,6 +11,7 @@
 #include <boost/config.hpp>
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/numeric_values.hpp>
+#include <boost/concept/assert.hpp>
 
 // TODO: Should this really be in detail?
 
@@ -51,13 +52,13 @@ namespace detail {
                         Combinator combine,
                         Distance init)
     {
-        function_requires< VertexListGraphConcept<Graph> >();
+        BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
         typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
         typedef typename graph_traits<Graph>::vertex_iterator VertexIterator;
-        function_requires< ReadablePropertyMapConcept<DistanceMap,Vertex> >();
-        function_requires< NumericValueConcept<Distance> >();
+        BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMap,Vertex> ));
+        BOOST_CONCEPT_ASSERT(( NumericValueConcept<Distance> ));
         typedef numeric_values<Distance> DistanceNumbers;
-        function_requires< AdaptableBinaryFunction<Combinator,Distance,Distance,Distance> >();
+        BOOST_CONCEPT_ASSERT(( AdaptableBinaryFunction<Combinator,Distance,Distance,Distance> ));
 
         // If there's ever an infinite distance, then we simply return
         // infinity. Note that this /will/ include the a non-zero
@@ -65,7 +66,7 @@ namespace detail {
         // zero, so it shouldn't be too problematic.
         Distance ret = init;
         VertexIterator i, end;
-        for(tie(i, end) = vertices(g); i != end; ++i) {
+        for(boost::tie(i, end) = vertices(g); i != end; ++i) {
             Vertex v = *i;
             if(get(dist, v) != DistanceNumbers::infinity()) {
                 ret = combine(ret, get(dist, v));
diff --git a/include/boost/graph/detail/histogram_sort.hpp b/include/boost/graph/detail/histogram_sort.hpp
index 742c6f963..ef0363563 100644
--- a/include/boost/graph/detail/histogram_sort.hpp
+++ b/include/boost/graph/detail/histogram_sort.hpp
@@ -10,6 +10,8 @@
 #ifndef BOOST_GRAPH_DETAIL_HISTOGRAM_SORT_HPP
 #define BOOST_GRAPH_DETAIL_HISTOGRAM_SORT_HPP
 
+#include <boost/assert.hpp>
+
 namespace boost {
   namespace graph {
     namespace detail {
@@ -52,12 +54,12 @@ count_starts
    KeyFilter key_filter,
    KeyTransform key_transform) {
 
-  typedef VerticesSize vertices_size_type;
   typedef typename std::iterator_traits<RowstartIterator>::value_type EdgeIndex;
 
   // Put the degree of each vertex v into m_rowstart[v + 1]
   for (KeyIterator i = begin; i != end; ++i) {
     if (key_filter(*i)) {
+      BOOST_ASSERT (key_transform(*i) < numkeys);
       ++starts[key_transform(*i) + 1];
     }
   }
@@ -66,7 +68,7 @@ count_starts
   // m_rowstart
   EdgeIndex start_of_this_row = 0;
   starts[0] = start_of_this_row;
-  for (vertices_size_type i = 1; i <= numkeys; ++i) {
+  for (VerticesSize i = 1; i < numkeys + 1; ++i) {
     start_of_this_row += starts[i];
     starts[i] = start_of_this_row;
   }
@@ -85,7 +87,6 @@ histogram_sort(KeyIterator key_begin, KeyIterator key_end,
                KeyFilter key_filter,
                KeyTransform key_transform) {
 
-  typedef NumKeys vertices_size_type;
   typedef typename std::iterator_traits<RowstartIterator>::value_type EdgeIndex;
 
   // Histogram sort the edges by their source vertices, putting the targets
@@ -96,7 +97,8 @@ histogram_sort(KeyIterator key_begin, KeyIterator key_end,
   Value1InputIter v1i = values1_begin;
   for (KeyIterator i = key_begin; i != key_end; ++i, ++v1i) {
     if (key_filter(*i)) {
-      vertices_size_type source = key_transform(*i);
+      NumKeys source = key_transform(*i);
+      BOOST_ASSERT (source < numkeys);
       EdgeIndex insert_pos = current_insert_positions[source];
       ++current_insert_positions[source];
       values1_out[insert_pos] = *v1i;
@@ -122,7 +124,6 @@ histogram_sort(KeyIterator key_begin, KeyIterator key_end,
                KeyFilter key_filter,
                KeyTransform key_transform) {
 
-  typedef NumKeys vertices_size_type;
   typedef typename std::iterator_traits<RowstartIterator>::value_type EdgeIndex;
 
   // Histogram sort the edges by their source vertices, putting the targets
@@ -134,7 +135,8 @@ histogram_sort(KeyIterator key_begin, KeyIterator key_end,
   Value2InputIter v2i = values2_begin;
   for (KeyIterator i = key_begin; i != key_end; ++i, ++v1i, ++v2i) {
     if (key_filter(*i)) {
-      vertices_size_type source = key_transform(*i);
+      NumKeys source = key_transform(*i);
+      BOOST_ASSERT (source < numkeys);
       EdgeIndex insert_pos = current_insert_positions[source];
       ++current_insert_positions[source];
       values1_out[insert_pos] = *v1i;
@@ -154,18 +156,18 @@ histogram_sort_inplace(KeyIterator key_begin,
                        Value1Iter values1,
                        KeyTransform key_transform) {
 
-  typedef NumKeys vertices_size_type;
   typedef typename std::iterator_traits<RowstartIterator>::value_type EdgeIndex;
 
   // 1. Copy m_rowstart (except last element) to get insert positions
   std::vector<EdgeIndex> insert_positions(rowstart, rowstart + numkeys);
   // 2. Swap the sources and targets into place
   for (size_t i = 0; i < rowstart[numkeys]; ++i) {
+    BOOST_ASSERT (key_transform(key_begin[i]) < numkeys);
     // While edge i is not in the right bucket:
     while (!(i >= rowstart[key_transform(key_begin[i])] && i < insert_positions[key_transform(key_begin[i])])) {
       // Add a slot in the right bucket
       size_t target_pos = insert_positions[key_transform(key_begin[i])]++;
-      assert (target_pos < rowstart[key_transform(key_begin[i]) + 1]);
+      BOOST_ASSERT (target_pos < rowstart[key_transform(key_begin[i]) + 1]);
       if (target_pos == i) continue;
       // Swap this edge into place
       using std::swap;
@@ -188,18 +190,18 @@ histogram_sort_inplace(KeyIterator key_begin,
                        Value2Iter values2,
                        KeyTransform key_transform) {
 
-  typedef NumKeys vertices_size_type;
   typedef typename std::iterator_traits<RowstartIterator>::value_type EdgeIndex;
 
   // 1. Copy m_rowstart (except last element) to get insert positions
   std::vector<EdgeIndex> insert_positions(rowstart, rowstart + numkeys);
   // 2. Swap the sources and targets into place
   for (size_t i = 0; i < rowstart[numkeys]; ++i) {
+    BOOST_ASSERT (key_transform(key_begin[i]) < numkeys);
     // While edge i is not in the right bucket:
     while (!(i >= rowstart[key_transform(key_begin[i])] && i < insert_positions[key_transform(key_begin[i])])) {
       // Add a slot in the right bucket
       size_t target_pos = insert_positions[key_transform(key_begin[i])]++;
-      assert (target_pos < rowstart[key_transform(key_begin[i]) + 1]);
+      BOOST_ASSERT (target_pos < rowstart[key_transform(key_begin[i]) + 1]);
       if (target_pos == i) continue;
       // Swap this edge into place
       using std::swap;
@@ -267,16 +269,21 @@ void split_into_separate_coords_filtered
   }
 }
 
+// The versions of operator()() here can't return by reference because the
+// actual type passed in may not match Pair, in which case the reference
+// parameter is bound to a temporary that could end up dangling after the
+// operator returns.
+
 template <typename Pair>
 struct project1st {
   typedef typename Pair::first_type result_type;
-  const result_type& operator()(const Pair& p) const {return p.first;}
+  result_type operator()(const Pair& p) const {return p.first;}
 };
 
 template <typename Pair>
 struct project2nd {
   typedef typename Pair::second_type result_type;
-  const result_type& operator()(const Pair& p) const {return p.second;}
+  result_type operator()(const Pair& p) const {return p.second;}
 };
 
     }
diff --git a/include/boost/graph/detail/indexed_properties.hpp b/include/boost/graph/detail/indexed_properties.hpp
index e1f874b2c..4494625c6 100644
--- a/include/boost/graph/detail/indexed_properties.hpp
+++ b/include/boost/graph/detail/indexed_properties.hpp
@@ -253,7 +253,7 @@ class indexed_edge_properties<Derived, void, Descriptor, IndexMap>
   typedef secret const_edge_map_type;
 
   secret operator[](secret) { return secret(); }
-  void write_by_index(std::size_t idx, const no_property& prop) {}
+  void write_by_index(std::size_t /*idx*/, const no_property& /*prop*/) {}
 
   edge_map_type get_edge_bundle(const IndexMap& = IndexMap()) const {
     return edge_map_type();
@@ -270,7 +270,7 @@ class indexed_edge_properties<Derived, void, Descriptor, IndexMap>
 
  public:
   void push_back(const edge_push_back_type&) { }
-  void move_range(std::size_t src_begin, std::size_t src_end, std::size_t dest_begin) {}
+  void move_range(std::size_t /*src_begin*/, std::size_t /*src_end*/, std::size_t /*dest_begin*/) {}
 
   typedef dummy_no_property_iterator iterator;
   iterator begin() {return dummy_no_property_iterator();}
diff --git a/include/boost/graph/detail/is_distributed_selector.hpp b/include/boost/graph/detail/is_distributed_selector.hpp
new file mode 100644
index 000000000..4319d9d89
--- /dev/null
+++ b/include/boost/graph/detail/is_distributed_selector.hpp
@@ -0,0 +1,26 @@
+// Copyright 2012 The Trustees of Indiana University.
+
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+//  Authors: Jeremiah Willcock
+//           Andrew Lumsdaine
+
+// Selector to determine whether a selector is distributedS (can only be true
+// if <boost/graph/distributed/selector.hpp> has been included) so that we can
+// disable various sequential-graph-only traits specializations for distributed
+// graphs.
+
+#ifndef BOOST_GRAPH_DETAIL_IS_DISTRIBUTED_SELECTOR_HPP
+#define BOOST_GRAPH_DETAIL_IS_DISTRIBUTED_SELECTOR_HPP
+
+#include <boost/mpl/bool.hpp>
+
+namespace boost {
+  namespace detail {
+    template <typename> struct is_distributed_selector: boost::mpl::false_ {};
+  }
+}
+
+#endif // BOOST_GRAPH_DETAIL_IS_DISTRIBUTED_SELECTOR_HPP
diff --git a/include/boost/graph/detail/is_same.hpp b/include/boost/graph/detail/is_same.hpp
deleted file mode 100644
index 07330d301..000000000
--- a/include/boost/graph/detail/is_same.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//=======================================================================
-// Copyright 1997, 1998, 1999, 2000 University of Notre Dame.
-// Authors: Andrew Lumsdaine, Lie-Quan Lee, Jeremy G. Siek
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//=======================================================================
-#ifndef BOOST_GRAPH_DETAIL_IS_SAME_HPP
-#define BOOST_GRAPH_DETAIL_IS_SAME_HPP
-
-// Deprecate the use of this header.
-// TODO: Remove this file from trunk/release in 1.41/1.42.
-#if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__DMC__)
-#  pragma message ("Warning: This header is deprecated. Please use: boost/type_traits/is_same.hpp")
-#elif defined(__GNUC__) || defined(__HP_aCC) || defined(__SUNPRO_CC) || defined(__IBMCPP__)
-#  warning "This header is deprecated. Please use: boost/type_traits/is_same.hpp"
-#endif
-
-#include <boost/mpl/if.hpp>
-
-namespace boost {
-  struct false_tag;
-  struct true_tag;
-
-  namespace graph_detail {
-    
-#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-    template <class U, class V>
-    struct is_same {
-      typedef boost::false_tag is_same_tag; 
-    };
-    template <class U>
-    struct is_same<U, U> {
-      typedef boost::true_tag is_same_tag;
-    };
-#else
-    template <class U, class V>
-    struct is_same {
-      enum { Unum = U::num, Vnum = V::num };
-      typedef typename mpl::if_c< (Unum == Vnum),
-               boost::true_tag, boost::false_tag>::type is_same_tag;
-    };
-#endif
-  } // namespace graph_detail
-} // namespace boost
-
-#endif
diff --git a/include/boost/graph/detail/labeled_graph_traits.hpp b/include/boost/graph/detail/labeled_graph_traits.hpp
index 6eb106093..a0c0973f9 100644
--- a/include/boost/graph/detail/labeled_graph_traits.hpp
+++ b/include/boost/graph/detail/labeled_graph_traits.hpp
@@ -218,9 +218,9 @@ namespace graph_detail {
 #define LABELED_GRAPH_PARAMS typename G, typename L, typename S
 #define LABELED_GRAPH labeled_graph<G,L,S>
 
-// Specialize mutability traits for for the labeled graph.
+// Specialize mutability traits for the labeled graph.
 // This specialization depends on the mutability of the underlying graph type.
-// If the underlying graph is fully mutable, this this is also fully mutable.
+// If the underlying graph is fully mutable, this is also fully mutable.
 // Otherwise, it's different.
 template <LABELED_GRAPH_PARAMS>
 struct graph_mutability_traits< LABELED_GRAPH > {
diff --git a/include/boost/graph/detail/read_graphviz_spirit.hpp b/include/boost/graph/detail/read_graphviz_spirit.hpp
index 4e8b22e5e..994646988 100644
--- a/include/boost/graph/detail/read_graphviz_spirit.hpp
+++ b/include/boost/graph/detail/read_graphviz_spirit.hpp
@@ -604,7 +604,9 @@ bool read_graphviz_spirit(MultiPassIterator begin, MultiPassIterator end,
 
   scanner_t scan(begin, end, policies);
 
-  return p.parse(scan);
+  bool ok = p.parse(scan);
+  m_graph.finish_building_graph();
+  return ok;
 }
 
 } // namespace boost
diff --git a/include/boost/graph/detail/set_adaptor.hpp b/include/boost/graph/detail/set_adaptor.hpp
index 90a64a2cd..33acc07e3 100644
--- a/include/boost/graph/detail/set_adaptor.hpp
+++ b/include/boost/graph/detail/set_adaptor.hpp
@@ -111,7 +111,7 @@ namespace boost {
     // Shit, can't implement this without knowing the size of the
     // universe.
     template <class K, class C, class A>
-    void set_compliment(const std::set<K,C,A>& x,
+    void set_compliment(const std::set<K,C,A>& /*x*/,
                         std::set<K,C,A>& z)
     {
       z.clear();
diff --git a/include/boost/graph/dijkstra_shortest_paths.hpp b/include/boost/graph/dijkstra_shortest_paths.hpp
index 5b39cb385..10e40f828 100644
--- a/include/boost/graph/dijkstra_shortest_paths.hpp
+++ b/include/boost/graph/dijkstra_shortest_paths.hpp
@@ -30,6 +30,7 @@
 #include <boost/property_map/property_map.hpp>
 #include <boost/property_map/vector_property_map.hpp>
 #include <boost/type_traits.hpp>
+#include <boost/concept/assert.hpp>
 
 #ifdef BOOST_GRAPH_DIJKSTRA_TESTING
 #  include <boost/pending/mutable_queue.hpp>
@@ -68,7 +69,7 @@ namespace boost {
   template <class Visitor, class Graph>
   struct DijkstraVisitorConcept {
     void constraints() {
-      function_requires< CopyConstructibleConcept<Visitor> >();
+      BOOST_CONCEPT_ASSERT(( CopyConstructibleConcept<Visitor> ));
       vis.initialize_vertex(u, g);
       vis.discover_vertex(u, g);
       vis.examine_vertex(u, g);
@@ -117,6 +118,7 @@ namespace boost {
     struct dijkstra_bfs_visitor
     {
       typedef typename property_traits<DistanceMap>::value_type D;
+      typedef typename property_traits<WeightMap>::value_type W;
 
       dijkstra_bfs_visitor(UniformCostVisitor vis, UpdatableQueue& Q,
                            WeightMap w, PredecessorMap p, DistanceMap d,
@@ -158,9 +160,39 @@ namespace boost {
       void examine_vertex(Vertex u, Graph& g) { m_vis.examine_vertex(u, g); }
       template <class Edge, class Graph>
       void examine_edge(Edge e, Graph& g) {
-        if (m_compare(get(m_weight, e), m_zero))
+        // Test for negative-weight edges:
+        //
+        // Reasons that other comparisons do not work:
+        //
+        // m_compare(e_weight, D(0)):
+        //    m_compare only needs to work on distances, not weights, and those
+        //    types do not need to be the same (bug 8398,
+        //    https://svn.boost.org/trac/boost/ticket/8398).
+        // m_compare(m_combine(source_dist, e_weight), source_dist):
+        //    if m_combine is project2nd (as in prim_minimum_spanning_tree),
+        //    this test will claim that the edge weight is negative whenever
+        //    the edge weight is less than source_dist, even if both of those
+        //    are positive (bug 9012,
+        //    https://svn.boost.org/trac/boost/ticket/9012).
+        // m_compare(m_combine(e_weight, source_dist), source_dist):
+        //    would fix project2nd issue, but documentation only requires that
+        //    m_combine be able to take a distance and a weight (in that order)
+        //    and return a distance.
+
+        // W e_weight = get(m_weight, e);
+        // sd_plus_ew = source_dist + e_weight.
+        // D sd_plus_ew = m_combine(source_dist, e_weight);
+        // sd_plus_2ew = source_dist + 2 * e_weight.
+        // D sd_plus_2ew = m_combine(sd_plus_ew, e_weight);
+        // The test here is equivalent to e_weight < 0 if m_combine has a
+        // cancellation law, but always returns false when m_combine is a
+        // projection operator.
+        if (m_compare(m_combine(m_zero, get(m_weight, e)), m_zero)) 
             boost::throw_exception(negative_edge());
+        // End of test for negative-weight edges.
+
         m_vis.examine_edge(e, g);
+
       }
       template <class Edge, class Graph>
       void black_target(Edge, Graph&) { }
@@ -251,14 +283,14 @@ namespace boost {
   }
 
   // Call breadth first search with default color map.
-  template <class Graph, class DijkstraVisitor,
+  template <class Graph, class SourceInputIter, class DijkstraVisitor,
             class PredecessorMap, class DistanceMap,
             class WeightMap, class IndexMap, class Compare, class Combine,
             class DistZero>
   inline void
   dijkstra_shortest_paths_no_init
     (const Graph& g,
-     typename graph_traits<Graph>::vertex_descriptor s,
+     SourceInputIter s_begin, SourceInputIter s_end,
      PredecessorMap predecessor, DistanceMap distance, WeightMap weight,
      IndexMap index_map,
      Compare compare, Combine combine, DistZero zero,
@@ -270,16 +302,16 @@ namespace boost {
     typedef typename ColorMapHelper::type ColorMap;
     ColorMap color =
       ColorMapHelper::build(g, index_map);
-    dijkstra_shortest_paths_no_init( g, s, predecessor, distance, weight,
+    dijkstra_shortest_paths_no_init( g, s_begin, s_end, predecessor, distance, weight,
       index_map, compare, combine, zero, vis,
         color);
   }
 
-  // Call breadth first search
+  // Call breadth first search with default color map.
   template <class Graph, class DijkstraVisitor,
             class PredecessorMap, class DistanceMap,
             class WeightMap, class IndexMap, class Compare, class Combine,
-            class DistZero, class ColorMap>
+            class DistZero>
   inline void
   dijkstra_shortest_paths_no_init
     (const Graph& g,
@@ -287,6 +319,25 @@ namespace boost {
      PredecessorMap predecessor, DistanceMap distance, WeightMap weight,
      IndexMap index_map,
      Compare compare, Combine combine, DistZero zero,
+     DijkstraVisitor vis)
+  {
+    dijkstra_shortest_paths_no_init(g, &s, &s + 1, predecessor, distance,
+                                    weight, index_map, compare, combine, zero,
+                                    vis);
+  }
+
+  // Call breadth first search
+  template <class Graph, class SourceInputIter, class DijkstraVisitor,
+            class PredecessorMap, class DistanceMap,
+            class WeightMap, class IndexMap, class Compare, class Combine,
+            class DistZero, class ColorMap>
+  inline void
+  dijkstra_shortest_paths_no_init
+    (const Graph& g,
+     SourceInputIter s_begin, SourceInputIter s_end,
+     PredecessorMap predecessor, DistanceMap distance, WeightMap weight,
+     IndexMap index_map,
+     Compare compare, Combine combine, DistZero zero,
      DijkstraVisitor vis, ColorMap color)
   {
     typedef indirect_cmp<DistanceMap, Compare> IndirectCmp;
@@ -304,7 +355,7 @@ namespace boost {
         PredecessorMap, DistanceMap, Combine, Compare>
       bfs_vis(vis, Q, weight, predecessor, distance, combine, compare, zero);
 
-      breadth_first_visit(g, s, Q, bfs_vis, color);
+      breadth_first_visit(g, s_begin, s_end, Q, bfs_vis, color);
       return;
     }
 #endif // BOOST_GRAPH_DIJKSTRA_TESTING
@@ -329,11 +380,30 @@ namespace boost {
       PredecessorMap, DistanceMap, Combine, Compare>
         bfs_vis(vis, Q, weight, predecessor, distance, combine, compare, zero);
 
-    breadth_first_visit(g, s, Q, bfs_vis, color);
+    breadth_first_visit(g, s_begin, s_end, Q, bfs_vis, color);
+  }
+
+  // Call breadth first search
+  template <class Graph, class DijkstraVisitor,
+            class PredecessorMap, class DistanceMap,
+            class WeightMap, class IndexMap, class Compare, class Combine,
+            class DistZero, class ColorMap>
+  inline void
+  dijkstra_shortest_paths_no_init
+    (const Graph& g,
+     typename graph_traits<Graph>::vertex_descriptor s,
+     PredecessorMap predecessor, DistanceMap distance, WeightMap weight,
+     IndexMap index_map,
+     Compare compare, Combine combine, DistZero zero,
+     DijkstraVisitor vis, ColorMap color)
+  {
+    dijkstra_shortest_paths_no_init(g, &s, &s + 1, predecessor, distance,
+                                    weight, index_map, compare, combine,
+                                    zero, vis, color);
   }
 
   // Initialize distances and call breadth first search with default color map
-  template <class VertexListGraph, class DijkstraVisitor,
+  template <class VertexListGraph, class SourceInputIter, class DijkstraVisitor,
             class PredecessorMap, class DistanceMap,
             class WeightMap, class IndexMap, class Compare, class Combine,
             class DistInf, class DistZero, typename T, typename Tag, 
@@ -341,7 +411,7 @@ namespace boost {
   inline void
   dijkstra_shortest_paths
     (const VertexListGraph& g,
-     typename graph_traits<VertexListGraph>::vertex_descriptor s,
+     SourceInputIter s_begin, SourceInputIter s_end,
      PredecessorMap predecessor, DistanceMap distance, WeightMap weight,
      IndexMap index_map,
      Compare compare, Combine combine, DistInf inf, DistZero zero,
@@ -350,16 +420,17 @@ namespace boost {
      BOOST_GRAPH_ENABLE_IF_MODELS_PARM(VertexListGraph,vertex_list_graph_tag))
   {
     boost::two_bit_color_map<IndexMap> color(num_vertices(g), index_map);
-    dijkstra_shortest_paths(g, s, predecessor, distance, weight, index_map,
-                            compare, combine, inf, zero, vis,
+    dijkstra_shortest_paths(g, s_begin, s_end, predecessor, distance, weight,
+                            index_map, compare, combine, inf, zero, vis,
                             color);
   }
 
-  // Initialize distances and call breadth first search
+  // Initialize distances and call breadth first search with default color map
   template <class VertexListGraph, class DijkstraVisitor,
             class PredecessorMap, class DistanceMap,
             class WeightMap, class IndexMap, class Compare, class Combine,
-            class DistInf, class DistZero, class ColorMap>
+            class DistInf, class DistZero, typename T, typename Tag, 
+            typename Base>
   inline void
   dijkstra_shortest_paths
     (const VertexListGraph& g,
@@ -367,6 +438,26 @@ namespace boost {
      PredecessorMap predecessor, DistanceMap distance, WeightMap weight,
      IndexMap index_map,
      Compare compare, Combine combine, DistInf inf, DistZero zero,
+     DijkstraVisitor vis,
+     const bgl_named_params<T, Tag, Base>&
+     BOOST_GRAPH_ENABLE_IF_MODELS_PARM(VertexListGraph,vertex_list_graph_tag))
+  {
+    dijkstra_shortest_paths(g, &s, &s + 1, predecessor, distance, weight,
+                            index_map, compare, combine, inf, zero, vis);
+  }
+
+  // Initialize distances and call breadth first search
+  template <class VertexListGraph, class SourceInputIter, class DijkstraVisitor,
+            class PredecessorMap, class DistanceMap,
+            class WeightMap, class IndexMap, class Compare, class Combine,
+            class DistInf, class DistZero, class ColorMap>
+  inline void
+  dijkstra_shortest_paths
+    (const VertexListGraph& g,
+     SourceInputIter s_begin, SourceInputIter s_end,
+     PredecessorMap predecessor, DistanceMap distance, WeightMap weight,
+     IndexMap index_map,
+     Compare compare, Combine combine, DistInf inf, DistZero zero,
      DijkstraVisitor vis, ColorMap color)
   {
     typedef typename property_traits<ColorMap>::value_type ColorValue;
@@ -378,17 +469,20 @@ namespace boost {
       put(predecessor, *ui, *ui);
       put(color, *ui, Color::white());
     }
-    put(distance, s, zero);
+    for (SourceInputIter it = s_begin; it != s_end; ++it) {
+      put(distance, *it, zero);
+    }
 
-    dijkstra_shortest_paths_no_init(g, s, predecessor, distance, weight,
-                            index_map, compare, combine, zero, vis, color);
+    dijkstra_shortest_paths_no_init(g, s_begin, s_end, predecessor, distance,
+                            weight, index_map, compare, combine, zero, vis,
+                            color);
   }
 
   // Initialize distances and call breadth first search
   template <class VertexListGraph, class DijkstraVisitor,
             class PredecessorMap, class DistanceMap,
             class WeightMap, class IndexMap, class Compare, class Combine,
-            class DistInf, class DistZero>
+            class DistInf, class DistZero, class ColorMap>
   inline void
   dijkstra_shortest_paths
     (const VertexListGraph& g,
@@ -396,13 +490,53 @@ namespace boost {
      PredecessorMap predecessor, DistanceMap distance, WeightMap weight,
      IndexMap index_map,
      Compare compare, Combine combine, DistInf inf, DistZero zero,
+     DijkstraVisitor vis, ColorMap color)
+  {
+    dijkstra_shortest_paths(g, &s, &s + 1, predecessor, distance, weight,
+                            index_map, compare, combine, inf, zero,
+                            vis, color);
+  }
+
+  // Initialize distances and call breadth first search
+  template <class VertexListGraph, class SourceInputIter,
+            class DijkstraVisitor,
+            class PredecessorMap, class DistanceMap,
+            class WeightMap, class IndexMap, class Compare, class Combine,
+            class DistInf, class DistZero>
+  inline void
+  dijkstra_shortest_paths
+    (const VertexListGraph& g,
+     SourceInputIter s_begin, SourceInputIter s_end,
+     PredecessorMap predecessor, DistanceMap distance, WeightMap weight,
+     IndexMap index_map,
+     Compare compare, Combine combine, DistInf inf, DistZero zero,
      DijkstraVisitor vis)
   {
-    dijkstra_shortest_paths(g, s, predecessor, distance, weight, index_map,
+    dijkstra_shortest_paths(g, s_begin, s_end, predecessor, distance,
+                            weight, index_map,
                             compare, combine, inf, zero, vis,
                             no_named_parameters());
   }
 
+  // Initialize distances and call breadth first search
+  template <class VertexListGraph, class DijkstraVisitor,
+            class PredecessorMap, class DistanceMap,
+            class WeightMap, class IndexMap, class Compare, class Combine,
+            class DistInf, class DistZero>
+  inline void
+  dijkstra_shortest_paths
+    (const VertexListGraph& g,
+     typename graph_traits<VertexListGraph>::vertex_descriptor s,
+     PredecessorMap predecessor, DistanceMap distance, WeightMap weight,
+     IndexMap index_map,
+     Compare compare, Combine combine, DistInf inf, DistZero zero,
+     DijkstraVisitor vis)
+  {
+    dijkstra_shortest_paths(g, &s, &s + 1, predecessor, distance,
+                            weight, index_map,
+                            compare, combine, inf, zero, vis);
+  }
+
   namespace detail {
 
     // Handle defaults for PredecessorMap and
@@ -420,6 +554,9 @@ namespace boost {
       dummy_property_map p_map;
 
       typedef typename property_traits<DistanceMap>::value_type D;
+      D inf = choose_param(get_param(params, distance_inf_t()),
+                           (std::numeric_limits<D>::max)());
+
       dijkstra_shortest_paths
         (g, s,
          choose_param(get_param(params, vertex_predecessor), p_map),
@@ -427,9 +564,8 @@ namespace boost {
          choose_param(get_param(params, distance_compare_t()),
                       std::less<D>()),
          choose_param(get_param(params, distance_combine_t()),
-                      closed_plus<D>()),
-         choose_param(get_param(params, distance_inf_t()),
-                      (std::numeric_limits<D>::max)()),
+                      closed_plus<D>(inf)),
+         inf,
          choose_param(get_param(params, distance_zero_t()),
                       D()),
          choose_param(get_param(params, graph_visitor),
diff --git a/include/boost/graph/dijkstra_shortest_paths_no_color_map.hpp b/include/boost/graph/dijkstra_shortest_paths_no_color_map.hpp
index 443984ff0..b1a9ef589 100644
--- a/include/boost/graph/dijkstra_shortest_paths_no_color_map.hpp
+++ b/include/boost/graph/dijkstra_shortest_paths_no_color_map.hpp
@@ -41,7 +41,6 @@ namespace boost {
   {
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
     typedef typename property_traits<DistanceMap>::value_type Distance;
-    typedef typename property_traits<WeightMap>::value_type Weight;
     
     typedef indirect_cmp<DistanceMap, DistanceCompare> DistanceIndirectCompare;
     DistanceIndirectCompare
@@ -92,7 +91,6 @@ namespace boost {
       }
   
       // Examine neighbors of min_vertex
-      typedef typename graph_traits<Graph>::edge_descriptor Edge;
       BGL_FORALL_OUTEDGES_T(min_vertex, current_edge, graph, Graph) {
         visitor.examine_edge(current_edge, graph);
         
@@ -113,16 +111,17 @@ namespace boost {
           distance_weight_combine, distance_compare);
   
         if (was_edge_relaxed) {
-          vertex_queue.update(neighbor_vertex);
           visitor.edge_relaxed(current_edge, graph);
+          if (is_neighbor_undiscovered) {
+            visitor.discover_vertex(neighbor_vertex, graph);
+            vertex_queue.push(neighbor_vertex);
+          } else {
+            vertex_queue.update(neighbor_vertex);
+          }
         } else {
           visitor.edge_not_relaxed(current_edge, graph);
         }
   
-        if (is_neighbor_undiscovered) {
-          visitor.discover_vertex(neighbor_vertex, graph);
-          vertex_queue.push(neighbor_vertex);
-        }
       } // end out edge iteration
   
       visitor.finish_vertex(min_vertex, graph);
@@ -186,6 +185,9 @@ namespace boost {
       dummy_property_map predecessor_map;
 
       typedef typename property_traits<DistanceMap>::value_type DistanceType;
+      DistanceType inf =
+        choose_param(get_param(params, distance_inf_t()),
+                     (std::numeric_limits<DistanceType>::max)());
       dijkstra_shortest_paths_no_color_map
         (graph, start_vertex,
          choose_param(get_param(params, vertex_predecessor), predecessor_map),
@@ -193,9 +195,8 @@ namespace boost {
          choose_param(get_param(params, distance_compare_t()),
                       std::less<DistanceType>()),
          choose_param(get_param(params, distance_combine_t()),
-                      closed_plus<DistanceType>()),
-         choose_param(get_param(params, distance_inf_t()),
-                      (std::numeric_limits<DistanceType>::max)()),
+                      closed_plus<DistanceType>(inf)),
+         inf,
          choose_param(get_param(params, distance_zero_t()),
                       DistanceType()),
          choose_param(get_param(params, graph_visitor),
diff --git a/include/boost/graph/dimacs.hpp b/include/boost/graph/dimacs.hpp
index 195ad3b65..3e8407dfa 100644
--- a/include/boost/graph/dimacs.hpp
+++ b/include/boost/graph/dimacs.hpp
@@ -17,6 +17,7 @@
 #include <exception>
 #include <vector>
 #include <queue>
+#include <boost/assert.hpp>
 
 namespace boost { namespace graph {
 
@@ -54,27 +55,27 @@ class dimacs_basic_reader {
                           num_edges( 0 ), seen_edges( 0 ), want_weights(false) {}
 
   edge_type edge_deref() {
-    assert( !read_edges.empty() );
+    BOOST_ASSERT( !read_edges.empty() );
     return read_edges.front();
    }
 
   inline edge_type* edge_ref() {
-    assert( !read_edges.empty() );
+    BOOST_ASSERT( !read_edges.empty() );
     return &read_edges.front();
   }
 
   inline edge_weight_type edge_weight_deref() {
-    assert( !read_edge_weights.empty() );
+    BOOST_ASSERT( !read_edge_weights.empty() );
     return read_edge_weights.front();
   }
 
   inline dimacs_basic_reader incr( incr_mode mode ) {
     if( mode == edge ) {
-      assert( !read_edges.empty() );
+      BOOST_ASSERT( !read_edges.empty() );
       read_edges.pop();
     }
     else if( mode == edge_weight ) {
-      assert( !read_edge_weights.empty() );
+      BOOST_ASSERT( !read_edge_weights.empty() );
       read_edge_weights.pop();
     }
 
@@ -100,8 +101,8 @@ class dimacs_basic_reader {
               read_edge_weights.push( weight );
           }
       }
-      assert( read_edges.size() < 100 );
-      assert( read_edge_weights.size() < 100 );
+      BOOST_ASSERT( read_edges.size() < 100 );
+      BOOST_ASSERT( read_edge_weights.size() < 100 );
     }
 
     // the 1000000 just happens to be about how many edges can be read in 
diff --git a/include/boost/graph/directed_graph.hpp b/include/boost/graph/directed_graph.hpp
index 992546d46..585308d18 100644
--- a/include/boost/graph/directed_graph.hpp
+++ b/include/boost/graph/directed_graph.hpp
@@ -7,9 +7,12 @@
 #ifndef BOOST_GRAPH_DIRECTED_GRAPH_HPP
 #define BOOST_GRAPH_DIRECTED_GRAPH_HPP
 
-#include <boost/utility.hpp>
 #include <boost/graph/adjacency_list.hpp>
 #include <boost/graph/properties.hpp>
+#include <boost/pending/property.hpp>
+#include <boost/property_map/transform_value_property_map.hpp>
+#include <boost/type_traits.hpp>
+#include <boost/mpl/if.hpp>
 
 namespace boost
 {
@@ -28,29 +31,26 @@ struct directed_graph_tag { };
  */
 template <
     typename VertexProp = no_property,
-    typename EdgeProp= no_property,
-    typename GraphProp= no_property>
+    typename EdgeProp = no_property,
+    typename GraphProp = no_property>
 class directed_graph
 {
 public:
-    typedef typename graph_detail::graph_prop<GraphProp>::property graph_property_type;
-    typedef typename graph_detail::graph_prop<GraphProp>::bundle graph_bundled;
-
-    typedef typename graph_detail::vertex_prop<VertexProp>::property vertex_property_type;
-    typedef typename graph_detail::vertex_prop<VertexProp>::bundle vertex_bundled;
-
-    typedef typename graph_detail::edge_prop<EdgeProp>::property edge_property_type;
-    typedef typename graph_detail::edge_prop<EdgeProp>::bundle edge_bundled;
-
-private:
-    // Wrap the user-specified properties with an index.
-    typedef property<vertex_index_t, unsigned, vertex_property_type> vertex_property;
-    typedef property<edge_index_t, unsigned, edge_property_type> edge_property;
+    typedef GraphProp graph_property_type;
+    typedef VertexProp vertex_property_type;
+    typedef EdgeProp edge_property_type;
+    typedef typename lookup_one_property<GraphProp, graph_bundle_t>::type graph_bundled;
+    typedef typename lookup_one_property<VertexProp, vertex_bundle_t>::type vertex_bundled;
+    typedef typename lookup_one_property<EdgeProp, edge_bundle_t>::type edge_bundled;
 
+public:
+    // Embed indices into the vertex type.
+    typedef property<vertex_index_t, unsigned, vertex_property_type> internal_vertex_property;
+    typedef property<edge_index_t, unsigned, edge_property_type> internal_edge_property;
 public:
     typedef adjacency_list<
         listS, listS, bidirectionalS,
-        vertex_property, edge_property, GraphProp,
+        internal_vertex_property, internal_edge_property, GraphProp,
         listS
     > graph_type;
 
@@ -83,8 +83,8 @@ class directed_graph
     typedef typename graph_type::edge_parallel_category edge_parallel_category;
     typedef typename graph_type::traversal_category traversal_category;
 
-    typedef unsigned vertex_index_type;
-    typedef unsigned edge_index_type;
+    typedef std::size_t vertex_index_type;
+    typedef std::size_t edge_index_type;
 
     directed_graph(GraphProp const& p = GraphProp())
         : m_graph(p), m_num_vertices(0), m_num_edges(0), m_max_vertex_index(0)
@@ -140,6 +140,7 @@ class directed_graph
     vertices_size_type num_vertices() const
     { return m_num_vertices; }
 
+
 private:
     // This helper function manages the attribution of vertex indices.
     vertex_descriptor make_index(vertex_descriptor v) {
@@ -153,7 +154,7 @@ class directed_graph
     { return make_index(boost::add_vertex(m_graph)); }
 
     vertex_descriptor add_vertex(vertex_property_type const& p)
-    { return make_index(boost::add_vertex(vertex_property(0u, p), m_graph)); }
+    { return make_index(boost::add_vertex(internal_vertex_property(0u, p), m_graph)); }
 
     void clear_vertex(vertex_descriptor v)
     {
@@ -189,7 +190,7 @@ class directed_graph
 
     std::pair<edge_descriptor, bool>
     add_edge(vertex_descriptor u, vertex_descriptor v, edge_property_type const& p)
-    { return make_index(boost::add_edge(u, v, edge_property(0u, p), m_graph)); }
+    { return make_index(boost::add_edge(u, v, internal_edge_property(0u, p), m_graph)); }
 
     void remove_edge(vertex_descriptor u, vertex_descriptor v)
     {
@@ -410,7 +411,7 @@ template <DIRECTED_GRAPH_PARAMS>
 typename DIRECTED_GRAPH::vertex_descriptor
 vertex(typename DIRECTED_GRAPH::vertices_size_type n,
        DIRECTED_GRAPH const& g)
-{ return vertex(g.impl()); }
+{ return vertex(n, g.impl()); }
 
 template <DIRECTED_GRAPH_PARAMS>
 std::pair<typename DIRECTED_GRAPH::edge_descriptor, bool>
@@ -519,37 +520,32 @@ remove_in_edge_if(typename DIRECTED_GRAPH::vertex_descriptor v,
                 DIRECTED_GRAPH& g)
 { return remove_in_edge_if(v, pred, g.impl()); }
 
-// Helper code for working with property maps
-namespace detail
-{
-    struct directed_graph_vertex_property_selector {
-        template <class DirectedGraph, class Property, class Tag>
-        struct bind_ {
-            typedef typename DirectedGraph::graph_type Graph;
-            typedef property_map<Graph, Tag> PropertyMap;
-            typedef typename PropertyMap::type type;
-            typedef typename PropertyMap::const_type const_type;
-        };
-    };
-
-    struct directed_graph_edge_property_selector {
-        template <class DirectedGraph, class Property, class Tag>
-        struct bind_ {
-            typedef typename DirectedGraph::graph_type Graph;
-            typedef property_map<Graph, Tag> PropertyMap;
-            typedef typename PropertyMap::type type;
-            typedef typename PropertyMap::const_type const_type;
-        };
-    };
-}
-
-template <>
-struct vertex_property_selector<directed_graph_tag>
-{ typedef detail::directed_graph_vertex_property_selector type; };
+template <DIRECTED_GRAPH_PARAMS, typename Property>
+struct property_map<DIRECTED_GRAPH, Property>: property_map<typename DIRECTED_GRAPH::graph_type, Property> {};
+
+template <DIRECTED_GRAPH_PARAMS>
+struct property_map<DIRECTED_GRAPH, vertex_all_t> {
+  typedef transform_value_property_map<
+            detail::remove_first_property,
+            typename property_map<typename DIRECTED_GRAPH::graph_type, vertex_all_t>::const_type>
+    const_type;
+  typedef transform_value_property_map<
+            detail::remove_first_property,
+            typename property_map<typename DIRECTED_GRAPH::graph_type, vertex_all_t>::type>
+    type;
+};
 
-template <>
-struct edge_property_selector<directed_graph_tag>
-{ typedef detail::directed_graph_edge_property_selector type; };
+template <DIRECTED_GRAPH_PARAMS>
+struct property_map<DIRECTED_GRAPH, edge_all_t> {
+  typedef transform_value_property_map<
+            detail::remove_first_property,
+            typename property_map<typename DIRECTED_GRAPH::graph_type, edge_all_t>::const_type>
+    const_type;
+  typedef transform_value_property_map<
+            detail::remove_first_property,
+            typename property_map<typename DIRECTED_GRAPH::graph_type, edge_all_t>::type>
+    type;
+};
 
 // PropertyGraph concepts
 template <DIRECTED_GRAPH_PARAMS, typename Property>
@@ -562,6 +558,26 @@ inline typename property_map<DIRECTED_GRAPH, Property>::const_type
 get(Property p, DIRECTED_GRAPH const& g)
 { return get(p, g.impl()); }
 
+template <DIRECTED_GRAPH_PARAMS>
+inline typename property_map<DIRECTED_GRAPH, vertex_all_t>::type
+get(vertex_all_t, DIRECTED_GRAPH& g)
+{ return typename property_map<DIRECTED_GRAPH, vertex_all_t>::type(detail::remove_first_property(), get(vertex_all, g.impl())); }
+
+template <DIRECTED_GRAPH_PARAMS>
+inline typename property_map<DIRECTED_GRAPH, vertex_all_t>::const_type
+get(vertex_all_t, DIRECTED_GRAPH const& g)
+{ return typename property_map<DIRECTED_GRAPH, vertex_all_t>::const_type(detail::remove_first_property(), get(vertex_all, g.impl())); }
+
+template <DIRECTED_GRAPH_PARAMS>
+inline typename property_map<DIRECTED_GRAPH, edge_all_t>::type
+get(edge_all_t, DIRECTED_GRAPH& g)
+{ return typename property_map<DIRECTED_GRAPH, edge_all_t>::type(detail::remove_first_property(), get(edge_all, g.impl())); }
+
+template <DIRECTED_GRAPH_PARAMS>
+inline typename property_map<DIRECTED_GRAPH, edge_all_t>::const_type
+get(edge_all_t, DIRECTED_GRAPH const& g)
+{ return typename property_map<DIRECTED_GRAPH, edge_all_t>::const_type(detail::remove_first_property(), get(edge_all, g.impl())); }
+
 template <DIRECTED_GRAPH_PARAMS, typename Property, typename Key>
 inline typename property_traits<
     typename property_map<
@@ -571,10 +587,40 @@ inline typename property_traits<
 get(Property p, DIRECTED_GRAPH const& g, Key const& k)
 { return get(p, g.impl(), k); }
 
+template <DIRECTED_GRAPH_PARAMS, typename Key>
+inline typename property_traits<
+    typename property_map<
+        typename DIRECTED_GRAPH::graph_type, vertex_all_t
+    >::const_type
+>::value_type
+get(vertex_all_t, DIRECTED_GRAPH const& g, Key const& k)
+{ return get(vertex_all, g.impl(), k).m_base; }
+
+template <DIRECTED_GRAPH_PARAMS, typename Key>
+inline typename property_traits<
+    typename property_map<
+        typename DIRECTED_GRAPH::graph_type, edge_all_t
+    >::const_type
+>::value_type
+get(edge_all_t, DIRECTED_GRAPH const& g, Key const& k)
+{ return get(edge_all, g.impl(), k).m_base; }
+
 template <DIRECTED_GRAPH_PARAMS, typename Property, typename Key, typename Value>
 inline void put(Property p, DIRECTED_GRAPH& g, Key const& k, Value const& v)
 { put(p, g.impl(), k, v); }
 
+template <DIRECTED_GRAPH_PARAMS, typename Key, typename Value>
+inline void put(vertex_all_t, DIRECTED_GRAPH& g, Key const& k, Value const& v)
+{ put(vertex_all, g.impl(), k,
+      typename DIRECTED_GRAPH::internal_vertex_property(get(vertex_index, g.impl(), k), v));
+}
+
+template <DIRECTED_GRAPH_PARAMS, typename Key, typename Value>
+inline void put(edge_all_t, DIRECTED_GRAPH& g, Key const& k, Value const& v)
+{ put(edge_all, g.impl(), k,
+      typename DIRECTED_GRAPH::internal_vertex_property(get(edge_index, g.impl(), k), v));
+}
+
 template <DIRECTED_GRAPH_PARAMS, class Property>
 typename graph_property<DIRECTED_GRAPH, Property>::type&
 get_property(DIRECTED_GRAPH& g, Property p)
@@ -590,35 +636,6 @@ void
 set_property(DIRECTED_GRAPH& g, Property p, Value v)
 { return set_property(g.impl(), p, v); }
 
-#ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES
-
-template <DIRECTED_GRAPH_PARAMS, typename Type, typename Bundle>
-inline typename property_map<DIRECTED_GRAPH, Type Bundle::*>::type
-get(Type Bundle::* p, DIRECTED_GRAPH& g) {
-    typedef typename property_map<
-        DIRECTED_GRAPH, Type Bundle::*
-    >::type return_type;
-    return return_type(&g, p);
-}
-
-template <DIRECTED_GRAPH_PARAMS, typename Type, typename Bundle>
-inline typename property_map<DIRECTED_GRAPH, Type Bundle::*>::const_type
-get(Type Bundle::* p, DIRECTED_GRAPH const& g) {
-    typedef typename property_map<
-        DIRECTED_GRAPH, Type Bundle::*
-    >::const_type return_type;
-    return return_type(&g, p);
-}
-
-template <DIRECTED_GRAPH_PARAMS, typename Type, typename Bundle, typename Key>
-inline Type get(Type Bundle::* p, DIRECTED_GRAPH const& g, Key const& k)
-{ return get(p, g.impl(), k); }
-
-template <DIRECTED_GRAPH_PARAMS, typename Type, typename Bundle, typename Key, typename Value>
-inline void put(Type Bundle::* p, DIRECTED_GRAPH& g, Key const& k, Value const& v)
-{ put(p, g.impl(), k, v); }
-#endif
-
 // Vertex index management
 
 template <DIRECTED_GRAPH_PARAMS>
diff --git a/include/boost/graph/dll_import_export.hpp b/include/boost/graph/dll_import_export.hpp
index cc369d1d1..d03fcd3f2 100644
--- a/include/boost/graph/dll_import_export.hpp
+++ b/include/boost/graph/dll_import_export.hpp
@@ -13,15 +13,13 @@
 
 #include <boost/config.hpp>
 
-#ifdef BOOST_HAS_DECLSPEC
-#  if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_GRAPH_DYN_LINK)
-#    ifdef BOOST_GRAPH_SOURCE
-#      define BOOST_GRAPH_DECL __declspec(dllexport)
-#    else
-#      define BOOST_GRAPH_DECL __declspec(dllimport)
-#    endif  // BOOST_GRAPH_SOURCE
-#  endif  // DYN_LINK
-#endif  // BOOST_HAS_DECLSPEC
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_GRAPH_DYN_LINK)
+#  ifdef BOOST_GRAPH_SOURCE
+#    define BOOST_GRAPH_DECL BOOST_SYMBOL_EXPORT
+#  else
+#    define BOOST_GRAPH_DECL BOOST_SYMBOL_IMPORT
+#  endif  // BOOST_GRAPH_SOURCE
+#endif  // DYN_LINK
 
 #ifndef BOOST_GRAPH_DECL
 #  define BOOST_GRAPH_DECL
diff --git a/include/boost/graph/dominator_tree.hpp b/include/boost/graph/dominator_tree.hpp
index db40cb73f..9371eee0d 100644
--- a/include/boost/graph/dominator_tree.hpp
+++ b/include/boost/graph/dominator_tree.hpp
@@ -13,6 +13,7 @@
 #include <deque>
 #include <set>
 #include <boost/graph/depth_first_search.hpp>
+#include <boost/concept/assert.hpp>
 
 // Dominator tree computation
 
@@ -244,7 +245,7 @@ namespace boost {
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
     typedef typename graph_traits<Graph>::vertices_size_type VerticesSizeType;
 
-    function_requires< BidirectionalGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph> ));
 
     const VerticesSizeType numOfVertices = num_vertices(g);
     if (numOfVertices == 0) return;
@@ -299,7 +300,7 @@ namespace boost {
     // Typedefs and concept check
     typedef typename graph_traits<Graph>::vertices_size_type VerticesSizeType;
 
-    function_requires< BidirectionalGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph> ));
 
     // 1. Depth first visit
     const VerticesSizeType numOfVertices = num_vertices(g);
@@ -388,7 +389,7 @@ namespace boost {
       iterator_property_map<typename std::vector< std::set<Vertex> >::iterator,
                             IndexMap> vertexSetMap;
 
-    function_requires<BidirectionalGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph> ));
 
     // 1. Finding dominator
     // 1.1. Initialize
diff --git a/include/boost/graph/eccentricity.hpp b/include/boost/graph/eccentricity.hpp
index 99f80a452..63797a830 100644
--- a/include/boost/graph/eccentricity.hpp
+++ b/include/boost/graph/eccentricity.hpp
@@ -7,9 +7,10 @@
 #ifndef BOOST_GRAPH_ECCENTRICITY_HPP
 #define BOOST_GRAPH_ECCENTRICITY_HPP
 
-#include <boost/utility.hpp>
+#include <boost/next_prior.hpp>
 #include <boost/config.hpp>
 #include <boost/graph/detail/geodesic.hpp>
+#include <boost/concept/assert.hpp>
 
 namespace boost
 {
@@ -19,9 +20,9 @@ template <typename Graph,
 inline typename property_traits<DistanceMap>::value_type
 eccentricity(const Graph& g, DistanceMap dist, Combinator combine)
 {
-    function_requires< GraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( GraphConcept<Graph> ));
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
-    function_requires< ReadablePropertyMapConcept<DistanceMap,Vertex> >();
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMap,Vertex> ));
     typedef typename property_traits<DistanceMap>::value_type Distance;
 
     return detail::combine_distances(g, dist, combine, Distance(0));
@@ -31,9 +32,9 @@ template <typename Graph, typename DistanceMap>
 inline typename property_traits<DistanceMap>::value_type
 eccentricity(const Graph& g, DistanceMap dist)
 {
-    function_requires< GraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( GraphConcept<Graph> ));
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
-    function_requires< ReadablePropertyMapConcept<DistanceMap,Vertex> >();
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMap,Vertex> ));
     typedef typename property_traits<DistanceMap>::value_type Distance;
 
     return eccentricity(g, dist, detail::maximize<Distance>());
@@ -44,12 +45,12 @@ inline std::pair<typename property_traits<EccentricityMap>::value_type,
                     typename property_traits<EccentricityMap>::value_type>
 all_eccentricities(const Graph& g, const DistanceMatrix& dist, EccentricityMap ecc)
 {
-    function_requires< VertexListGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
     typedef typename graph_traits<Graph>::vertex_iterator VertexIterator;
-    function_requires< ReadablePropertyMapConcept<DistanceMatrix,Vertex> >();
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMatrix,Vertex> ));
     typedef typename property_traits<DistanceMatrix>::value_type DistanceMap;
-    function_requires< WritablePropertyMapConcept<EccentricityMap,Vertex> >();
+    BOOST_CONCEPT_ASSERT(( WritablePropertyMapConcept<EccentricityMap,Vertex> ));
     typedef typename property_traits<EccentricityMap>::value_type Eccentricity;
     BOOST_USING_STD_MIN();
     BOOST_USING_STD_MAX();
@@ -76,10 +77,10 @@ inline std::pair<typename property_traits<EccentricityMap>::value_type,
                     typename property_traits<EccentricityMap>::value_type>
 radius_and_diameter(const Graph& g, EccentricityMap ecc)
 {
-    function_requires< VertexListGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
     typedef typename graph_traits<Graph>::vertex_iterator VertexIterator;
-    function_requires< ReadablePropertyMapConcept<EccentricityMap, Vertex> >();
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<EccentricityMap, Vertex> ));
     typedef typename property_traits<EccentricityMap>::value_type Eccentricity;
     BOOST_USING_STD_MIN();
     BOOST_USING_STD_MAX();
diff --git a/include/boost/graph/edge_coloring.hpp b/include/boost/graph/edge_coloring.hpp
new file mode 100644
index 000000000..8eb79ad43
--- /dev/null
+++ b/include/boost/graph/edge_coloring.hpp
@@ -0,0 +1,196 @@
+//=======================================================================
+// Copyright 2013 Maciej Piechotka
+// Authors: Maciej Piechotka
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//=======================================================================
+#ifndef BOOST_GRAPH_EDGE_COLORING_HPP
+#define BOOST_GRAPH_EDGE_COLORING_HPP
+
+#include <boost/graph/graph_traits.hpp>
+#include <boost/graph/iteration_macros.hpp>
+#include <boost/graph/properties.hpp>
+#include <algorithm>
+#include <limits>
+#include <vector>
+
+/* This algorithm is to find coloring of an edges
+
+   Reference:
+
+   Misra, J., & Gries, D. (1992). A constructive proof of Vizing's
+   theorem. In Information Processing Letters.
+*/
+
+namespace boost {
+  namespace detail {
+    template<typename Graph, typename ColorMap>
+    bool
+    is_free(const Graph &g,
+            ColorMap color,
+            typename boost::graph_traits<Graph>::vertex_descriptor u,
+            typename boost::property_traits<ColorMap>::value_type free_color)
+    {
+      typedef typename boost::property_traits<ColorMap>::value_type color_t;
+      if (free_color == (std::numeric_limits<color_t>::max)())
+        return false;
+      BGL_FORALL_OUTEDGES_T(u, e, g, Graph) {
+        if (get(color, e) == free_color) {
+          return false;
+        }
+      }
+      return true;
+    }
+
+    template<typename Graph, typename ColorMap>
+    std::vector<typename boost::graph_traits<Graph>::vertex_descriptor>
+    maximal_fan(const Graph &g,
+                ColorMap color,
+                typename boost::graph_traits<Graph>::vertex_descriptor x,
+                typename boost::graph_traits<Graph>::vertex_descriptor y)
+    {
+      typedef typename boost::graph_traits<Graph>::vertex_descriptor vertex_t;
+      std::vector<vertex_t> fan;
+      fan.push_back(y);
+      bool extended;
+      do {
+        extended = false;
+        BGL_FORALL_OUTEDGES_T(x, e, g, Graph) {
+          vertex_t v = target(e, g);
+          if (is_free(g, color, fan.back(), get(color, e)) &&
+              std::find(fan.begin(), fan.end(), v) == fan.end()) {
+            fan.push_back(v);
+            extended = true;
+          }
+        }
+      } while(extended);
+      return fan;
+    }
+    template<typename Graph, typename ColorMap>
+    typename boost::property_traits<ColorMap>::value_type
+    find_free_color(const Graph &g,
+                    ColorMap color,
+                    typename boost::graph_traits<Graph>::vertex_descriptor u)
+    {
+      typename boost::property_traits<ColorMap>::value_type c = 0;
+      while (!is_free(g, color, u, c)) c++;
+      return c;
+    }
+
+    template<typename Graph, typename ColorMap>
+    void
+    invert_cd_path(const Graph &g,
+                   ColorMap color,
+                   typename boost::graph_traits<Graph>::vertex_descriptor x,
+                   typename boost::graph_traits<Graph>::edge_descriptor eold,
+                   typename boost::property_traits<ColorMap>::value_type c,
+                   typename boost::property_traits<ColorMap>::value_type d)
+    {
+      put(color, eold, d);
+      BGL_FORALL_OUTEDGES_T(x, e, g, Graph) {
+        if (get(color, e) == d && e != eold) {
+          invert_cd_path(g, color, target(e, g), e, d, c);
+          return;
+        }
+      }
+    }
+
+    template<typename Graph, typename ColorMap>
+    void
+    invert_cd_path(const Graph &g,
+                   ColorMap color,
+                   typename boost::graph_traits<Graph>::vertex_descriptor x,
+                   typename boost::property_traits<ColorMap>::value_type c,
+                   typename boost::property_traits<ColorMap>::value_type d)
+    {
+      BGL_FORALL_OUTEDGES_T(x, e, g, Graph) {
+        if (get(color, e) == d) {
+          invert_cd_path(g, color, target(e, g), e, d, c);
+          return;
+        }
+      }
+    }
+    
+    template<typename Graph, typename ColorMap, typename ForwardIterator>
+    void
+    rotate_fan(const Graph &g,
+               ColorMap color,
+               typename boost::graph_traits<Graph>::vertex_descriptor x,
+               ForwardIterator begin,
+               ForwardIterator end)
+    {
+      typedef typename boost::graph_traits<Graph>::edge_descriptor edge_t;
+      if (begin == end) {
+        return;
+      }
+      edge_t previous = edge(x, *begin, g).first;
+      for (begin++; begin != end; begin++) {
+        edge_t current = edge(x, *begin, g).first;
+        put(color, previous, get(color, current));
+        previous = current;
+      }
+    }
+
+    template<typename Graph, typename ColorMap>
+    class find_free_in_fan
+    {
+    public:
+      find_free_in_fan(const Graph &graph,
+                       const ColorMap color,
+                       typename boost::property_traits<ColorMap>::value_type d)
+        : graph(graph),
+          color(color),
+          d(d) {}
+      bool operator()(const typename boost::graph_traits<Graph>::vertex_descriptor u) const {
+        return is_free(graph, color, u, d);
+      }
+    private:
+      const Graph &graph;
+      const ColorMap color;
+      const typename boost::property_traits<ColorMap>::value_type d;
+    };
+  }
+
+  template<typename Graph, typename ColorMap>
+  typename boost::property_traits<ColorMap>::value_type
+  color_edge(const Graph &g,
+             ColorMap color,
+             typename boost::graph_traits<Graph>::edge_descriptor e)
+  {
+    typedef typename boost::graph_traits<Graph>::vertex_descriptor vertex_t;
+    typedef typename boost::property_traits<ColorMap>::value_type color_t;
+    typedef typename std::vector<vertex_t>::iterator fan_iterator;
+    using namespace detail;
+    vertex_t x = source(e, g), y = target(e, g);
+    std::vector<vertex_t> fan = maximal_fan(g, color, x, y);
+    color_t c = find_free_color(g, color, x);
+    color_t d = find_free_color(g, color, fan.back());
+    invert_cd_path(g, color, x, c, d);
+    fan_iterator w = std::find_if(fan.begin(),
+                                  fan.end(),
+                                  find_free_in_fan<Graph, ColorMap>(g, color, d));
+    rotate_fan(g, color, x, fan.begin(), w + 1);
+    put(color, edge(x, *w, g).first, d);
+    return (std::max)(c, d);
+  }
+
+  template<typename Graph, typename ColorMap>
+  typename boost::property_traits<ColorMap>::value_type
+  edge_coloring(const Graph &g,
+                ColorMap color)
+  {
+    typedef typename boost::property_traits<ColorMap>::value_type color_t;
+    BGL_FORALL_EDGES_T(e, g, Graph) {
+      put(color, e, (std::numeric_limits<color_t>::max)());
+    }
+    color_t colors = 0;
+    BGL_FORALL_EDGES_T(e, g, Graph) {
+      colors = (std::max)(colors, color_edge(g, color, e) + 1);
+    }
+    return colors;
+  }
+}
+
+#endif
diff --git a/include/boost/graph/edmonds_karp_max_flow.hpp b/include/boost/graph/edmonds_karp_max_flow.hpp
index 43cc592d2..377e6f14d 100644
--- a/include/boost/graph/edmonds_karp_max_flow.hpp
+++ b/include/boost/graph/edmonds_karp_max_flow.hpp
@@ -52,21 +52,21 @@ namespace boost {
 
       // find minimum residual capacity along the augmenting path
       FlowValue delta = (std::numeric_limits<FlowValue>::max)();
-      e = p[sink];
+      e = get(p, sink);
       do {
         BOOST_USING_STD_MIN();
-        delta = min BOOST_PREVENT_MACRO_SUBSTITUTION(delta, residual_capacity[e]);
+        delta = min BOOST_PREVENT_MACRO_SUBSTITUTION(delta, get(residual_capacity, e));
         u = source(e, g);
-        e = p[u];
+        e = get(p, u);
       } while (u != src);
 
       // push delta units of flow along the augmenting path
-      e = p[sink];
+      e = get(p, sink);
       do {
-        residual_capacity[e] -= delta;
-        residual_capacity[reverse_edge[e]] += delta;
+        put(residual_capacity, e, get(residual_capacity, e) - delta);
+        put(residual_capacity, get(reverse_edge, e), get(residual_capacity, get(reverse_edge, e)) + delta);
         u = source(e, g);
-        e = p[u];
+        e = get(p, u);
       } while (u != src);
     }
 
@@ -94,22 +94,22 @@ namespace boost {
     typename graph_traits<Graph>::out_edge_iterator ei, e_end;
     for (boost::tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter)
       for (boost::tie(ei, e_end) = out_edges(*u_iter, g); ei != e_end; ++ei)
-        res[*ei] = cap[*ei];
+        put(res, *ei, get(cap, *ei));
     
-    color[sink] = Color::gray();
-    while (color[sink] != Color::white()) {
+    put(color, sink, Color::gray());
+    while (get(color, sink) != Color::white()) {
       boost::queue<vertex_t> Q;
       breadth_first_search
         (detail::residual_graph(g, res), src, Q,
          make_bfs_visitor(record_edge_predecessors(pred, on_tree_edge())),
          color);
-      if (color[sink] != Color::white())
+      if (get(color, sink) != Color::white())
         detail::augment(g, src, sink, pred, res, rev);
     } // while
     
     typename property_traits<CapacityEdgeMap>::value_type flow = 0;
     for (boost::tie(ei, e_end) = out_edges(src, g); ei != e_end; ++ei)
-      flow += (cap[*ei] - res[*ei]);
+      flow += (get(cap, *ei) - get(res, *ei));
     return flow;
   } // edmonds_karp_max_flow()
   
@@ -140,7 +140,7 @@ namespace boost {
       }
     };
     template<>
-    struct edmonds_karp_dispatch2<detail::error_property_not_found> {
+    struct edmonds_karp_dispatch2<param_not_found> {
       template <class Graph, class PredMap, class P, class T, class R>
       static typename edge_capacity_value<Graph, P, T, R>::type
       apply
@@ -149,9 +149,8 @@ namespace boost {
        typename graph_traits<Graph>::vertex_descriptor sink,
        PredMap pred,
        const bgl_named_params<P, T, R>& params,
-       detail::error_property_not_found)
+       param_not_found)
       {
-        typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor;
         typedef typename graph_traits<Graph>::vertices_size_type size_type;
         size_type n = is_default_param(get_param(params, vertex_color)) ?
           num_vertices(g) : 1;
@@ -183,13 +182,13 @@ namespace boost {
             const bgl_named_params<P, T, R>& params,
             PredMap pred)
       {
-        typedef typename property_value< bgl_named_params<P,T,R>, vertex_color_t>::type C;
+        typedef typename get_param_type< vertex_color_t, bgl_named_params<P,T,R> >::type C;
         return edmonds_karp_dispatch2<C>::apply
           (g, src, sink, pred, params, get_param(params, vertex_color));
       }
     };
     template<>
-    struct edmonds_karp_dispatch1<detail::error_property_not_found> {
+    struct edmonds_karp_dispatch1<param_not_found> {
 
       template <class Graph, class P, class T, class R>
       static typename edge_capacity_value<Graph, P, T, R>::type
@@ -198,7 +197,7 @@ namespace boost {
        typename graph_traits<Graph>::vertex_descriptor src,
        typename graph_traits<Graph>::vertex_descriptor sink,
        const bgl_named_params<P, T, R>& params,
-       detail::error_property_not_found)
+       param_not_found)
       {
         typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor;
         typedef typename graph_traits<Graph>::vertices_size_type size_type;
@@ -206,7 +205,7 @@ namespace boost {
           num_vertices(g) : 1;
         std::vector<edge_descriptor> pred_vec(n);
         
-        typedef typename property_value< bgl_named_params<P,T,R>, vertex_color_t>::type C;
+        typedef typename get_param_type< vertex_color_t, bgl_named_params<P,T,R> >::type C;
         return edmonds_karp_dispatch2<C>::apply
           (g, src, sink, 
            make_iterator_property_map(pred_vec.begin(), choose_const_pmap
@@ -227,7 +226,7 @@ namespace boost {
      typename graph_traits<Graph>::vertex_descriptor sink,
      const bgl_named_params<P, T, R>& params)
   {
-    typedef typename property_value< bgl_named_params<P,T,R>, vertex_predecessor_t>::type Pred;
+    typedef typename get_param_type< vertex_predecessor_t, bgl_named_params<P,T,R> >::type Pred;
     return detail::edmonds_karp_dispatch1<Pred>::apply
       (g, src, sink, params, get_param(params, vertex_predecessor));
   }
diff --git a/include/boost/graph/erdos_renyi_generator.hpp b/include/boost/graph/erdos_renyi_generator.hpp
index a45944168..5be06d79d 100644
--- a/include/boost/graph/erdos_renyi_generator.hpp
+++ b/include/boost/graph/erdos_renyi_generator.hpp
@@ -10,7 +10,7 @@
 #ifndef BOOST_GRAPH_ERDOS_RENYI_GENERATOR_HPP
 #define BOOST_GRAPH_ERDOS_RENYI_GENERATOR_HPP
 
-#include <cassert>
+#include <boost/assert.hpp>
 #include <iterator>
 #include <utility>
 #include <boost/shared_ptr.hpp>
@@ -155,8 +155,8 @@ namespace boost {
       // bernoulli_distribution would need to be run until it returns true.
       // Thus, this distribution can be used to step through the edges
       // which are actually present.
-      assert (src != (std::numeric_limits<vertices_size_type>::max)() &&
-              src != n);
+      BOOST_ASSERT (src != (std::numeric_limits<vertices_size_type>::max)() &&
+                    src != n);
       while (src != n) {
         vertices_size_type increment = rand_vertex(*gen);
         size_t tgt_index_limit =
diff --git a/include/boost/graph/filtered_graph.hpp b/include/boost/graph/filtered_graph.hpp
index 764b2d7d1..74fea4611 100644
--- a/include/boost/graph/filtered_graph.hpp
+++ b/include/boost/graph/filtered_graph.hpp
@@ -195,7 +195,6 @@ namespace boost {
 
     typedef filtered_graph_tag graph_tag;
 
-#ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES
     // Bundled properties support
     template<typename Descriptor>
     typename graph::detail::bundled_result<Graph, Descriptor>::type&
@@ -206,11 +205,10 @@ namespace boost {
     typename graph::detail::bundled_result<Graph, Descriptor>::type const&
     operator[](Descriptor x) const
     { return this->m_g[x]; }
-#endif // BOOST_GRAPH_NO_BUNDLED_PROPERTIES
 
     static vertex_descriptor null_vertex()
     {
-       return Graph::null_vertex();
+       return Traits::null_vertex();
     }
 
     //private:
@@ -222,19 +220,21 @@ namespace boost {
   template <typename Graph, 
             typename EdgePredicate,
             typename VertexPredicate>
-  struct vertex_property_type<filtered_graph<Graph, EdgePredicate, VertexPredicate> > {
-    typedef typename vertex_property_type<Graph>::type type;
-  };
+  struct vertex_property_type<filtered_graph<Graph, EdgePredicate, VertexPredicate> >:
+    vertex_property_type<Graph> {};
 
   template <typename Graph, 
             typename EdgePredicate,
             typename VertexPredicate>
-  struct edge_property_type<filtered_graph<Graph, EdgePredicate, VertexPredicate> > {
-    typedef typename edge_property_type<Graph>::type type;
-  };
+  struct edge_property_type<filtered_graph<Graph, EdgePredicate, VertexPredicate> >:
+    edge_property_type<Graph> {};
 
+  template <typename Graph, 
+            typename EdgePredicate,
+            typename VertexPredicate>
+  struct graph_property_type<filtered_graph<Graph, EdgePredicate, VertexPredicate> >:
+    graph_property_type<Graph> {};
 
-#ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES
   template<typename Graph, typename EdgePredicate, typename VertexPredicate>
   struct vertex_bundle_type<filtered_graph<Graph, EdgePredicate, 
                                            VertexPredicate> > 
@@ -244,7 +244,11 @@ namespace boost {
   struct edge_bundle_type<filtered_graph<Graph, EdgePredicate, 
                                          VertexPredicate> > 
     : edge_bundle_type<Graph> { };
-#endif // BOOST_GRAPH_NO_BUNDLED_PROPERTIES
+
+  template<typename Graph, typename EdgePredicate, typename VertexPredicate>
+  struct graph_bundle_type<filtered_graph<Graph, EdgePredicate, 
+                                          VertexPredicate> > 
+    : graph_bundle_type<Graph> { };
 
   //===========================================================================
   // Non-member functions for the Filtered Edge Graph
diff --git a/include/boost/graph/find_flow_cost.hpp b/include/boost/graph/find_flow_cost.hpp
new file mode 100644
index 000000000..e4d6f404e
--- /dev/null
+++ b/include/boost/graph/find_flow_cost.hpp
@@ -0,0 +1,52 @@
+//=======================================================================
+// Copyright 2013 University of Warsaw.
+// Authors: Piotr Wygocki 
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//=======================================================================
+#ifndef BOOST_GRAPH_FIND_FLOW_COST_HPP
+#define BOOST_GRAPH_FIND_FLOW_COST_HPP
+
+#include <boost/graph/iteration_macros.hpp>
+
+namespace boost {
+
+template<class Graph, class Capacity, class ResidualCapacity, class Weight>
+typename property_traits<typename property_map < Graph, edge_capacity_t >::type>::value_type
+find_flow_cost(const Graph & g, Capacity capacity, ResidualCapacity residual_capacity, Weight weight) {
+    typedef typename property_traits<typename property_map<Graph, edge_weight_t>::const_type>::value_type Cost;
+
+    Cost cost = 0;
+    BGL_FORALL_EDGES_T(e, g, Graph) {
+        if(get(capacity, e) > Cost(0)) {
+            cost +=  (get(capacity, e) - get(residual_capacity, e)) * get(weight, e);
+        } 
+    }
+    return cost;
+}
+
+template <class Graph, class P, class T, class R> 
+typename property_traits<typename property_map < Graph, edge_capacity_t >::type>::value_type
+find_flow_cost(const Graph & g,
+               const bgl_named_params<P, T, R>& params) {
+    return find_flow_cost(g,
+           choose_const_pmap(get_param(params, edge_capacity), g, edge_capacity),
+           choose_const_pmap(get_param(params, edge_residual_capacity), 
+                       g, edge_residual_capacity),
+           choose_const_pmap(get_param(params, edge_weight), g, edge_weight));
+}
+
+template <class Graph>
+typename property_traits<typename property_map < Graph, edge_capacity_t >::type>::value_type
+find_flow_cost(const Graph &g) {
+    bgl_named_params<int, buffer_param_t> params(0);
+    return find_flow_cost(g, params);
+}
+
+
+} //boost
+
+#endif /* BOOST_GRAPH_FIND_FLOW_COST_HPP */
+
diff --git a/include/boost/graph/floyd_warshall_shortest.hpp b/include/boost/graph/floyd_warshall_shortest.hpp
index 48dba7126..472995f04 100644
--- a/include/boost/graph/floyd_warshall_shortest.hpp
+++ b/include/boost/graph/floyd_warshall_shortest.hpp
@@ -34,6 +34,7 @@
 #include <boost/graph/named_function_params.hpp>
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/relax.hpp>
+#include <boost/concept/assert.hpp>
 
 namespace boost
 {
@@ -84,7 +85,7 @@ namespace boost
     const BinaryFunction& combine, const Infinity& inf, 
     const Zero& zero)
   {
-    function_requires<VertexListGraphConcept<VertexListGraph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<VertexListGraph> ));
   
     return detail::floyd_warshall_dispatch(g, d, compare, combine, 
     inf, zero);
@@ -101,9 +102,9 @@ namespace boost
     const BinaryPredicate& compare, const BinaryFunction& combine, 
     const Infinity& inf, const Zero& zero)
   {
-    function_requires<VertexListGraphConcept<VertexAndEdgeListGraph> >();
-    function_requires<EdgeListGraphConcept<VertexAndEdgeListGraph> >();
-    function_requires<IncidenceGraphConcept<VertexAndEdgeListGraph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<VertexAndEdgeListGraph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<VertexAndEdgeListGraph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<VertexAndEdgeListGraph> ));
   
     typename graph_traits<VertexAndEdgeListGraph>::vertex_iterator 
       firstv, lastv, firstv2, lastv2;
@@ -163,14 +164,16 @@ namespace boost
       const bgl_named_params<P, T, R>& params)
     {
       typedef typename property_traits<WeightMap>::value_type WM;
+      WM inf =
+        choose_param(get_param(params, distance_inf_t()), 
+          std::numeric_limits<WM>::max BOOST_PREVENT_MACRO_SUBSTITUTION());
     
       return floyd_warshall_initialized_all_pairs_shortest_paths(g, d,
         choose_param(get_param(params, distance_compare_t()), 
           std::less<WM>()),
         choose_param(get_param(params, distance_combine_t()), 
-          closed_plus<WM>()),
-        choose_param(get_param(params, distance_inf_t()), 
-          std::numeric_limits<WM>::max BOOST_PREVENT_MACRO_SUBSTITUTION()),
+          closed_plus<WM>(inf)),
+        inf,
         choose_param(get_param(params, distance_zero_t()), 
           WM()));
     }
@@ -185,13 +188,15 @@ namespace boost
     {
       typedef typename property_traits<WeightMap>::value_type WM;
     
+      WM inf =
+        choose_param(get_param(params, distance_inf_t()), 
+          std::numeric_limits<WM>::max BOOST_PREVENT_MACRO_SUBSTITUTION());
       return floyd_warshall_all_pairs_shortest_paths(g, d, w,
         choose_param(get_param(params, distance_compare_t()), 
           std::less<WM>()),
         choose_param(get_param(params, distance_combine_t()), 
-          closed_plus<WM>()),
-        choose_param(get_param(params, distance_inf_t()), 
-          std::numeric_limits<WM>::max BOOST_PREVENT_MACRO_SUBSTITUTION()),
+          closed_plus<WM>(inf)),
+        inf,
         choose_param(get_param(params, distance_zero_t()), 
           WM()));
     }
diff --git a/include/boost/graph/fruchterman_reingold.hpp b/include/boost/graph/fruchterman_reingold.hpp
index 4ce502e83..01d080a41 100644
--- a/include/boost/graph/fruchterman_reingold.hpp
+++ b/include/boost/graph/fruchterman_reingold.hpp
@@ -282,7 +282,6 @@ fruchterman_reingold_force_directed_layout
   Cooling         cool,
   DisplacementMap displacement)
 {
-  typedef typename Topology::point_type Point;
   typedef typename graph_traits<Graph>::vertex_iterator   vertex_iterator;
   typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor;
   typedef typename graph_traits<Graph>::edge_iterator     edge_iterator;
@@ -363,7 +362,7 @@ namespace detail {
   };
 
   template<>
-  struct fr_force_directed_layout<error_property_not_found>
+  struct fr_force_directed_layout<param_not_found>
   {
     template<typename Topology, typename Graph, typename PositionMap, 
              typename AttractiveForce, typename RepulsiveForce,
@@ -377,7 +376,7 @@ namespace detail {
         RepulsiveForce  repulsive_force,
         ForcePairs      force_pairs,
         Cooling         cool,
-        error_property_not_found,
+        param_not_found,
         const bgl_named_params<Param, Tag, Rest>& params)
     {
       typedef typename Topology::point_difference_type PointDiff;
@@ -404,8 +403,7 @@ fruchterman_reingold_force_directed_layout
    const Topology& topology,
    const bgl_named_params<Param, Tag, Rest>& params)
 {
-  typedef typename property_value<bgl_named_params<Param,Tag,Rest>,
-                                  vertex_displacement_t>::type D;
+  typedef typename get_param_type<vertex_displacement_t, bgl_named_params<Param,Tag,Rest> >::type D;
 
   detail::fr_force_directed_layout<D>::run
     (g, position, topology, 
diff --git a/include/boost/graph/geodesic_distance.hpp b/include/boost/graph/geodesic_distance.hpp
index a4d702749..d76d321e1 100644
--- a/include/boost/graph/geodesic_distance.hpp
+++ b/include/boost/graph/geodesic_distance.hpp
@@ -9,6 +9,7 @@
 
 #include <boost/graph/detail/geodesic.hpp>
 #include <boost/graph/exterior_property.hpp>
+#include <boost/concept/assert.hpp>
 
 namespace boost
 {
@@ -25,10 +26,10 @@ struct mean_geodesic_measure
 
     result_type operator ()(distance_type d, const Graph& g)
     {
-        function_requires< VertexListGraphConcept<Graph> >();
-        function_requires< NumericValueConcept<DistanceType> >();
-        function_requires< NumericValueConcept<ResultType> >();
-        function_requires< AdaptableBinaryFunctionConcept<Divides,ResultType,ResultType,ResultType> >();
+        BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+        BOOST_CONCEPT_ASSERT(( NumericValueConcept<DistanceType> ));
+        BOOST_CONCEPT_ASSERT(( NumericValueConcept<ResultType> ));
+        BOOST_CONCEPT_ASSERT(( AdaptableBinaryFunctionConcept<Divides,ResultType,ResultType,ResultType> ));
 
         return (d == base_type::infinite_distance())
             ? base_type::infinite_result()
@@ -69,8 +70,8 @@ struct mean_graph_distance_measure
 
     inline result_type operator ()(distance_type d, const Graph& g)
     {
-        function_requires< VertexListGraphConcept<Graph> >();
-        function_requires< NumericValueConcept<DistanceType> >();
+        BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+        BOOST_CONCEPT_ASSERT(( NumericValueConcept<DistanceType> ));
 
         if(d == base_type::infinite_distance()) {
             return base_type::infinite_result();
@@ -99,7 +100,7 @@ mean_geodesic(const Graph& g,
                 Measure measure,
                 Combinator combine)
 {
-    function_requires< DistanceMeasureConcept<Measure,Graph> >();
+    BOOST_CONCEPT_ASSERT(( DistanceMeasureConcept<Measure,Graph> ));
     typedef typename Measure::distance_type Distance;
 
     Distance n = detail::combine_distances(g, dist, combine, Distance(0));
@@ -112,7 +113,7 @@ template <typename Graph,
 inline typename Measure::result_type
 mean_geodesic(const Graph& g, DistanceMap dist, Measure measure)
 {
-    function_requires< DistanceMeasureConcept<Measure,Graph> >();
+    BOOST_CONCEPT_ASSERT(( DistanceMeasureConcept<Measure,Graph> ));
     typedef typename Measure::distance_type Distance;
 
     return mean_geodesic(g, dist, measure, std::plus<Distance>());
@@ -139,15 +140,15 @@ all_mean_geodesics(const Graph& g,
                     GeodesicMap geo,
                     Measure measure)
 {
-    function_requires< VertexListGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
     typedef typename graph_traits<Graph>::vertex_iterator VertexIterator;
-    function_requires< ReadablePropertyMapConcept<DistanceMatrixMap,Vertex> >();
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMatrixMap,Vertex> ));
     typedef typename property_traits<DistanceMatrixMap>::value_type DistanceMap;
-    function_requires< DistanceMeasureConcept<Measure,Graph> >();
+    BOOST_CONCEPT_ASSERT(( DistanceMeasureConcept<Measure,Graph> ));
     typedef typename Measure::result_type Result;
-    function_requires< WritablePropertyMapConcept<GeodesicMap,Vertex> >();
-    function_requires< NumericValueConcept<Result> >();
+    BOOST_CONCEPT_ASSERT(( WritablePropertyMapConcept<GeodesicMap,Vertex> ));
+    BOOST_CONCEPT_ASSERT(( NumericValueConcept<Result> ));
 
     // NOTE: We could compute the mean geodesic here by performing additional
     // computations (i.e., adding and dividing). However, I don't really feel
@@ -156,7 +157,7 @@ all_mean_geodesics(const Graph& g,
     Result inf = numeric_values<Result>::infinity();
     Result sum = numeric_values<Result>::zero();
     VertexIterator i, end;
-    for(tie(i, end) = vertices(g); i != end; ++i) {
+    for(boost::tie(i, end) = vertices(g); i != end; ++i) {
         DistanceMap dm = get(dist, *i);
         Result r = mean_geodesic(g, dm, measure);
         put(geo, *i, r);
@@ -178,11 +179,11 @@ template <typename Graph, typename DistanceMatrixMap, typename GeodesicMap>
 inline typename property_traits<GeodesicMap>::value_type
 all_mean_geodesics(const Graph& g, DistanceMatrixMap dist, GeodesicMap geo)
 {
-    function_requires< GraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( GraphConcept<Graph> ));
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
-    function_requires< ReadablePropertyMapConcept<DistanceMatrixMap,Vertex> >();
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<DistanceMatrixMap,Vertex> ));
     typedef typename property_traits<DistanceMatrixMap>::value_type DistanceMap;
-    function_requires< WritablePropertyMapConcept<GeodesicMap,Vertex> >();
+    BOOST_CONCEPT_ASSERT(( WritablePropertyMapConcept<GeodesicMap,Vertex> ));
     typedef typename property_traits<GeodesicMap>::value_type Result;
 
     return all_mean_geodesics(g, dist, geo, measure_mean_geodesic<Result>(g, DistanceMap()));
@@ -193,7 +194,7 @@ template <typename Graph, typename GeodesicMap, typename Measure>
 inline typename Measure::result_type
 small_world_distance(const Graph& g, GeodesicMap geo, Measure measure)
 {
-    function_requires< DistanceMeasureConcept<Measure,Graph> >();
+    BOOST_CONCEPT_ASSERT(( DistanceMeasureConcept<Measure,Graph> ));
     typedef typename Measure::result_type Result;
 
     Result sum = detail::combine_distances(g, geo, std::plus<Result>(), Result(0));
diff --git a/include/boost/graph/graph_archetypes.hpp b/include/boost/graph/graph_archetypes.hpp
index 9b364bb81..81f9c2c8a 100644
--- a/include/boost/graph/graph_archetypes.hpp
+++ b/include/boost/graph/graph_archetypes.hpp
@@ -53,6 +53,8 @@ namespace boost { // should use a different namespace for this
     typedef void in_edge_iterator;
     typedef void vertex_iterator;
     typedef void edge_iterator;
+
+    static vertex_descriptor null_vertex() {return vertex_descriptor();}
   };
   template <typename V, typename D, typename P, typename B>
   V source(const typename incidence_graph_archetype<V,D,P,B>::edge_descriptor&,
@@ -105,6 +107,8 @@ namespace boost { // should use a different namespace for this
     typedef void out_edge_iterator;
     typedef void vertex_iterator;
     typedef void edge_iterator;
+
+    static vertex_descriptor null_vertex() {return vertex_descriptor();}
   };
   
   template <typename V, typename D, typename P, typename B>
@@ -154,6 +158,8 @@ namespace boost { // should use a different namespace for this
 
     typedef void in_edge_iterator;
     typedef void edge_iterator;
+
+    static vertex_descriptor null_vertex() {return vertex_descriptor();}
   };
   
   template <typename V, typename D, typename P, typename B>
diff --git a/include/boost/graph/graph_as_tree.hpp b/include/boost/graph/graph_as_tree.hpp
index 3758c3f00..721e503e8 100644
--- a/include/boost/graph/graph_as_tree.hpp
+++ b/include/boost/graph/graph_as_tree.hpp
@@ -50,13 +50,9 @@ namespace boost {
   
   template <class Graph, class ParentMap
           , class Node 
-#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
              = typename graph_traits<Graph>::vertex_descriptor
-#endif
           , class ChIt
-#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
               = typename graph_traits<Graph>::adjacency_iterator
-#endif
            >
   class graph_as_tree
     : public graph_as_tree_base<Graph, Node, ChIt, 
diff --git a/include/boost/graph/graph_concepts.hpp b/include/boost/graph/graph_concepts.hpp
index 7c2b2795b..875f81848 100644
--- a/include/boost/graph/graph_concepts.hpp
+++ b/include/boost/graph/graph_concepts.hpp
@@ -20,7 +20,11 @@
 #include <boost/graph/numeric_values.hpp>
 #include <boost/graph/buffer_concepts.hpp>
 #include <boost/concept_check.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/static_assert.hpp>
 #include <boost/detail/workaround.hpp>
+#include <boost/concept/assert.hpp>
 
 #include <boost/concept/detail/concept_def.hpp>
 namespace boost
@@ -34,7 +38,6 @@ namespace boost
 // It is needed in order to allow us to write using boost::vertices as
 // needed for ADL when using vector_as_graph below.
 #if !defined(BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP)            \
- && !BOOST_WORKAROUND(__GNUC__, <= 2)                       \
  && !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 # define BOOST_VECTOR_AS_GRAPH_GRAPH_ADL_HACK
 #endif
@@ -54,12 +57,10 @@ typename T::ThereReallyIsNoMemberByThisNameInT vertices(T const&);
     BOOST_concept(Graph,(G))
     {
         typedef typename graph_traits<G>::vertex_descriptor vertex_descriptor;
+        typedef typename graph_traits<G>::edge_descriptor edge_descriptor;
         typedef typename graph_traits<G>::directed_category directed_category;
-        typedef typename graph_traits<G>::edge_parallel_category
-        edge_parallel_category;
-
-        typedef typename graph_traits<G>::traversal_category
-        traversal_category;
+        typedef typename graph_traits<G>::edge_parallel_category edge_parallel_category; 
+        typedef typename graph_traits<G>::traversal_category traversal_category;
 
         BOOST_CONCEPT_USAGE(Graph)
         {
@@ -74,11 +75,12 @@ typename T::ThereReallyIsNoMemberByThisNameInT vertices(T const&);
         : Graph<G>
     {
         typedef typename graph_traits<G>::edge_descriptor edge_descriptor;
-        typedef typename graph_traits<G>::out_edge_iterator
-        out_edge_iterator;
+        typedef typename graph_traits<G>::out_edge_iterator out_edge_iterator;
+        typedef typename graph_traits<G>::degree_size_type degree_size_type;
+        typedef typename graph_traits<G>::traversal_category traversal_category;
 
-        typedef typename graph_traits<G>::traversal_category
-        traversal_category;
+        BOOST_STATIC_ASSERT((boost::mpl::not_<boost::is_same<out_edge_iterator, void> >::value));
+        BOOST_STATIC_ASSERT((boost::mpl::not_<boost::is_same<degree_size_type, void> >::value));
 
         BOOST_CONCEPT_USAGE(IncidenceGraph) {
             BOOST_CONCEPT_ASSERT((MultiPassInputIterator<out_edge_iterator>));
@@ -122,6 +124,8 @@ typename T::ThereReallyIsNoMemberByThisNameInT vertices(T const&);
         BOOST_CONCEPT_ASSERT((Convertible<traversal_category,
             bidirectional_graph_tag>));
 
+        BOOST_STATIC_ASSERT((boost::mpl::not_<boost::is_same<in_edge_iterator, void> >::value));
+
         p = in_edges(v, g);
         n = in_degree(v, g);
         e = *p.first;
@@ -152,6 +156,8 @@ typename T::ThereReallyIsNoMemberByThisNameInT vertices(T const&);
         BOOST_CONCEPT_ASSERT((Convertible<traversal_category,
             adjacency_graph_tag>));
 
+        BOOST_STATIC_ASSERT((boost::mpl::not_<boost::is_same<adjacency_iterator, void> >::value));
+
         p = adjacent_vertices(v, g);
         v = *p.first;
         const_constraints(g);
@@ -177,6 +183,9 @@ typename T::ThereReallyIsNoMemberByThisNameInT vertices(T const&);
         BOOST_CONCEPT_ASSERT((Convertible<traversal_category,
             vertex_list_graph_tag>));
 
+        BOOST_STATIC_ASSERT((boost::mpl::not_<boost::is_same<vertex_iterator, void> >::value));
+        BOOST_STATIC_ASSERT((boost::mpl::not_<boost::is_same<vertices_size_type, void> >::value));
+
 #ifdef BOOST_VECTOR_AS_GRAPH_GRAPH_ADL_HACK
         // dwa 2003/7/11 -- This clearly shouldn't be necessary, but if
         // you want to use vector_as_graph, it is!  I'm sure the graph
@@ -226,6 +235,9 @@ typename T::ThereReallyIsNoMemberByThisNameInT vertices(T const&);
         BOOST_CONCEPT_ASSERT((Convertible<traversal_category,
             edge_list_graph_tag>));
 
+        BOOST_STATIC_ASSERT((boost::mpl::not_<boost::is_same<edge_iterator, void> >::value));
+        BOOST_STATIC_ASSERT((boost::mpl::not_<boost::is_same<edges_size_type, void> >::value));
+
         p = edges(g);
         e = *p.first;
         u = source(e, g);
@@ -342,7 +354,7 @@ typename T::ThereReallyIsNoMemberByThisNameInT vertices(T const&);
         }
         G g;
         typename graph_traits<G>::vertex_descriptor v;
-        typename vertex_property<G>::type vp;
+        typename vertex_property_type<G>::type vp;
     };
 
     BOOST_concept(EdgeMutablePropertyGraph,(G))
@@ -356,7 +368,7 @@ typename T::ThereReallyIsNoMemberByThisNameInT vertices(T const&);
         G g;
         std::pair<edge_descriptor, bool> p;
         typename graph_traits<G>::vertex_descriptor u, v;
-        typename edge_property<G>::type ep;
+        typename edge_property_type<G>::type ep;
     };
 
     BOOST_concept(AdjacencyMatrix,(G))
@@ -457,10 +469,10 @@ typename T::ThereReallyIsNoMemberByThisNameInT vertices(T const&);
 
             const_constraints(g);
         }
-        void const_constraints(const Graph& g)
+        void const_constraints(const Graph& g_)
         {
             typedef typename property_map<Graph, vertex_index_t>::const_type Map;
-            Map m = get(vertex_index, g);
+            Map m = get(vertex_index, g_);
             ignore_unused_variable_warning(m);
         }
     private:
@@ -484,10 +496,10 @@ typename T::ThereReallyIsNoMemberByThisNameInT vertices(T const&);
 
             const_constraints(g);
         }
-        void const_constraints(const Graph& g)
+        void const_constraints(const Graph& g_)
         {
             typedef typename property_map<Graph, edge_index_t>::const_type Map;
-            Map m = get(edge_index, g);
+            Map m = get(edge_index, g_);
             ignore_unused_variable_warning(m);
         }
     private:
@@ -529,8 +541,8 @@ typename T::ThereReallyIsNoMemberByThisNameInT vertices(T const&);
     {
         BOOST_CONCEPT_USAGE(NumericValue)
         {
-            function_requires< DefaultConstructible<Numeric> >();
-            function_requires< CopyConstructible<Numeric> >();
+            BOOST_CONCEPT_ASSERT(( DefaultConstructible<Numeric> ));
+            BOOST_CONCEPT_ASSERT(( CopyConstructible<Numeric> ));
             numeric_values<Numeric>::zero();
             numeric_values<Numeric>::infinity();
         }
diff --git a/include/boost/graph/graph_stats.hpp b/include/boost/graph/graph_stats.hpp
index 636c49137..ad0e330ca 100644
--- a/include/boost/graph/graph_stats.hpp
+++ b/include/boost/graph/graph_stats.hpp
@@ -12,6 +12,7 @@
 #include <map>
 #include <list>
 #include <boost/graph/iteration_macros.hpp>
+#include <boost/assert.hpp>
 
 namespace boost { namespace graph {
 
@@ -124,7 +125,7 @@ std::map<unsigned long, double> weight_degree_dist( Graph& g ) {
 
   for( std::map<unsigned long, double>::iterator iter = dist.begin();
        iter != dist.end(); ++iter ) {
-    assert( n[iter->first] != 0 );
+    BOOST_ASSERT( n[iter->first] != 0 );
     dist[iter->first] /= n[iter->first];
   }
 
diff --git a/include/boost/graph/graph_test.hpp b/include/boost/graph/graph_test.hpp
index fc4d9f0f9..69d89f34f 100644
--- a/include/boost/graph/graph_test.hpp
+++ b/include/boost/graph/graph_test.hpp
@@ -213,7 +213,7 @@ namespace boost {
       IsoMap iso_map(iso_vec.begin(), get(vertex_index, g));
       copy_graph(g, cpy, orig_to_copy(iso_map));
 
-      assert((verify_isomorphism(g, cpy, iso_map)));
+      BOOST_CHECK((verify_isomorphism(g, cpy, iso_map)));
 
       vertex_t v = add_vertex(g);
       
@@ -325,10 +325,10 @@ namespace boost {
 
     template <typename PropVal, typename PropertyTag>
     void test_readable_vertex_property_graph
-      (const std::vector<PropVal>& vertex_prop, PropertyTag, const Graph& g)
+      (const std::vector<PropVal>& vertex_prop, PropertyTag tag, const Graph& g)
     {
       typedef typename property_map<Graph, PropertyTag>::const_type const_Map;
-      const_Map pmap = get(PropertyTag(), g);
+      const_Map pmap = get(tag, g);
       typename std::vector<PropVal>::const_iterator i = vertex_prop.begin();
 
   for (typename boost::graph_traits<Graph>::vertex_iterator 
@@ -339,7 +339,7 @@ namespace boost {
          ++bgl_first_9) {
       //BGL_FORALL_VERTICES_T(v, g, Graph) {
         typename property_traits<const_Map>::value_type 
-          pval1 = get(pmap, v), pval2 = get(PropertyTag(), g, v);
+          pval1 = get(pmap, v), pval2 = get(tag, g, v);
         BOOST_CHECK(pval1 == pval2);
         BOOST_CHECK(pval1 == *i++);
       }
@@ -350,7 +350,7 @@ namespace boost {
       (const std::vector<PropVal>& vertex_prop, PropertyTag tag, Graph& g)
     {
       typedef typename property_map<Graph, PropertyTag>::type PMap;
-      PMap pmap = get(PropertyTag(), g);
+      PMap pmap = get(tag, g);
       typename std::vector<PropVal>::const_iterator i = vertex_prop.begin();
   for (typename boost::graph_traits<Graph>::vertex_iterator 
            bgl_first_9 = vertices(g).first, bgl_last_9 = vertices(g).second;
@@ -368,7 +368,7 @@ namespace boost {
       
       typename std::vector<PropVal>::const_iterator j = vertex_prop.begin();
       BGL_FORALL_VERTICES_T(v, g, Graph)
-        put(PropertyTag(), g, v, *j++);
+        put(tag, g, v, *j++);
       
       test_readable_vertex_property_graph(vertex_prop, tag, g);      
     }
diff --git a/include/boost/graph/graph_traits.hpp b/include/boost/graph/graph_traits.hpp
index fd1b0415c..a1c27483a 100644
--- a/include/boost/graph/graph_traits.hpp
+++ b/include/boost/graph/graph_traits.hpp
@@ -12,10 +12,15 @@
 
 #include <boost/config.hpp>
 #include <iterator>
+#include <utility> /* Primarily for std::pair */
 #include <boost/tuple/tuple.hpp>
 #include <boost/mpl/if.hpp>
+#include <boost/mpl/eval_if.hpp>
 #include <boost/mpl/bool.hpp>
 #include <boost/mpl/not.hpp>
+#include <boost/mpl/has_xxx.hpp>
+#include <boost/mpl/void.hpp>
+#include <boost/mpl/identity.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/iterator/iterator_categories.hpp>
 #include <boost/iterator/iterator_adaptor.hpp>
@@ -24,23 +29,47 @@
 
 namespace boost {
 
+    namespace detail {
+#define BOOST_GRAPH_MEMBER_OR_VOID(name) \
+      BOOST_MPL_HAS_XXX_TRAIT_DEF(name) \
+      template <typename T> struct BOOST_JOIN(get_member_, name) {typedef typename T::name type;}; \
+      template <typename T> struct BOOST_JOIN(get_opt_member_, name): \
+        boost::mpl::eval_if_c< \
+          BOOST_JOIN(has_, name)<T>::value, \
+          BOOST_JOIN(get_member_, name)<T>, \
+          boost::mpl::identity<void> > \
+        {};
+      BOOST_GRAPH_MEMBER_OR_VOID(adjacency_iterator)
+      BOOST_GRAPH_MEMBER_OR_VOID(out_edge_iterator)
+      BOOST_GRAPH_MEMBER_OR_VOID(in_edge_iterator)
+      BOOST_GRAPH_MEMBER_OR_VOID(vertex_iterator)
+      BOOST_GRAPH_MEMBER_OR_VOID(edge_iterator)
+      BOOST_GRAPH_MEMBER_OR_VOID(vertices_size_type)
+      BOOST_GRAPH_MEMBER_OR_VOID(edges_size_type)
+      BOOST_GRAPH_MEMBER_OR_VOID(degree_size_type)
+    }
+
     template <typename G>
     struct graph_traits {
+#define BOOST_GRAPH_PULL_OPT_MEMBER(name) \
+        typedef typename detail::BOOST_JOIN(get_opt_member_, name)<G>::type name;
+
         typedef typename G::vertex_descriptor      vertex_descriptor;
         typedef typename G::edge_descriptor        edge_descriptor;
-        typedef typename G::adjacency_iterator     adjacency_iterator;
-        typedef typename G::out_edge_iterator      out_edge_iterator;
-        typedef typename G::in_edge_iterator       in_edge_iterator;
-        typedef typename G::vertex_iterator        vertex_iterator;
-        typedef typename G::edge_iterator          edge_iterator;
+        BOOST_GRAPH_PULL_OPT_MEMBER(adjacency_iterator)
+        BOOST_GRAPH_PULL_OPT_MEMBER(out_edge_iterator)
+        BOOST_GRAPH_PULL_OPT_MEMBER(in_edge_iterator)
+        BOOST_GRAPH_PULL_OPT_MEMBER(vertex_iterator)
+        BOOST_GRAPH_PULL_OPT_MEMBER(edge_iterator)
 
         typedef typename G::directed_category      directed_category;
         typedef typename G::edge_parallel_category edge_parallel_category;
         typedef typename G::traversal_category     traversal_category;
 
-        typedef typename G::vertices_size_type     vertices_size_type;
-        typedef typename G::edges_size_type        edges_size_type;
-        typedef typename G::degree_size_type       degree_size_type;
+        BOOST_GRAPH_PULL_OPT_MEMBER(vertices_size_type)
+        BOOST_GRAPH_PULL_OPT_MEMBER(edges_size_type)
+        BOOST_GRAPH_PULL_OPT_MEMBER(degree_size_type)
+#undef BOOST_GRAPH_PULL_OPT_MEMBER
 
         static inline vertex_descriptor null_vertex();
     };
@@ -137,7 +166,13 @@ namespace boost {
     struct edge_list_graph_tag { };
     struct adjacency_matrix_tag { };
 
-    /** @name Taversal Category Traits
+    // Parallel traversal_category tags
+    struct distributed_graph_tag { };
+    struct distributed_vertex_list_graph_tag { };
+    struct distributed_edge_list_graph_tag { };
+#define BOOST_GRAPH_SEQUENTIAL_TRAITS_DEFINES_DISTRIBUTED_TAGS // Disable these from external versions of PBGL
+
+    /** @name Traversal Category Traits
      * These traits classify graph types by their supported methods of
      * vertex and edge traversal.
      */
@@ -217,23 +252,31 @@ namespace boost {
     //?? not the right place ?? Lee
     typedef boost::forward_traversal_tag multi_pass_input_iterator_tag;
 
+    namespace detail {
+      BOOST_MPL_HAS_XXX_TRAIT_DEF(graph_property_type)
+      BOOST_MPL_HAS_XXX_TRAIT_DEF(edge_property_type)
+      BOOST_MPL_HAS_XXX_TRAIT_DEF(vertex_property_type)
+
+      template <typename G> struct get_graph_property_type {typedef typename G::graph_property_type type;};
+      template <typename G> struct get_edge_property_type {typedef typename G::edge_property_type type;};
+      template <typename G> struct get_vertex_property_type {typedef typename G::vertex_property_type type;};
+    }
+
     template <typename G>
-    struct graph_property_type {
-      typedef typename G::graph_property_type type;
-    };
+    struct graph_property_type
+      : boost::mpl::eval_if<detail::has_graph_property_type<G>,
+                            detail::get_graph_property_type<G>,
+                            no_property> {};
     template <typename G>
-    struct edge_property_type {
-      typedef typename G::edge_property_type type;
-    };
+    struct edge_property_type
+      : boost::mpl::eval_if<detail::has_edge_property_type<G>,
+                            detail::get_edge_property_type<G>,
+                            no_property> {};
     template <typename G>
-    struct vertex_property_type {
-      typedef typename G::vertex_property_type type;
-    };
-
-    struct no_bundle { };
-    struct no_graph_bundle : no_bundle { };
-    struct no_vertex_bundle : no_bundle { };
-    struct no_edge_bundle : no_bundle { };
+    struct vertex_property_type
+      : boost::mpl::eval_if<detail::has_vertex_property_type<G>,
+                            detail::get_vertex_property_type<G>,
+                            no_property> {};
 
     template<typename G>
     struct graph_bundle_type {
@@ -261,13 +304,21 @@ namespace boost {
             typedef typename bundler::type type;
         };
 
+        template<typename Graph>
+        class bundled_result<Graph, graph_bundle_t> {
+            typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
+            typedef graph_bundle_type<Graph> bundler;
+        public:
+            typedef typename bundler::type type;
+        };
+
     } } // namespace graph::detail
 
     namespace graph_detail {
       // A helper metafunction for determining whether or not a type is
       // bundled.
       template <typename T>
-      struct is_no_bundle : mpl::bool_<is_convertible<T, no_bundle>::value>
+      struct is_no_bundle : mpl::bool_<is_same<T, no_property>::value>
       { };
     } // namespace graph_detail
 
diff --git a/include/boost/graph/graph_utility.hpp b/include/boost/graph/graph_utility.hpp
index ba1fe3d83..f1f120e30 100644
--- a/include/boost/graph/graph_utility.hpp
+++ b/include/boost/graph/graph_utility.hpp
@@ -237,8 +237,6 @@ namespace boost {
   template <class Graph, class Vertex>
   bool is_adj_dispatch(Graph& g, Vertex a, Vertex b, bidirectional_tag)
   {
-    typedef typename graph_traits<Graph>::edge_descriptor 
-      edge_descriptor;
     typename graph_traits<Graph>::adjacency_iterator vi, viend, 
       adj_found;
     boost::tie(vi, viend) = adjacent_vertices(a, g);
@@ -265,21 +263,9 @@ namespace boost {
   template <class Graph, class Vertex>
   bool is_adj_dispatch(Graph& g, Vertex a, Vertex b, directed_tag)
   {
-    typedef typename graph_traits<Graph>::edge_descriptor 
-      edge_descriptor;
     typename graph_traits<Graph>::adjacency_iterator vi, viend, found;
     boost::tie(vi, viend) = adjacent_vertices(a, g);
-#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 && defined(__SGI_STL_PORT)
-    // Getting internal compiler error with std::find()
-    found = viend;
-    for (; vi != viend; ++vi)
-      if (*vi == b) {
-        found = vi;
-        break;
-      }
-#else
     found = std::find(vi, viend, b);
-#endif
     if ( found == viend )
       return false;
 
@@ -287,17 +273,7 @@ namespace boost {
       out_found;
     boost::tie(oi, oiend) = out_edges(a, g);
 
-#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 && defined(__SGI_STL_PORT)
-    // Getting internal compiler error with std::find()
-    out_found = oiend;
-    for (; oi != oiend; ++oi)
-      if (target(*oi, g) == b) {
-        out_found = oi;
-        break;
-      }
-#else
     out_found = std::find_if(oi, oiend, incident_to(b, g));
-#endif
     if (out_found == oiend)
       return false;
     return true;
diff --git a/include/boost/graph/graphml.hpp b/include/boost/graph/graphml.hpp
index 6afa12c96..be73def30 100644
--- a/include/boost/graph/graphml.hpp
+++ b/include/boost/graph/graphml.hpp
@@ -204,14 +204,14 @@ template<typename MutableGraph>
 const char* mutate_graph_impl<MutableGraph>::m_type_names[] = {"boolean", "int", "long", "float", "double", "string"};
 
 void BOOST_GRAPH_DECL
-read_graphml(std::istream& in, mutate_graph& g);
+read_graphml(std::istream& in, mutate_graph& g, size_t desired_idx);
 
 template<typename MutableGraph>
 void
-read_graphml(std::istream& in, MutableGraph& g, dynamic_properties& dp)
+read_graphml(std::istream& in, MutableGraph& g, dynamic_properties& dp, size_t desired_idx = 0)
 {
     mutate_graph_impl<MutableGraph> mg(g,dp);
-    read_graphml(in, mg);
+    read_graphml(in, mg, desired_idx);
 }
 
 template <typename Types>
@@ -262,8 +262,8 @@ write_graphml(std::ostream& out, const Graph& g, VertexIndexMap vertex_index,
     for (dynamic_properties::const_iterator i = dp.begin(); i != dp.end(); ++i)
     {
         std::string key_id = "key" + lexical_cast<std::string>(key_count++);
-        if (i->second->key() == typeid(Graph))
-            vertex_key_ids[i->first] = key_id;
+        if (i->second->key() == typeid(Graph*))
+            graph_key_ids[i->first] = key_id;
         else if (i->second->key() == typeid(vertex_descriptor))
             vertex_key_ids[i->first] = key_id;
         else if (i->second->key() == typeid(edge_descriptor))
@@ -273,7 +273,7 @@ write_graphml(std::ostream& out, const Graph& g, VertexIndexMap vertex_index,
         std::string type_name = "string";
         mpl::for_each<value_types>(get_type_name<value_types>(i->second->value(), type_names, type_name));
         out << "  <key id=\"" << encode_char_entities(key_id) << "\" for=\""
-            << (i->second->key() == typeid(Graph) ? "graph" : (i->second->key() == typeid(vertex_descriptor) ? "node" : "edge")) << "\""
+            << (i->second->key() == typeid(Graph*) ? "graph" : (i->second->key() == typeid(vertex_descriptor) ? "node" : "edge")) << "\""
             << " attr.name=\"" << i->first << "\""
             << " attr.type=\"" << type_name << "\""
             << " />\n";
@@ -287,10 +287,12 @@ write_graphml(std::ostream& out, const Graph& g, VertexIndexMap vertex_index,
     // Output graph data
     for (dynamic_properties::const_iterator i = dp.begin(); i != dp.end(); ++i)
     {
-        if (i->second->key() == typeid(Graph))
+        if (i->second->key() == typeid(Graph*))
         {
+            // The const_cast here is just to get typeid correct for property
+            // map key; the graph should not be mutated using it.
             out << "   <data key=\"" << graph_key_ids[i->first] << "\">"
-                << encode_char_entities(i->second->get_string(g)) << "</data>\n";
+                << encode_char_entities(i->second->get_string(const_cast<Graph*>(&g))) << "</data>\n";
         }
     }
 
diff --git a/include/boost/graph/graphviz.hpp b/include/boost/graph/graphviz.hpp
index 1e6aeaf00..1c8cb194a 100644
--- a/include/boost/graph/graphviz.hpp
+++ b/include/boost/graph/graphviz.hpp
@@ -25,10 +25,14 @@
 #include <boost/property_map/dynamic_property_map.hpp>
 #include <boost/graph/overloading.hpp>
 #include <boost/graph/dll_import_export.hpp>
+#include <boost/graph/compressed_sparse_row_graph.hpp>
+#include <boost/graph/iteration_macros.hpp>
 #include <boost/spirit/include/classic_multi_pass.hpp>
 #include <boost/lexical_cast.hpp>
+#include <boost/static_assert.hpp>
 #include <boost/algorithm/string/replace.hpp>
 #include <boost/xpressive/xpressive_static.hpp>
+#include <boost/foreach.hpp>
 
 namespace boost {
 
@@ -67,7 +71,8 @@ namespace boost {
     if (regex_match(s, valid_unquoted_id)) {
       return s;
     } else {
-      return "\"" + regex_replace(s, sregex(as_xpr('"')), "\\\"") + "\"";
+      boost::algorithm::replace_all(s, "\"", "\\\"");
+      return "\"" + s + "\"";
     }
   }
 
@@ -284,8 +289,6 @@ namespace boost {
                  BOOST_GRAPH_ENABLE_IF_MODELS_PARM(Graph,vertex_list_graph_tag))
   { write_graphviz(out, g, vpw, epw, gpw, get(vertex_index, g)); }
 
-#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
-  // ambiguous overload problem with VC++
   template <typename Graph>
   inline void
   write_graphviz(std::ostream& out, const Graph& g
@@ -295,7 +298,6 @@ namespace boost {
     default_writer gw;
     write_graphviz(out, g, dw, dw, gw);
   }
-#endif
 
   template <typename Graph, typename VertexWriter>
   inline void
@@ -344,21 +346,7 @@ namespace boost {
       typename Graph::const_children_iterator i_child, j_child;
 
       //print graph/node/edge attributes
-#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
-      typedef typename graph_property<Graph, graph_graph_attribute_t>::type
-        GAttrMap;
-      typedef typename graph_property<Graph, graph_vertex_attribute_t>::type
-        NAttrMap;
-      typedef typename graph_property<Graph, graph_edge_attribute_t>::type
-        EAttrMap;
-      GAttrMap gam = get_property(g, graph_graph_attribute);
-      NAttrMap nam = get_property(g, graph_vertex_attribute);
-      EAttrMap eam = get_property(g, graph_edge_attribute);
-      graph_attributes_writer<GAttrMap, NAttrMap, EAttrMap> writer(gam, nam, eam);
-      writer(out);
-#else
       make_graph_attributes_writer(g)(out);
-#endif
 
       //print subgraph
       for ( boost::tie(i_child,j_child) = g.children();
@@ -377,15 +365,7 @@ namespace boost {
         if ( vertex_marker[pos] ) {
           vertex_marker[pos] = false;
           out << escape_dot_string(pos);
-#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
-          typedef typename property_map<Graph, vertex_attribute_t>::const_type
-            VertexAttributeMap;
-          attributes_writer<VertexAttributeMap> vawriter(get(vertex_attribute,
-                                                             g.root()));
-          vawriter(out, v);
-#else
           make_vertex_attributes_writer(g.root())(out, v);
-#endif
           out << ";" << std::endl;
         }
       }
@@ -398,14 +378,7 @@ namespace boost {
           edge_marker[pos] = false;
           out << escape_dot_string(get(vertex_id, u)) << " " << Traits::delimiter()
               << " " << escape_dot_string(get(vertex_id, v));
-#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
-          typedef typename property_map<Graph, edge_attribute_t>::const_type
-            EdgeAttributeMap;
-          attributes_writer<EdgeAttributeMap> eawriter(get(edge_attribute, g));
-          eawriter(out, *ei);
-#else
           make_edge_attributes_writer(g)(out, *ei); //print edge properties
-#endif
           out << ";" << std::endl;
         }
       }
@@ -563,6 +536,28 @@ namespace boost {
     const std::string* node_id;
   };
 
+  template <typename Graph>
+  class dynamic_graph_properties_writer
+  {
+  public:
+    dynamic_graph_properties_writer(const dynamic_properties& dp, const Graph& g) : g(&g), dp(&dp) { }
+
+    void operator()(std::ostream& out) const
+    {
+      for (dynamic_properties::const_iterator i = dp->begin();
+           i != dp->end(); ++i) {
+        if (typeid(Graph*) == i->second->key()) {
+          // const_cast here is to match interface used in read_graphviz
+          out << i->first << "=" << escape_dot_string(i->second->get_string(const_cast<Graph*>(g))) << ";\n";
+        }
+      }
+    }
+
+  private:
+    const Graph* g;
+    const dynamic_properties* dp;
+  };
+
   namespace graph { namespace detail {
 
     template<typename Vertex>
@@ -614,7 +609,7 @@ namespace boost {
       (out, g,
        /*vertex_writer=*/dynamic_vertex_properties_writer(dp, node_id),
        /*edge_writer=*/dynamic_properties_writer(dp),
-       /*graph_writer=*/default_writer(),
+       /*graph_writer=*/dynamic_graph_properties_writer<Graph>(dp, g),
        id);
   }
 
@@ -712,6 +707,9 @@ class mutate_graph
 
   virtual void  // RG: need new second parameter to support BGL subgraphs
   set_graph_property(const id_t& key, const id_t& value) = 0;
+
+  virtual void
+  finish_building_graph() = 0;
 };
 
 template<typename MutableGraph>
@@ -780,6 +778,8 @@ class mutate_graph_impl : public mutate_graph
     put(key, dp_, &graph_, value);
   }
 
+  void finish_building_graph() {}
+
 
  protected:
   MutableGraph& graph_;
@@ -789,6 +789,109 @@ class mutate_graph_impl : public mutate_graph
   std::map<edge_t, bgl_edge_t> bgl_edges;
 };
 
+template<typename Directed,
+         typename VertexProperty,
+         typename EdgeProperty,
+         typename GraphProperty,
+         typename Vertex,
+         typename EdgeIndex>
+class mutate_graph_impl<compressed_sparse_row_graph<Directed, VertexProperty, EdgeProperty, GraphProperty, Vertex, EdgeIndex> >
+  : public mutate_graph
+{
+  typedef compressed_sparse_row_graph<Directed, VertexProperty, EdgeProperty, GraphProperty, Vertex, EdgeIndex> CSRGraph;
+  typedef typename graph_traits<CSRGraph>::vertices_size_type bgl_vertex_t;
+  typedef typename graph_traits<CSRGraph>::edges_size_type    bgl_edge_t;
+  typedef typename graph_traits<CSRGraph>::edge_descriptor    edge_descriptor;
+
+ public:
+  mutate_graph_impl(CSRGraph& graph, dynamic_properties& dp,
+                    std::string node_id_prop)
+    : graph_(graph), dp_(dp), vertex_count(0), node_id_prop_(node_id_prop) { }
+
+  ~mutate_graph_impl() {}
+
+  void finish_building_graph() {
+    typedef compressed_sparse_row_graph<directedS, no_property, bgl_edge_t, GraphProperty, Vertex, EdgeIndex> TempCSRGraph;
+    TempCSRGraph temp(edges_are_unsorted_multi_pass,
+                      edges_to_add.begin(), edges_to_add.end(),
+                      counting_iterator<bgl_edge_t>(0),
+                      vertex_count);
+    set_property(temp, graph_all, get_property(graph_, graph_all));
+    graph_.assign(temp); // Copies structure, not properties
+    std::vector<edge_descriptor> edge_permutation_from_sorting(num_edges(temp));
+    BGL_FORALL_EDGES_T(e, temp, TempCSRGraph) {
+      edge_permutation_from_sorting[temp[e]] = e;
+    }
+    typedef boost::tuple<id_t, bgl_vertex_t, id_t> v_prop;
+    BOOST_FOREACH(const v_prop& t, vertex_props) {
+      put(boost::get<0>(t), dp_, boost::get<1>(t), boost::get<2>(t));
+    }
+    typedef boost::tuple<id_t, bgl_edge_t, id_t> e_prop;
+    BOOST_FOREACH(const e_prop& t, edge_props) {
+      put(boost::get<0>(t), dp_, edge_permutation_from_sorting[boost::get<1>(t)], boost::get<2>(t));
+    }
+  }
+
+  bool is_directed() const
+  {
+    return
+      boost::is_convertible<
+        typename boost::graph_traits<CSRGraph>::directed_category,
+        boost::directed_tag>::value;
+  }
+
+  virtual void do_add_vertex(const node_t& node)
+  {
+    // Add the node to the graph.
+    bgl_vertex_t v = vertex_count++;
+
+    // Set up a mapping from name to BGL vertex.
+    bgl_nodes.insert(std::make_pair(node, v));
+
+    // node_id_prop_ allows the caller to see the real id names for nodes.
+    vertex_props.push_back(boost::make_tuple(node_id_prop_, v, node));
+  }
+
+  void
+  do_add_edge(const edge_t& edge, const node_t& source, const node_t& target)
+  {
+    bgl_edge_t result = edges_to_add.size();
+    edges_to_add.push_back(std::make_pair(bgl_nodes[source], bgl_nodes[target]));
+    bgl_edges.insert(std::make_pair(edge, result));
+  }
+
+  void
+  set_node_property(const id_t& key, const node_t& node, const id_t& value)
+  {
+    vertex_props.push_back(boost::make_tuple(key, bgl_nodes[node], value));
+  }
+
+  void
+  set_edge_property(const id_t& key, const edge_t& edge, const id_t& value)
+  {
+    edge_props.push_back(boost::make_tuple(key, bgl_edges[edge], value));
+  }
+
+  void
+  set_graph_property(const id_t& key, const id_t& value)
+  {
+    /* RG: pointer to graph prevents copying */
+    put(key, dp_, &graph_, value);
+  }
+
+
+ protected:
+  CSRGraph& graph_;
+  dynamic_properties& dp_;
+  bgl_vertex_t vertex_count;
+  std::string node_id_prop_;
+  std::vector<boost::tuple<id_t, bgl_vertex_t, id_t> > vertex_props;
+  std::vector<boost::tuple<id_t, bgl_edge_t, id_t> > edge_props;
+  std::vector<std::pair<bgl_vertex_t, bgl_vertex_t> > edges_to_add;
+  std::map<node_t, bgl_vertex_t> bgl_nodes;
+  std::map<edge_t, bgl_edge_t> bgl_edges;
+};
+
 } } } // end namespace boost::detail::graph
 
 #ifdef BOOST_GRAPH_USE_SPIRIT_PARSER
diff --git a/include/boost/graph/grid_graph.hpp b/include/boost/graph/grid_graph.hpp
index 9eff52591..9a09fca34 100644
--- a/include/boost/graph/grid_graph.hpp
+++ b/include/boost/graph/grid_graph.hpp
@@ -17,7 +17,6 @@
 #include <boost/array.hpp>
 #include <boost/bind.hpp>
 #include <boost/limits.hpp>
-#include <boost/make_shared.hpp>
 #include <boost/graph/graph_traits.hpp>
 #include <boost/graph/properties.hpp>
 #include <boost/iterator/counting_iterator.hpp>
@@ -31,11 +30,6 @@
 #define BOOST_GRID_GRAPH_TYPE \
   grid_graph<DimensionsT, VertexIndexT, EdgeIndexT>
 
-#define BOOST_GRID_GRAPH_TYPE_MEM typename BOOST_GRID_GRAPH_TYPE::
-
-#define BOOST_GRID_GRAPH_TYPE_TD(mem) \
-  typedef typename BOOST_GRID_GRAPH_TYPE::mem mem
-
 #define BOOST_GRID_GRAPH_TRAITS_T \
   typename graph_traits<BOOST_GRID_GRAPH_TYPE >
 
@@ -63,14 +57,21 @@ namespace boost {
     grid_graph_index_map() { }
 
     grid_graph_index_map(const Graph& graph) :
-      m_graph(make_shared<Graph>(graph)) { }
+      m_graph(&graph) { }
 
     value_type operator[](key_type key) const {
       return (m_graph->index_of(key));
     }
 
+    friend inline Index
+    get(const grid_graph_index_map<Graph, Descriptor, Index>& index_map,
+        const typename grid_graph_index_map<Graph, Descriptor, Index>::key_type& key)
+    {
+      return (index_map[key]);
+    }
+
   protected:
-    shared_ptr<Graph> m_graph;
+    const Graph* m_graph;
   };
 
   template<BOOST_GRID_GRAPH_TEMPLATE_PARAMS>
@@ -89,6 +90,39 @@ namespace boost {
     typedef type const_type;
   };
 
+  //==========================
+  // Reverse Edge Property Map
+  //==========================
+
+  template <typename Descriptor>
+  struct grid_graph_reverse_edge_map {
+  public:
+    typedef Descriptor value_type;
+    typedef Descriptor reference_type;
+    typedef reference_type reference;
+    typedef Descriptor key_type;
+    typedef readable_property_map_tag category;
+
+    grid_graph_reverse_edge_map() { }
+
+    value_type operator[](const key_type& key) const {
+      return (value_type(key.second, key.first));
+    }
+
+    friend inline Descriptor
+    get(const grid_graph_reverse_edge_map<Descriptor>& rev_map,
+        const typename grid_graph_reverse_edge_map<Descriptor>::key_type& key)
+    {
+      return (rev_map[key]);
+    }
+  };
+
+  template<BOOST_GRID_GRAPH_TEMPLATE_PARAMS>
+  struct property_map<BOOST_GRID_GRAPH_TYPE, edge_reverse_t> {
+    typedef grid_graph_reverse_edge_map<BOOST_GRID_GRAPH_TRAITS_T::edge_descriptor> type;
+    typedef type const_type;
+  };
+
   //=================
   // Function Objects
   //=================
@@ -268,7 +302,7 @@ namespace boost {
     typedef transform_iterator<adjacent_vertex_function, degree_iterator> adjacency_iterator;
 
     // categories
-    typedef undirected_tag directed_category;
+    typedef directed_tag directed_category;
     typedef disallow_parallel_edge_tag edge_parallel_category;    
     struct traversal_category : virtual public incidence_graph_tag,
                                 virtual public adjacency_graph_tag,
@@ -351,7 +385,7 @@ namespace boost {
         // Stop at the end of this dimension if necessary.
         new_position =
           (std::min)(new_position,
-                     length(dimension_index) - 1);
+                     vertices_size_type(length(dimension_index) - 1));
       }
 
       vertex[dimension_index] = new_position;
@@ -417,7 +451,7 @@ namespace boost {
     vertex_descriptor vertex_at
     (vertices_size_type vertex_index) const {
     
-      array<vertices_size_type, Dimensions> vertex;
+      boost::array<vertices_size_type, Dimensions> vertex;
       vertices_size_type index_divider = 1;
 
       for (std::size_t dimension_index = 0;
@@ -507,6 +541,8 @@ namespace boost {
       vertex_descriptor source_vertex = source(edge, *this);
       vertex_descriptor target_vertex = target(edge, *this);
 
+      BOOST_ASSERT (source_vertex != target_vertex);
+
       // Determine the dimension where the source and target vertices
       // differ (should only be one if this is a valid edge).
       std::size_t different_dimension_index = 0;
@@ -671,7 +707,8 @@ namespace boost {
     void precalculate() {
       m_num_vertices =
         std::accumulate(m_dimension_lengths.begin(),
-                        m_dimension_lengths.end(), 1,
+                        m_dimension_lengths.end(),
+                        vertices_size_type(1),
                         std::multiplies<vertices_size_type>());
 
       // Calculate number of edges in each dimension
@@ -706,13 +743,12 @@ namespace boost {
     // VertexListGraph
     //================
 
-    template<BOOST_GRID_GRAPH_TEMPLATE_PARAMS>
-    friend inline std::pair<BOOST_GRID_GRAPH_TYPE_MEM vertex_iterator,
-                            BOOST_GRID_GRAPH_TYPE_MEM vertex_iterator> 
-    vertices(const BOOST_GRID_GRAPH_TYPE& graph) {
-      BOOST_GRID_GRAPH_TYPE_TD(vertex_iterator);
-      BOOST_GRID_GRAPH_TYPE_TD(vertex_function);
-      BOOST_GRID_GRAPH_TYPE_TD(vertex_index_iterator);
+    friend inline std::pair<typename type::vertex_iterator,
+                            typename type::vertex_iterator> 
+    vertices(const type& graph) {
+      typedef typename type::vertex_iterator vertex_iterator;
+      typedef typename type::vertex_function vertex_function;
+      typedef typename type::vertex_index_iterator vertex_index_iterator;
 
       return (std::make_pair
               (vertex_iterator(vertex_index_iterator(0),
@@ -721,16 +757,14 @@ namespace boost {
                                vertex_function(&graph))));
     }
 
-    template<BOOST_GRID_GRAPH_TEMPLATE_PARAMS>
-    friend inline  BOOST_GRID_GRAPH_TYPE_MEM vertices_size_type
-    num_vertices(const BOOST_GRID_GRAPH_TYPE& graph) {
+    friend inline typename type::vertices_size_type
+    num_vertices(const type& graph) {
       return (graph.num_vertices());
     }
 
-    template<BOOST_GRID_GRAPH_TEMPLATE_PARAMS>
-    friend inline BOOST_GRID_GRAPH_TYPE_MEM vertex_descriptor
-    vertex(BOOST_GRID_GRAPH_TYPE_MEM vertices_size_type vertex_index,
-           const BOOST_GRID_GRAPH_TYPE& graph) {
+    friend inline typename type::vertex_descriptor
+    vertex(typename type::vertices_size_type vertex_index,
+           const type& graph) {
 
       return (graph.vertex_at(vertex_index));
     }
@@ -739,14 +773,13 @@ namespace boost {
     // IncidenceGraph
     //===============
 
-    template<BOOST_GRID_GRAPH_TEMPLATE_PARAMS>
-    friend inline std::pair<BOOST_GRID_GRAPH_TYPE_MEM out_edge_iterator,
-                            BOOST_GRID_GRAPH_TYPE_MEM out_edge_iterator>
-    out_edges(BOOST_GRID_GRAPH_TYPE_MEM vertex_descriptor vertex,
-              const BOOST_GRID_GRAPH_TYPE& graph) {
-      BOOST_GRID_GRAPH_TYPE_TD(degree_iterator);
-      BOOST_GRID_GRAPH_TYPE_TD(out_edge_function);
-      BOOST_GRID_GRAPH_TYPE_TD(out_edge_iterator);
+    friend inline std::pair<typename type::out_edge_iterator,
+                            typename type::out_edge_iterator>
+    out_edges(typename type::vertex_descriptor vertex,
+              const type& graph) {
+      typedef typename type::degree_iterator degree_iterator;
+      typedef typename type::out_edge_function out_edge_function;
+      typedef typename type::out_edge_iterator out_edge_iterator;
 
       return (std::make_pair
               (out_edge_iterator(degree_iterator(0),
@@ -755,19 +788,17 @@ namespace boost {
                                  out_edge_function(vertex, &graph))));
     }
 
-    template<BOOST_GRID_GRAPH_TEMPLATE_PARAMS>
-    friend inline BOOST_GRID_GRAPH_TYPE_MEM degree_size_type
+    friend inline typename type::degree_size_type
     out_degree
-    (BOOST_GRID_GRAPH_TYPE_MEM vertex_descriptor vertex,
-     const BOOST_GRID_GRAPH_TYPE& graph) {
+    (typename type::vertex_descriptor vertex,
+     const type& graph) {
       return (graph.out_degree(vertex));
     }
 
-    template<BOOST_GRID_GRAPH_TEMPLATE_PARAMS>
-    friend inline BOOST_GRID_GRAPH_TYPE_MEM edge_descriptor
-    out_edge_at(BOOST_GRID_GRAPH_TYPE_MEM vertex_descriptor vertex,
-                BOOST_GRID_GRAPH_TYPE_MEM degree_size_type out_edge_index,
-                const BOOST_GRID_GRAPH_TYPE& graph) {
+    friend inline typename type::edge_descriptor
+    out_edge_at(typename type::vertex_descriptor vertex,
+                typename type::degree_size_type out_edge_index,
+                const type& graph) {
       return (graph.out_edge_at(vertex, out_edge_index));
     }
 
@@ -775,14 +806,13 @@ namespace boost {
     // AdjacencyGraph
     //===============
 
-    template <BOOST_GRID_GRAPH_TEMPLATE_PARAMS>
-    friend typename std::pair<BOOST_GRID_GRAPH_TYPE_MEM adjacency_iterator,
-                              BOOST_GRID_GRAPH_TYPE_MEM adjacency_iterator>
-    adjacent_vertices (BOOST_GRID_GRAPH_TYPE_MEM vertex_descriptor vertex,
-                       const BOOST_GRID_GRAPH_TYPE& graph) {
-      BOOST_GRID_GRAPH_TYPE_TD(degree_iterator);
-      BOOST_GRID_GRAPH_TYPE_TD(adjacent_vertex_function);
-      BOOST_GRID_GRAPH_TYPE_TD(adjacency_iterator);
+    friend typename std::pair<typename type::adjacency_iterator,
+                              typename type::adjacency_iterator>
+    adjacent_vertices (typename type::vertex_descriptor vertex,
+                       const type& graph) {
+      typedef typename type::degree_iterator degree_iterator;
+      typedef typename type::adjacent_vertex_function adjacent_vertex_function;
+      typedef typename type::adjacency_iterator adjacency_iterator;
 
       return (std::make_pair
               (adjacency_iterator(degree_iterator(0),
@@ -795,26 +825,23 @@ namespace boost {
     // EdgeListGraph
     //==============
 
-    template<BOOST_GRID_GRAPH_TEMPLATE_PARAMS>
-    friend inline BOOST_GRID_GRAPH_TYPE_MEM edges_size_type
-    num_edges(const BOOST_GRID_GRAPH_TYPE& graph) {
+    friend inline typename type::edges_size_type
+    num_edges(const type& graph) {
       return (graph.num_edges());
     }
 
-    template<BOOST_GRID_GRAPH_TEMPLATE_PARAMS>
-    friend inline BOOST_GRID_GRAPH_TYPE_MEM edge_descriptor
-    edge_at(BOOST_GRID_GRAPH_TYPE_MEM edges_size_type edge_index,
-            const BOOST_GRID_GRAPH_TYPE& graph) {
+    friend inline typename type::edge_descriptor
+    edge_at(typename type::edges_size_type edge_index,
+            const type& graph) {
       return (graph.edge_at(edge_index));
     }
 
-    template<BOOST_GRID_GRAPH_TEMPLATE_PARAMS>
-    friend inline std::pair<BOOST_GRID_GRAPH_TYPE_MEM edge_iterator,
-                            BOOST_GRID_GRAPH_TYPE_MEM edge_iterator>
-    edges(const BOOST_GRID_GRAPH_TYPE& graph) {
-      BOOST_GRID_GRAPH_TYPE_TD(edge_index_iterator);
-      BOOST_GRID_GRAPH_TYPE_TD(edge_function);
-      BOOST_GRID_GRAPH_TYPE_TD(edge_iterator);
+    friend inline std::pair<typename type::edge_iterator,
+                            typename type::edge_iterator>
+    edges(const type& graph) {
+      typedef typename type::edge_index_iterator edge_index_iterator;
+      typedef typename type::edge_function edge_function;
+      typedef typename type::edge_iterator edge_iterator;
 
       return (std::make_pair
               (edge_iterator(edge_index_iterator(0),
@@ -827,14 +854,13 @@ namespace boost {
     // BiDirectionalGraph
     //===================
 
-    template<BOOST_GRID_GRAPH_TEMPLATE_PARAMS>
-    friend inline std::pair<BOOST_GRID_GRAPH_TYPE_MEM in_edge_iterator,
-                            BOOST_GRID_GRAPH_TYPE_MEM in_edge_iterator>
-    in_edges(BOOST_GRID_GRAPH_TYPE_MEM vertex_descriptor vertex,
-             const BOOST_GRID_GRAPH_TYPE& graph) {
-      BOOST_GRID_GRAPH_TYPE_TD(in_edge_function);
-      BOOST_GRID_GRAPH_TYPE_TD(degree_iterator);
-      BOOST_GRID_GRAPH_TYPE_TD(in_edge_iterator);
+    friend inline std::pair<typename type::in_edge_iterator,
+                            typename type::in_edge_iterator>
+    in_edges(typename type::vertex_descriptor vertex,
+             const type& graph) {
+      typedef typename type::in_edge_function in_edge_function;
+      typedef typename type::degree_iterator degree_iterator;
+      typedef typename type::in_edge_iterator in_edge_iterator;
 
       return (std::make_pair
               (in_edge_iterator(degree_iterator(0),
@@ -843,25 +869,22 @@ namespace boost {
                                 in_edge_function(vertex, &graph))));
     }
 
-    template<BOOST_GRID_GRAPH_TEMPLATE_PARAMS>
-    friend inline BOOST_GRID_GRAPH_TYPE_MEM degree_size_type
-    in_degree (BOOST_GRID_GRAPH_TYPE_MEM vertex_descriptor vertex,
-               const BOOST_GRID_GRAPH_TYPE& graph) {
+    friend inline typename type::degree_size_type
+    in_degree (typename type::vertex_descriptor vertex,
+               const type& graph) {
       return (graph.in_degree(vertex));
     }
 
-    template<BOOST_GRID_GRAPH_TEMPLATE_PARAMS>
-    friend inline BOOST_GRID_GRAPH_TYPE_MEM degree_size_type
-    degree (BOOST_GRID_GRAPH_TYPE_MEM vertex_descriptor vertex,
-            const BOOST_GRID_GRAPH_TYPE& graph) {
+    friend inline typename type::degree_size_type
+    degree (typename type::vertex_descriptor vertex,
+            const type& graph) {
       return (graph.out_degree(vertex) * 2);
     }
 
-    template<BOOST_GRID_GRAPH_TEMPLATE_PARAMS>
-    friend inline BOOST_GRID_GRAPH_TYPE_MEM edge_descriptor
-    in_edge_at(BOOST_GRID_GRAPH_TYPE_MEM vertex_descriptor vertex,
-               BOOST_GRID_GRAPH_TYPE_MEM degree_size_type in_edge_index,
-               const BOOST_GRID_GRAPH_TYPE& graph) {
+    friend inline typename type::edge_descriptor
+    in_edge_at(typename type::vertex_descriptor vertex,
+               typename type::degree_size_type in_edge_index,
+               const type& graph) {
       return (graph.in_edge_at(vertex, in_edge_index));
     }
 
@@ -870,21 +893,20 @@ namespace boost {
     // Adjacency Matrix
     //==================
 
-    template<BOOST_GRID_GRAPH_TEMPLATE_PARAMS>
-    friend std::pair<BOOST_GRID_GRAPH_TYPE_MEM edge_descriptor, bool>
-    edge (BOOST_GRID_GRAPH_TYPE_MEM vertex_descriptor source_vertex,
-          BOOST_GRID_GRAPH_TYPE_MEM vertex_descriptor destination_vertex,
-          const BOOST_GRID_GRAPH_TYPE& graph) {
+    friend std::pair<typename type::edge_descriptor, bool>
+    edge (typename type::vertex_descriptor source_vertex,
+          typename type::vertex_descriptor destination_vertex,
+          const type& graph) {
 
-      std::pair<BOOST_GRID_GRAPH_TYPE_MEM edge_descriptor, bool> edge_exists =
+      std::pair<typename type::edge_descriptor, bool> edge_exists =
         std::make_pair(std::make_pair(source_vertex, destination_vertex), false);
 
       for (std::size_t dimension_index = 0;
            dimension_index < Dimensions;
            ++dimension_index) {
 
-        BOOST_GRID_GRAPH_TYPE_MEM vertices_size_type dim_difference = 0;
-        BOOST_GRID_GRAPH_TYPE_MEM vertices_size_type
+        typename type::vertices_size_type dim_difference = 0;
+        typename type::vertices_size_type
           source_dim = source_vertex[dimension_index],
           dest_dim = destination_vertex[dimension_index];
 
@@ -931,68 +953,62 @@ namespace boost {
     // Index Property Map Functions
     //=============================
 
-    template<BOOST_GRID_GRAPH_TEMPLATE_PARAMS>
-    friend inline BOOST_GRID_GRAPH_TYPE_MEM vertices_size_type
+    friend inline typename type::vertices_size_type
     get(vertex_index_t,
-        const BOOST_GRID_GRAPH_TYPE& graph,
-        BOOST_GRID_GRAPH_TYPE_MEM vertex_descriptor vertex) {
+        const type& graph,
+        typename type::vertex_descriptor vertex) {
       return (graph.index_of(vertex));
     }
 
-    template<BOOST_GRID_GRAPH_TEMPLATE_PARAMS>
-    friend inline BOOST_GRID_GRAPH_TYPE_MEM edges_size_type
+    friend inline typename type::edges_size_type
     get(edge_index_t,
-        const BOOST_GRID_GRAPH_TYPE& graph,
-        BOOST_GRID_GRAPH_TYPE_MEM edge_descriptor edge) {
+        const type& graph,
+        typename type::edge_descriptor edge) {
       return (graph.index_of(edge));
     }
 
-    template <BOOST_GRID_GRAPH_TEMPLATE_PARAMS>
     friend inline grid_graph_index_map<
-                    BOOST_GRID_GRAPH_TYPE,
-                    BOOST_GRID_GRAPH_TYPE_MEM vertex_descriptor,
-                    BOOST_GRID_GRAPH_TYPE_MEM vertices_size_type>
-    get(vertex_index_t, const BOOST_GRID_GRAPH_TYPE& graph) {
+                    type,
+                    typename type::vertex_descriptor,
+                    typename type::vertices_size_type>
+    get(vertex_index_t, const type& graph) {
       return (grid_graph_index_map<
-                BOOST_GRID_GRAPH_TYPE,
-                BOOST_GRID_GRAPH_TYPE_MEM vertex_descriptor,
-                BOOST_GRID_GRAPH_TYPE_MEM vertices_size_type>(graph));
+                type,
+                typename type::vertex_descriptor,
+                typename type::vertices_size_type>(graph));
     }
 
-    template <BOOST_GRID_GRAPH_TEMPLATE_PARAMS>
     friend inline grid_graph_index_map<
-                    BOOST_GRID_GRAPH_TYPE,
-                    BOOST_GRID_GRAPH_TYPE_MEM edge_descriptor,
-                    BOOST_GRID_GRAPH_TYPE_MEM edges_size_type>
-    get(edge_index_t, const BOOST_GRID_GRAPH_TYPE& graph) {
+                    type,
+                    typename type::edge_descriptor,
+                    typename type::edges_size_type>
+    get(edge_index_t, const type& graph) {
       return (grid_graph_index_map<
-                BOOST_GRID_GRAPH_TYPE,
-                BOOST_GRID_GRAPH_TYPE_MEM edge_descriptor,
-                BOOST_GRID_GRAPH_TYPE_MEM edges_size_type>(graph));
+                type,
+                typename type::edge_descriptor,
+                typename type::edges_size_type>(graph));
     }                                       
 
-    template<typename Graph,
-             typename Descriptor,
-             typename Index>
-    friend inline Index
-    get(const grid_graph_index_map<Graph, Descriptor, Index>& index_map,
-        const typename grid_graph_index_map<Graph, Descriptor, Index>::key_type& key)
-    {
-      return (index_map[key]);
-    }
+    friend inline grid_graph_reverse_edge_map<
+                    typename type::edge_descriptor>
+    get(edge_reverse_t, const type& graph) {
+      return (grid_graph_reverse_edge_map<
+                typename type::edge_descriptor>());
+    }                                       
 
     template<typename Graph,
              typename Descriptor,
              typename Index>
     friend struct grid_graph_index_map;
 
+    template<typename Descriptor>
+    friend struct grid_graph_reverse_edge_map;
+
   }; // grid_graph
 
 } // namespace boost
 
 #undef BOOST_GRID_GRAPH_TYPE
-#undef BOOST_GRID_GRAPH_TYPE_TD
-#undef BOOST_GRID_GRAPH_TYPE_MEM
 #undef BOOST_GRID_GRAPH_TEMPLATE_PARAMS
 #undef BOOST_GRID_GRAPH_TRAITS_T
 
diff --git a/include/boost/graph/gursoy_atun_layout.hpp b/include/boost/graph/gursoy_atun_layout.hpp
index b16a01f68..9f050e1b3 100644
--- a/include/boost/graph/gursoy_atun_layout.hpp
+++ b/include/boost/graph/gursoy_atun_layout.hpp
@@ -17,6 +17,7 @@
 
 #include <boost/config/no_tr1/cmath.hpp>
 #include <boost/throw_exception.hpp>
+#include <boost/assert.hpp>
 #include <vector>
 #include <exception>
 #include <algorithm>
@@ -169,7 +170,7 @@ gursoy_atun_step
     }
     min_distance_unset = false;
   }
-  assert (!min_distance_unset); // Graph must have at least one vertex
+  BOOST_ASSERT (!min_distance_unset); // Graph must have at least one vertex
   boost::detail::update_position_visitor<
       PositionMap, NodeDistanceMap, Topology,
       VertexListAndIncidenceGraph> 
@@ -207,9 +208,6 @@ void gursoy_atun_refine(const VertexListAndIncidenceGraph& graph,
 
   typedef typename graph_traits<VertexListAndIncidenceGraph>::vertex_iterator
     vertex_iterator;
-  typedef typename graph_traits<VertexListAndIncidenceGraph>::vertex_descriptor
-    vertex_descriptor;
-  typedef typename Topology::point_type point_type;
   vertex_iterator i, iend;
   double diameter_ratio = (double)diameter_final / diameter_initial;
   double learning_constant_ratio = 
@@ -229,6 +227,7 @@ void gursoy_atun_refine(const VertexListAndIncidenceGraph& graph,
                                 vertex_index_map);
   for (int round = 0; round < nsteps; ++round) {
     double part_done = (double)round / (nsteps - 1);
+    // fprintf(stderr, "%2d%% done\n", int(rint(part_done * 100.)));
     int diameter = (int)(diameter_initial * pow(diameter_ratio, part_done));
     double learning_constant = 
       learning_constant_initial * pow(learning_constant_ratio, part_done);
diff --git a/include/boost/graph/hawick_circuits.hpp b/include/boost/graph/hawick_circuits.hpp
new file mode 100644
index 000000000..93c12b5c7
--- /dev/null
+++ b/include/boost/graph/hawick_circuits.hpp
@@ -0,0 +1,381 @@
+// Copyright Louis Dionne 2013
+
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy
+// at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_GRAPH_HAWICK_CIRCUITS_HPP
+#define BOOST_GRAPH_HAWICK_CIRCUITS_HPP
+
+#include <algorithm>
+#include <boost/assert.hpp>
+#include <boost/foreach.hpp>
+#include <boost/graph/graph_traits.hpp>
+#include <boost/graph/one_bit_color_map.hpp>
+#include <boost/graph/properties.hpp>
+#include <boost/move/utility.hpp>
+#include <boost/property_map/property_map.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/tuple/tuple.hpp> // for boost::tie
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/utility/result_of.hpp>
+#include <set>
+#include <utility> // for std::pair
+#include <vector>
+
+
+namespace boost {
+namespace hawick_circuits_detail {
+//! @internal Functor returning all the vertices adjacent to a vertex.
+struct get_all_adjacent_vertices {
+    template <typename Sig>
+    struct result;
+
+    template <typename This, typename Vertex, typename Graph>
+    struct result<This(Vertex, Graph)> {
+    private:
+        typedef typename remove_reference<Graph>::type RawGraph;
+        typedef graph_traits<RawGraph> Traits;
+        typedef typename Traits::adjacency_iterator AdjacencyIterator;
+
+    public:
+        typedef std::pair<AdjacencyIterator, AdjacencyIterator> type;
+    };
+
+    template <typename Vertex, typename Graph>
+    typename result<
+        get_all_adjacent_vertices(BOOST_FWD_REF(Vertex), BOOST_FWD_REF(Graph))
+    >::type
+    operator()(BOOST_FWD_REF(Vertex) v, BOOST_FWD_REF(Graph) g) const {
+        return adjacent_vertices(boost::forward<Vertex>(v),
+                                 boost::forward<Graph>(g));
+    }
+};
+
+//! @internal Functor returning a set of the vertices adjacent to a vertex.
+struct get_unique_adjacent_vertices {
+    template <typename Sig>
+    struct result;
+
+    template <typename This, typename Vertex, typename Graph>
+    struct result<This(Vertex, Graph)> {
+        typedef std::set<typename remove_reference<Vertex>::type> type;
+    };
+
+    template <typename Vertex, typename Graph>
+    typename result<get_unique_adjacent_vertices(Vertex, Graph const&)>::type
+    operator()(Vertex v, Graph const& g) const {
+        typedef typename result<
+                    get_unique_adjacent_vertices(Vertex, Graph const&)
+                >::type Set;
+        return Set(adjacent_vertices(v, g).first,
+                   adjacent_vertices(v, g).second);
+    }
+};
+
+//! @internal
+//! Return whether a container contains a given value.
+//! This is not meant as a general purpose membership testing function; it
+//! would have to be more clever about possible optimizations.
+template <typename Container, typename Value>
+bool contains(Container const& c, Value const& v) {
+    return std::find(boost::begin(c), boost::end(c), v) != boost::end(c);
+}
+
+/*!
+ * @internal
+ * Algorithm finding all the cycles starting from a given vertex.
+ *
+ * The search is only done in the subgraph induced by the starting vertex
+ * and the vertices with an index higher than the starting vertex.
+ */
+template <
+    typename Graph,
+    typename Visitor,
+    typename VertexIndexMap,
+    typename Stack,
+    typename ClosedMatrix,
+    typename GetAdjacentVertices
+>
+struct hawick_circuits_from {
+private:
+    typedef graph_traits<Graph> Traits;
+    typedef typename Traits::vertex_descriptor Vertex;
+    typedef typename Traits::edge_descriptor Edge;
+    typedef typename Traits::vertices_size_type VerticesSize;
+    typedef typename property_traits<VertexIndexMap>::value_type VertexIndex;
+
+    typedef typename result_of<
+                GetAdjacentVertices(Vertex, Graph const&)
+            >::type AdjacentVertices;
+    typedef typename range_iterator<AdjacentVertices const>::type AdjacencyIterator;
+
+    // The one_bit_color_map starts all white, i.e. not blocked.
+    // Since we make that assumption (I looked at the implementation, but
+    // I can't find anything that documents this behavior), we're gonna
+    // assert it in the constructor.
+    typedef one_bit_color_map<VertexIndexMap> BlockedMap;
+    typedef typename property_traits<BlockedMap>::value_type BlockedColor;
+
+    static BlockedColor blocked_false_color()
+    { return color_traits<BlockedColor>::white(); }
+
+    static BlockedColor blocked_true_color()
+    { return color_traits<BlockedColor>::black(); }
+
+    // This is used by the constructor to secure the assumption
+    // documented above.
+    bool blocked_map_starts_all_unblocked() const {
+        BOOST_FOREACH(Vertex v, vertices(graph_))
+            if (is_blocked(v))
+                return false;
+        return true;
+    }
+
+    // This is only used in the constructor to make sure the optimization of
+    // sharing data structures between iterations does not break the code.
+    bool all_closed_rows_are_empty() const {
+        BOOST_FOREACH(typename ClosedMatrix::reference row, closed_)
+            if (!row.empty())
+                return false;
+        return true;
+    }
+
+public:
+    hawick_circuits_from(Graph const& graph, Visitor& visitor,
+                         VertexIndexMap const& vim,
+                         Stack& stack, ClosedMatrix& closed,
+                         VerticesSize n_vertices)
+        : graph_(graph), visitor_(visitor), vim_(vim), stack_(stack),
+          closed_(closed), blocked_(n_vertices, vim_)
+        {
+            BOOST_ASSERT(blocked_map_starts_all_unblocked());
+
+            // Since sharing the data structures between iterations is
+            // just an optimization, it must always be equivalent to
+            // constructing new ones in this constructor.
+            BOOST_ASSERT(stack_.empty());
+            BOOST_ASSERT(closed_.size() == n_vertices);
+            BOOST_ASSERT(all_closed_rows_are_empty());
+        }
+
+private:
+    //! @internal Return the index of a given vertex.
+    VertexIndex index_of(Vertex v) const {
+        return get(vim_, v);
+    }
+
+
+    //! @internal Return whether a vertex `v` is closed to a vertex `u`.
+    bool is_closed_to(Vertex u, Vertex v) const {
+        typedef typename ClosedMatrix::const_reference VertexList;
+        VertexList closed_to_u = closed_[index_of(u)];
+        return contains(closed_to_u, v);
+    }
+
+    //! @internal Close a vertex `v` to a vertex `u`.
+    void close_to(Vertex u, Vertex v) {
+        BOOST_ASSERT(!is_closed_to(u, v));
+        closed_[index_of(u)].push_back(v);
+    }
+
+
+    //! @internal Return whether a given vertex is blocked.
+    bool is_blocked(Vertex v) const {
+        return get(blocked_, v) == blocked_true_color();
+    }
+
+    //! @internal Block a given vertex.
+    void block(Vertex v) {
+        put(blocked_, v, blocked_true_color());
+    }
+
+    //! @internal Unblock a given vertex.
+    void unblock(Vertex u) {
+        typedef typename ClosedMatrix::reference VertexList;
+
+        put(blocked_, u, blocked_false_color());
+        VertexList closed_to_u = closed_[index_of(u)];
+
+        while (!closed_to_u.empty()) {
+            Vertex const w = closed_to_u.back();
+            closed_to_u.pop_back();
+            if (is_blocked(w))
+                unblock(w);
+        }
+        BOOST_ASSERT(closed_to_u.empty());
+    }
+
+    //! @internal Main procedure as described in the paper.
+    bool circuit(Vertex start, Vertex v) {
+        bool found_circuit = false;
+        stack_.push_back(v);
+        block(v);
+
+        // Cache some values that are used more than once in the function.
+        VertexIndex const index_of_start = index_of(start);
+        AdjacentVertices const adj_vertices = GetAdjacentVertices()(v, graph_);
+        AdjacencyIterator const w_end = boost::end(adj_vertices);
+
+        for (AdjacencyIterator w_it = boost::begin(adj_vertices);
+             w_it != w_end;
+             ++w_it)
+        {
+            Vertex const w = *w_it;
+            // Since we're only looking in the subgraph induced by `start`
+            // and the vertices with an index higher than `start`, we skip
+            // any vertex that does not satisfy that.
+            if (index_of(w) < index_of_start)
+                continue;
+
+            // If the last vertex is equal to `start`, we have a circuit.
+            else if (w == start) {
+                // const_cast to ensure the visitor does not modify the stack
+                visitor_.cycle(const_cast<Stack const&>(stack_), graph_);
+                found_circuit = true;
+            }
+
+            // If `w` is not blocked, we continue searching further down the
+            // same path for a cycle with `w` in it.
+            else if (!is_blocked(w) && circuit(start, w))
+                found_circuit = true;
+        }
+
+        if (found_circuit)
+            unblock(v);
+        else
+            for (AdjacencyIterator w_it = boost::begin(adj_vertices);
+                 w_it != w_end;
+                 ++w_it)
+            {
+                Vertex const w = *w_it;
+                // Like above, we skip vertices that are not in the subgraph
+                // we're considering.
+                if (index_of(w) < index_of_start)
+                    continue;
+
+                // If `v` is not closed to `w`, we make it so.
+                if (!is_closed_to(w, v))
+                    close_to(w, v);
+            }
+
+        BOOST_ASSERT(v == stack_.back());
+        stack_.pop_back();
+        return found_circuit;
+    }
+
+public:
+    void operator()(Vertex start) {
+        circuit(start, start);
+    }
+
+private:
+    Graph const& graph_;
+    Visitor& visitor_;
+    VertexIndexMap const& vim_;
+    Stack& stack_;
+    ClosedMatrix& closed_;
+    BlockedMap blocked_;
+};
+
+template <
+    typename GetAdjacentVertices,
+    typename Graph, typename Visitor, typename VertexIndexMap
+>
+void call_hawick_circuits(Graph const& graph,
+                          Visitor /* by value */ visitor,
+                          VertexIndexMap const& vertex_index_map) {
+    typedef graph_traits<Graph> Traits;
+    typedef typename Traits::vertex_descriptor Vertex;
+    typedef typename Traits::vertices_size_type VerticesSize;
+    typedef typename Traits::vertex_iterator VertexIterator;
+
+    typedef std::vector<Vertex> Stack;
+    typedef std::vector<std::vector<Vertex> > ClosedMatrix;
+
+    typedef hawick_circuits_from<
+                Graph, Visitor, VertexIndexMap, Stack, ClosedMatrix,
+                GetAdjacentVertices
+            > SubAlgorithm;
+
+    VerticesSize const n_vertices = num_vertices(graph);
+    Stack stack; stack.reserve(n_vertices);
+    ClosedMatrix closed(n_vertices);
+
+    VertexIterator start, last;
+    for (boost::tie(start, last) = vertices(graph); start != last; ++start) {
+        // Note1: The sub algorithm may NOT be reused once it has been called.
+
+        // Note2: We reuse the Stack and the ClosedMatrix (after clearing them)
+        // in each iteration to avoid redundant destruction and construction.
+        // It would be strictly equivalent to have these as member variables
+        // of the sub algorithm.
+        SubAlgorithm sub_algo(graph, visitor, vertex_index_map,
+                              stack, closed, n_vertices);
+        sub_algo(*start);
+        stack.clear();
+        typename ClosedMatrix::iterator row, last_row = closed.end();
+        for (row = closed.begin(); row != last_row; ++row)
+            row->clear();
+    }
+}
+
+template <typename GetAdjacentVertices, typename Graph, typename Visitor>
+void call_hawick_circuits(Graph const& graph, BOOST_FWD_REF(Visitor) visitor) {
+    call_hawick_circuits<GetAdjacentVertices>(
+        graph, boost::forward<Visitor>(visitor), get(vertex_index, graph)
+    );
+}
+} // end namespace hawick_circuits_detail
+
+//! Enumerate all the elementary circuits in a directed multigraph.
+template <typename Graph, typename Visitor, typename VertexIndexMap>
+void hawick_circuits(BOOST_FWD_REF(Graph) graph,
+                     BOOST_FWD_REF(Visitor) visitor,
+                     BOOST_FWD_REF(VertexIndexMap) vertex_index_map) {
+    hawick_circuits_detail::call_hawick_circuits<
+        hawick_circuits_detail::get_all_adjacent_vertices
+    >(
+        boost::forward<Graph>(graph),
+        boost::forward<Visitor>(visitor),
+        boost::forward<VertexIndexMap>(vertex_index_map)
+    );
+}
+
+template <typename Graph, typename Visitor>
+void hawick_circuits(BOOST_FWD_REF(Graph) graph,
+                     BOOST_FWD_REF(Visitor) visitor) {
+    hawick_circuits_detail::call_hawick_circuits<
+        hawick_circuits_detail::get_all_adjacent_vertices
+    >(boost::forward<Graph>(graph), boost::forward<Visitor>(visitor));
+}
+
+/*!
+ * Same as `boost::hawick_circuits`, but duplicate circuits caused by parallel
+ * edges will not be considered. Each circuit will be considered only once.
+ */
+template <typename Graph, typename Visitor, typename VertexIndexMap>
+void hawick_unique_circuits(BOOST_FWD_REF(Graph) graph,
+                            BOOST_FWD_REF(Visitor) visitor,
+                            BOOST_FWD_REF(VertexIndexMap) vertex_index_map) {
+    hawick_circuits_detail::call_hawick_circuits<
+        hawick_circuits_detail::get_unique_adjacent_vertices
+    >(
+        boost::forward<Graph>(graph),
+        boost::forward<Visitor>(visitor),
+        boost::forward<VertexIndexMap>(vertex_index_map)
+    );
+}
+
+template <typename Graph, typename Visitor>
+void hawick_unique_circuits(BOOST_FWD_REF(Graph) graph,
+                            BOOST_FWD_REF(Visitor) visitor) {
+    hawick_circuits_detail::call_hawick_circuits<
+        hawick_circuits_detail::get_unique_adjacent_vertices
+    >(boost::forward<Graph>(graph), boost::forward<Visitor>(visitor));
+}
+} // end namespace boost
+
+#endif // !BOOST_GRAPH_HAWICK_CIRCUITS_HPP
diff --git a/include/boost/graph/howard_cycle_ratio.hpp b/include/boost/graph/howard_cycle_ratio.hpp
index 09c6522b8..afbf26d87 100644
--- a/include/boost/graph/howard_cycle_ratio.hpp
+++ b/include/boost/graph/howard_cycle_ratio.hpp
@@ -20,6 +20,7 @@
 #include <boost/property_map/property_map.hpp>
 #include <boost/graph/graph_traits.hpp>
 #include <boost/graph/graph_concepts.hpp>
+#include <boost/concept/assert.hpp>
 
 /** @file howard_cycle_ratio.hpp
  * @brief The implementation of the maximum/minimum cycle ratio/mean algorithm.
@@ -477,13 +478,13 @@ namespace boost {
     {
       typedef typename graph_traits<TG>::directed_category DirCat;
       BOOST_STATIC_ASSERT((is_convertible<DirCat*, directed_tag*>::value == true));
-      function_requires< IncidenceGraphConcept<TG> >();
-      function_requires< VertexListGraphConcept<TG> >();
+      BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<TG> ));
+      BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<TG> ));
       typedef typename graph_traits<TG>::vertex_descriptor Vertex;
-      function_requires< ReadablePropertyMapConcept<TVIM, Vertex> >();
+      BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<TVIM, Vertex> ));
       typedef typename graph_traits<TG>::edge_descriptor Edge;
-      function_requires< ReadablePropertyMapConcept<TEW1, Edge> >();
-      function_requires< ReadablePropertyMapConcept<TEW2, Edge> >();
+      BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<TEW1, Edge> ));
+      BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<TEW2, Edge> ));
 
       if(pcc == 0) {
           return detail::mcr_howard<FT,TG, TVIM, TEW1, TEW2>(
diff --git a/include/boost/graph/is_kuratowski_subgraph.hpp b/include/boost/graph/is_kuratowski_subgraph.hpp
index fab0b0246..d0a2aede9 100644
--- a/include/boost/graph/is_kuratowski_subgraph.hpp
+++ b/include/boost/graph/is_kuratowski_subgraph.hpp
@@ -9,7 +9,6 @@
 #define __IS_KURATOWSKI_SUBGRAPH_HPP__
 
 #include <boost/config.hpp>
-#include <boost/utility.hpp> //for next/prior
 #include <boost/tuple/tuple.hpp>   //for tie
 #include <boost/property_map/property_map.hpp>
 #include <boost/graph/properties.hpp>
@@ -33,7 +32,7 @@ namespace boost
     {
       typename graph_traits<Graph>::vertex_iterator vi, vi_end, inner_vi;
       Graph K_5(5);
-      for(tie(vi,vi_end) = vertices(K_5); vi != vi_end; ++vi)
+      for(boost::tie(vi,vi_end) = vertices(K_5); vi != vi_end; ++vi)
         for(inner_vi = next(vi); inner_vi != vi_end; ++inner_vi)
           add_edge(*vi, *inner_vi, K_5);
       return K_5;
@@ -47,7 +46,7 @@ namespace boost
         vi, vi_end, bipartition_start, inner_vi;
       Graph K_3_3(6);
       bipartition_start = next(next(next(vertices(K_3_3).first)));
-      for(tie(vi, vi_end) = vertices(K_3_3); vi != bipartition_start; ++vi)
+      for(boost::tie(vi, vi_end) = vertices(K_3_3); vi != bipartition_start; ++vi)
         for(inner_vi= bipartition_start; inner_vi != vi_end; ++inner_vi)
           add_edge(*vi, *inner_vi, K_3_3);
       return K_3_3;
@@ -158,7 +157,7 @@ namespace boost
       {
 
         vertex_iterator_t vi, vi_end;
-        for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
+        for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
           {
             vertex_t v(*vi);
 
@@ -176,7 +175,7 @@ namespace boost
 
             while (neighbors[v].size() > 0 && neighbors[v].size() < max_size)
               {
-                // Find one of v's neighbors u such that that v and u
+                // Find one of v's neighbors u such that v and u
                 // have no neighbors in common. We'll look for such a 
                 // neighbor with a naive cubic-time algorithm since the 
                 // max size of any of the neighbor sets we'll consider 
@@ -242,7 +241,7 @@ namespace boost
         if (max_size == 3)
           {
             // check to see whether we should go on to find a K_5
-            for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
+            for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
               if (neighbors[*vi].size() == 4)
                 {
                   target_graph = detail::tg_k_5;
@@ -261,7 +260,7 @@ namespace boost
     v_list_t main_vertices;
     vertex_iterator_t vi, vi_end;
     
-    for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
+    for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
       {
         if (!neighbors[*vi].empty())
           main_vertices.push_back(*vi);
@@ -301,11 +300,11 @@ namespace boost
     
     if (target_graph == detail::tg_k_5)
       {
-        return isomorphism(K_5,contracted_graph);
+        return boost::isomorphism(K_5,contracted_graph);
       }
     else //target_graph == tg_k_3_3
       {
-        return isomorphism(K_3_3,contracted_graph);
+        return boost::isomorphism(K_3_3,contracted_graph);
       }
     
     
diff --git a/include/boost/graph/is_straight_line_drawing.hpp b/include/boost/graph/is_straight_line_drawing.hpp
index 6b7c39054..a4bd8ff5f 100644
--- a/include/boost/graph/is_straight_line_drawing.hpp
+++ b/include/boost/graph/is_straight_line_drawing.hpp
@@ -9,7 +9,7 @@
 #define __IS_STRAIGHT_LINE_DRAWING_HPP__
 
 #include <boost/config.hpp>
-#include <boost/utility.hpp> //for next and prior
+#include <boost/next_prior.hpp>
 #include <boost/tuple/tuple.hpp>
 #include <boost/tuple/tuple_comparison.hpp>
 #include <boost/property_map/property_map.hpp>
@@ -19,6 +19,7 @@
 #include <algorithm>
 #include <vector>
 #include <set>
+#include <map>
 
 
 
@@ -34,12 +35,12 @@ namespace boost
   // defines how far away from the endpoints of s1 and s2 we want to consider
   // an intersection.
 
-  bool intersects(double x1, double y1,
-                  double x2, double y2,
-                  double a1, double b1,
-                  double a2, double b2,
-                  double epsilon = 0.000001
-                  )
+  inline bool intersects(double x1, double y1,
+                         double x2, double y2,
+                         double a1, double b1,
+                         double a2, double b2,
+                         double epsilon = 0.000001
+                         )
   {
 
     if (x1 - x2 == 0)
@@ -105,11 +106,8 @@ namespace boost
   {
 
     typedef typename graph_traits<Graph>::vertex_descriptor vertex_t;
-    typedef typename graph_traits<Graph>::vertex_iterator vertex_iterator_t;
     typedef typename graph_traits<Graph>::edge_descriptor edge_t;
     typedef typename graph_traits<Graph>::edge_iterator edge_iterator_t;
-    typedef typename graph_traits<Graph>::edges_size_type e_size_t;
-    typedef typename graph_traits<Graph>::vertices_size_type v_size_t;
 
     typedef std::size_t x_coord_t;
     typedef std::size_t y_coord_t;
@@ -126,7 +124,7 @@ namespace boost
     active_map_t active_edges;
 
     edge_iterator_t ei, ei_end;
-    for(tie(ei,ei_end) = edges(g); ei != ei_end; ++ei)
+    for(boost::tie(ei,ei_end) = edges(g); ei != ei_end; ++ei)
       {
         edge_t e(*ei);
         vertex_t s(source(e,g));
diff --git a/include/boost/graph/isomorphism.hpp b/include/boost/graph/isomorphism.hpp
index 9461dc31e..225cd2051 100644
--- a/include/boost/graph/isomorphism.hpp
+++ b/include/boost/graph/isomorphism.hpp
@@ -11,10 +11,12 @@
 #include <iterator>
 #include <algorithm>
 #include <boost/config.hpp>
+#include <boost/assert.hpp>
+#include <boost/smart_ptr.hpp>
 #include <boost/graph/depth_first_search.hpp>
-#include <boost/utility.hpp>
 #include <boost/detail/algorithm.hpp>
 #include <boost/pending/indirect_cmp.hpp> // for make_indirect_pmap
+#include <boost/concept/assert.hpp>
 
 #ifndef BOOST_GRAPH_ITERATION_MACROS_HPP
 #define BOOST_ISO_INCLUDED_ITER_MACROS // local macro, see bottom of file
@@ -133,6 +135,10 @@ namespace boost {
     
       bool test_isomorphism()
       {
+        // reset isomapping
+        BGL_FORALL_VERTICES_T(v, G1, Graph1)
+          f[v] = graph_traits<Graph2>::null_vertex();
+          
         {
           std::vector<invar1_value> invar1_array;
           BGL_FORALL_VERTICES_T(v, G1, Graph1)
@@ -153,7 +159,7 @@ namespace boost {
         {
           std::vector<size_type> multiplicity(max_invariant, 0);
           BGL_FORALL_VERTICES_T(v, G1, Graph1)
-            ++multiplicity[invariant1(v)];
+            ++multiplicity.at(invariant1(v));
           sort(V_mult, compare_multiplicity(invariant1, &multiplicity[0]));
         }
         
@@ -194,69 +200,130 @@ namespace boost {
       }
     
     private:
+      struct match_continuation {
+        enum {pos_G2_vertex_loop, pos_fi_adj_loop, pos_dfs_num} position;
+        typedef typename graph_traits<Graph2>::vertex_iterator vertex_iterator;
+        std::pair<vertex_iterator, vertex_iterator> G2_verts;
+        typedef typename graph_traits<Graph2>::adjacency_iterator adjacency_iterator;
+        std::pair<adjacency_iterator, adjacency_iterator> fi_adj;
+        edge_iter iter;
+        int dfs_num_k;
+      };
+
       bool match(edge_iter iter, int dfs_num_k)
       {
+        std::vector<match_continuation> k;
+        typedef typename graph_traits<Graph2>::vertex_iterator vertex_iterator;
+        std::pair<vertex_iterator, vertex_iterator> G2_verts(vertices(G2));
+        typedef typename graph_traits<Graph2>::adjacency_iterator adjacency_iterator;
+        std::pair<adjacency_iterator, adjacency_iterator> fi_adj;
+        vertex1_t i, j;
+
+        recur:
         if (iter != ordered_edges.end()) {
-          vertex1_t i = source(*iter, G1), j = target(*iter, G2);
+          i = source(*iter, G1);
+          j = target(*iter, G1);
           if (dfs_num[i] > dfs_num_k) {
-            vertex1_t kp1 = dfs_vertices[dfs_num_k + 1];
-            BGL_FORALL_VERTICES_T(u, G2, Graph2) {
-              if (invariant1(kp1) == invariant2(u) && in_S[u] == false) {
-                f[kp1] = u;
-                in_S[u] = true;
-                num_edges_on_k = 0;
-                
-                if (match(iter, dfs_num_k + 1))
-#if 0
-                    // dwa 2003/7/11 -- this *HAS* to be a bug!
-                    ;
-#endif 
-                    return true;
+            G2_verts = vertices(G2);
+            while (G2_verts.first != G2_verts.second) {
+              {
+                vertex2_t u = *G2_verts.first;
+                vertex1_t kp1 = dfs_vertices[dfs_num_k + 1];
+                if (invariant1(kp1) == invariant2(u) && in_S[u] == false) {
+                  {
+                    f[kp1] = u;
+                    in_S[u] = true;
+                    num_edges_on_k = 0;
                     
-                in_S[u] = false;
+                    match_continuation new_k;
+                    new_k.position = match_continuation::pos_G2_vertex_loop;
+                    new_k.G2_verts = G2_verts;
+                    new_k.iter = iter;
+                    new_k.dfs_num_k = dfs_num_k;
+                    k.push_back(new_k);
+                    ++dfs_num_k;
+                    goto recur;
+                  }
+                }
               }
+G2_loop_k:    ++G2_verts.first;
             }
                
           }
           else if (dfs_num[j] > dfs_num_k) {
-            vertex1_t k = dfs_vertices[dfs_num_k];
-            num_edges_on_k -= 
-              count_if(adjacent_vertices(f[k], G2), make_indirect_pmap(in_S));
-                
-            for (int jj = 0; jj < dfs_num_k; ++jj) {
-              vertex1_t j = dfs_vertices[jj];
-              num_edges_on_k -= count(adjacent_vertices(f[j], G2), f[k]);
+            {
+              vertex1_t vk = dfs_vertices[dfs_num_k];
+              num_edges_on_k -= 
+                count_if(adjacent_vertices(f[vk], G2), make_indirect_pmap(in_S));
+                  
+              for (int jj = 0; jj < dfs_num_k; ++jj) {
+                vertex1_t j = dfs_vertices[jj];
+                num_edges_on_k -= count(adjacent_vertices(f[j], G2), f[vk]);
+              }
             }
                 
             if (num_edges_on_k != 0)
-              return false;
-            BGL_FORALL_ADJ_T(f[i], v, G2, Graph2)
-              if (invariant2(v) == invariant1(j) && in_S[v] == false) {
-                f[j] = v;
-                in_S[v] = true;
-                num_edges_on_k = 1;
-                BOOST_USING_STD_MAX();
-                int next_k = max BOOST_PREVENT_MACRO_SUBSTITUTION(dfs_num_k, max BOOST_PREVENT_MACRO_SUBSTITUTION(dfs_num[i], dfs_num[j]));
-                if (match(boost::next(iter), next_k))
-                  return true;
-                in_S[v] = false;
+              goto return_point_false;
+            fi_adj = adjacent_vertices(f[i], G2);
+            while (fi_adj.first != fi_adj.second) {
+              {
+                vertex2_t v = *fi_adj.first;
+                if (invariant2(v) == invariant1(j) && in_S[v] == false) {
+                  f[j] = v;
+                  in_S[v] = true;
+                  num_edges_on_k = 1;
+                  BOOST_USING_STD_MAX();
+                  int next_k = max BOOST_PREVENT_MACRO_SUBSTITUTION(dfs_num_k, max BOOST_PREVENT_MACRO_SUBSTITUTION(dfs_num[i], dfs_num[j]));
+                  match_continuation new_k;
+                  new_k.position = match_continuation::pos_fi_adj_loop;
+                  new_k.fi_adj = fi_adj;
+                  new_k.iter = iter;
+                  new_k.dfs_num_k = dfs_num_k;
+                  ++iter;
+                  dfs_num_k = next_k;
+                  k.push_back(new_k);
+                  goto recur;
+                }
               }
-                
-                
+fi_adj_loop_k:++fi_adj.first;
+            }
           }
           else {
             if (container_contains(adjacent_vertices(f[i], G2), f[j])) {
               ++num_edges_on_k;
-              if (match(boost::next(iter), dfs_num_k))
-                return true;
+              match_continuation new_k;
+              new_k.position = match_continuation::pos_dfs_num;
+              k.push_back(new_k);
+              ++iter;
+              goto recur;
             }
                 
           }
         } else 
-          return true;
-        return false;
-      }
+          goto return_point_true;
+        goto return_point_false;
     
+        {
+          return_point_true: return true;
+
+          return_point_false:
+          if (k.empty()) return false;
+          const match_continuation& this_k = k.back();
+          switch (this_k.position) {
+            case match_continuation::pos_G2_vertex_loop: {G2_verts = this_k.G2_verts; iter = this_k.iter; dfs_num_k = this_k.dfs_num_k; k.pop_back(); in_S[*G2_verts.first] = false; i = source(*iter, G1); j = target(*iter, G1); goto G2_loop_k;}
+            case match_continuation::pos_fi_adj_loop: {fi_adj = this_k.fi_adj; iter = this_k.iter; dfs_num_k = this_k.dfs_num_k; k.pop_back(); in_S[*fi_adj.first] = false; i = source(*iter, G1); j = target(*iter, G1); goto fi_adj_loop_k;}
+            case match_continuation::pos_dfs_num: {k.pop_back(); goto return_point_false;}
+            default: {
+              BOOST_ASSERT(!"Bad position");
+#ifdef UNDER_CE
+              exit(-1);
+#else
+              abort();
+#endif
+            }
+          }
+        }
+      }
     };
 
     
@@ -284,21 +351,41 @@ namespace boost {
     typedef size_type result_type;
 
     degree_vertex_invariant(const InDegreeMap& in_degree_map, const Graph& g)
-      : m_in_degree_map(in_degree_map), m_g(g) { }
+      : m_in_degree_map(in_degree_map),
+        m_max_vertex_in_degree(0),
+        m_max_vertex_out_degree(0),
+        m_g(g) {
+      BGL_FORALL_VERTICES_T(v, g, Graph) {
+        m_max_vertex_in_degree =
+          (std::max)(m_max_vertex_in_degree, get(m_in_degree_map, v));
+        m_max_vertex_out_degree =
+          (std::max)(m_max_vertex_out_degree, out_degree(v, g));
+      }
+    }
 
     size_type operator()(vertex_t v) const {
-      return (num_vertices(m_g) + 1) * out_degree(v, m_g)
+      return (m_max_vertex_in_degree + 1) * out_degree(v, m_g)
         + get(m_in_degree_map, v);
     }
     // The largest possible vertex invariant number
     size_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const { 
-      return num_vertices(m_g) * num_vertices(m_g) + num_vertices(m_g);
+      return (m_max_vertex_in_degree + 1) * (m_max_vertex_out_degree + 1);
     }
   private:
     InDegreeMap m_in_degree_map;
+    size_type m_max_vertex_in_degree;
+    size_type m_max_vertex_out_degree;
     const Graph& m_g;
   };
 
+  // Count actual number of vertices, even in filtered graphs.
+  template <typename Graph>
+  size_t count_vertices(const Graph& g)
+  {
+      size_t n = 0;
+      BGL_FORALL_VERTICES_T(v, g, Graph) {(void)v; ++n;}
+      return n;
+  }
 
   template <typename Graph1, typename Graph2, typename IsoMapping, 
     typename Invariant1, typename Invariant2,
@@ -310,37 +397,37 @@ namespace boost {
 
   {
     // Graph requirements
-    function_requires< VertexListGraphConcept<Graph1> >();
-    function_requires< EdgeListGraphConcept<Graph1> >();
-    function_requires< VertexListGraphConcept<Graph2> >();
-    function_requires< BidirectionalGraphConcept<Graph2> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph1> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph1> ));
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph2> ));
+    //BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph2> ));
     
     typedef typename graph_traits<Graph1>::vertex_descriptor vertex1_t;
     typedef typename graph_traits<Graph2>::vertex_descriptor vertex2_t;
     typedef typename graph_traits<Graph1>::vertices_size_type size_type;
     
     // Vertex invariant requirement
-    function_requires< AdaptableUnaryFunctionConcept<Invariant1,
-      size_type, vertex1_t> >();
-    function_requires< AdaptableUnaryFunctionConcept<Invariant2,
-      size_type, vertex2_t> >();
+    BOOST_CONCEPT_ASSERT(( AdaptableUnaryFunctionConcept<Invariant1,
+      size_type, vertex1_t> ));
+    BOOST_CONCEPT_ASSERT(( AdaptableUnaryFunctionConcept<Invariant2,
+      size_type, vertex2_t> ));
     
     // Property map requirements
-    function_requires< ReadWritePropertyMapConcept<IsoMapping, vertex1_t> >();
+    BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<IsoMapping, vertex1_t> ));
     typedef typename property_traits<IsoMapping>::value_type IsoMappingValue;
-    BOOST_STATIC_ASSERT((is_same<IsoMappingValue, vertex2_t>::value));
+    BOOST_STATIC_ASSERT((is_convertible<IsoMappingValue, vertex2_t>::value));
     
-    function_requires< ReadablePropertyMapConcept<IndexMap1, vertex1_t> >();
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<IndexMap1, vertex1_t> ));
     typedef typename property_traits<IndexMap1>::value_type IndexMap1Value;
     BOOST_STATIC_ASSERT((is_convertible<IndexMap1Value, size_type>::value));
     
-    function_requires< ReadablePropertyMapConcept<IndexMap2, vertex2_t> >();
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<IndexMap2, vertex2_t> ));
     typedef typename property_traits<IndexMap2>::value_type IndexMap2Value;
     BOOST_STATIC_ASSERT((is_convertible<IndexMap2Value, size_type>::value));
     
-    if (num_vertices(G1) != num_vertices(G2))
+    if (count_vertices(G1) != count_vertices(G2))
       return false;
-    if (num_vertices(G1) == 0 && num_vertices(G2) == 0)
+    if (count_vertices(G1) == 0 && count_vertices(G2) == 0)
       return true;
     
     detail::isomorphism_algo<Graph1, Graph2, IsoMapping, Invariant1,
@@ -391,39 +478,68 @@ namespace boost {
                          index_map1, index_map2
                          );  
     }  
+
+    template <typename G, typename Index>
+    struct make_degree_invariant {
+      const G& g;
+      const Index& index;
+      make_degree_invariant(const G& g, const Index& index): g(g), index(index) {}
+      typedef typename boost::graph_traits<G>::degree_size_type degree_size_type;
+      typedef shared_array_property_map<degree_size_type, Index> prop_map_type;
+      typedef degree_vertex_invariant<prop_map_type, G> result_type;
+      result_type operator()() const {
+        prop_map_type pm = make_shared_array_property_map(num_vertices(g), degree_size_type(), index);
+        compute_in_degree(g, pm);
+        return result_type(pm, g);
+      }
+    };
    
   } // namespace detail
 
-
-  // Named parameter interface
-  template <typename Graph1, typename Graph2, class P, class T, class R>
-  bool isomorphism(const Graph1& g1,
-                   const Graph2& g2,
-                   const bgl_named_params<P,T,R>& params)
-  {
-    typedef typename graph_traits<Graph2>::vertex_descriptor vertex2_t;
-    typename std::vector<vertex2_t>::size_type n = num_vertices(g1);
-    std::vector<vertex2_t> f(n);
-    return detail::isomorphism_impl
-      (g1, g2, 
-       choose_param(get_param(params, vertex_isomorphism_t()),
-                    make_safe_iterator_property_map(f.begin(), f.size(),
-                                                    choose_const_pmap(get_param(params, vertex_index1),
-                                                                      g1, vertex_index), vertex2_t())),
-       choose_const_pmap(get_param(params, vertex_index1), g1, vertex_index),
-       choose_const_pmap(get_param(params, vertex_index2), g2, vertex_index),
-       params
-       );
-  }
-
-  // All defaults interface
-  template <typename Graph1, typename Graph2>
-  bool isomorphism(const Graph1& g1, const Graph2& g2)
-  {
-    return isomorphism(g1, g2,
-                       bgl_named_params<int, buffer_param_t>(0));// bogus named param
+  namespace graph {
+    namespace detail {
+      template <typename Graph1, typename Graph2>
+      struct isomorphism_impl {
+        typedef bool result_type;
+        template <typename ArgPack>
+        bool operator()(const Graph1& g1, const Graph2& g2, const ArgPack& arg_pack) const {
+          using namespace boost::graph::keywords;
+          typedef typename boost::detail::override_const_property_result<ArgPack, tag::vertex_index1_map, boost::vertex_index_t, Graph1>::type index1_map_type;
+          typedef typename boost::detail::override_const_property_result<ArgPack, tag::vertex_index2_map, boost::vertex_index_t, Graph2>::type index2_map_type;
+          index1_map_type index1_map = boost::detail::override_const_property(arg_pack, _vertex_index1_map, g1, boost::vertex_index);
+          index2_map_type index2_map = boost::detail::override_const_property(arg_pack, _vertex_index2_map, g2, boost::vertex_index);
+          typedef typename graph_traits<Graph2>::vertex_descriptor vertex2_t;
+          typename std::vector<vertex2_t>::size_type n = (typename std::vector<vertex2_t>::size_type)num_vertices(g1);
+          std::vector<vertex2_t> f(n);
+          typename boost::parameter::lazy_binding<
+                     ArgPack,
+                     tag::vertex_invariant1,
+                     boost::detail::make_degree_invariant<Graph1, index1_map_type> >::type
+            invariant1 =
+              arg_pack[_vertex_invariant1 || boost::detail::make_degree_invariant<Graph1, index1_map_type>(g1, index1_map)];
+          typename boost::parameter::lazy_binding<
+                     ArgPack,
+                     tag::vertex_invariant2,
+                     boost::detail::make_degree_invariant<Graph2, index2_map_type> >::type
+            invariant2 =
+              arg_pack[_vertex_invariant2 || boost::detail::make_degree_invariant<Graph2, index2_map_type>(g2, index2_map)];
+          return boost::isomorphism
+                   (g1, g2,
+                    choose_param(arg_pack[_isomorphism_map | boost::param_not_found()],
+                                 make_shared_array_property_map(num_vertices(g1), vertex2_t(), index1_map)),
+                    invariant1,
+                    invariant2,
+                    arg_pack[_vertex_max_invariant | (invariant2.max)()],
+                    index1_map,
+                    index2_map);
+        }
+      };
+    }
+    BOOST_GRAPH_MAKE_FORWARDING_FUNCTION(isomorphism, 2, 6)
   }
 
+  // Named parameter interface
+  BOOST_GRAPH_MAKE_OLD_STYLE_PARAMETER_FUNCTION(isomorphism, 2)
 
   // Verify that the given mapping iso_map from the vertices of g1 to the
   // vertices of g2 describes an isomorphism.
diff --git a/include/boost/graph/johnson_all_pairs_shortest.hpp b/include/boost/graph/johnson_all_pairs_shortest.hpp
index 8aec50059..1e703791d 100644
--- a/include/boost/graph/johnson_all_pairs_shortest.hpp
+++ b/include/boost/graph/johnson_all_pairs_shortest.hpp
@@ -29,6 +29,7 @@
 #include <boost/graph/dijkstra_shortest_paths.hpp>
 #include <boost/graph/adjacency_list.hpp>
 #include <boost/type_traits/same_traits.hpp>
+#include <boost/concept/assert.hpp>
 
 namespace boost {
 
@@ -44,8 +45,8 @@ namespace boost {
   {
     typedef graph_traits<VertexAndEdgeListGraph> Traits1;
     typedef typename property_traits<Weight>::value_type DT;
-    function_requires< BasicMatrixConcept<DistanceMatrix,
-      typename Traits1::vertices_size_type, DT> >();
+    BOOST_CONCEPT_ASSERT(( BasicMatrixConcept<DistanceMatrix,
+      typename Traits1::vertices_size_type, DT> ));
 
     typedef typename Traits1::directed_category DirCat;
     bool is_undirected = is_same<DirCat, undirected_tag>::value;
@@ -112,7 +113,7 @@ namespace boost {
       for (boost::tie(e, e_end) = edges(g2); e != e_end; ++e) {
         typename Traits2::vertex_descriptor a = source(*e, g2),
           b = target(*e, g2);
-        put(w_hat, *e, combine(get(w, *e), (get(h, a) - get(h, b))));
+        put(w_hat, *e, combine((get(h, a) - get(h, b)), get(w, *e)));
       }
       for (boost::tie(u, u_end) = vertices(g2); u != u_end; ++u) {
         dijkstra_visitor<> dvis;
@@ -120,9 +121,7 @@ namespace boost {
           (g2, *u, pred, d, w_hat, id2, compare, combine, inf, zero,dvis);
         for (boost::tie(v, v_end) = vertices(g2); v != v_end; ++v) {
           if (*u != s && *v != s) {
-            typename Traits1::vertex_descriptor u1, v1;
-            u1 = verts1[get(id2, *u)]; v1 = verts1[get(id2, *v)];
-            D[get(id2, *u)-1][get(id2, *v)-1] = combine(get(d, *v), (get(h, *v) - get(h, *u)));
+            D[get(id2, *u)-1][get(id2, *v)-1] = combine((get(h, *v) - get(h, *u)), get(d, *v));
           }
         }
       }
diff --git a/include/boost/graph/kamada_kawai_spring_layout.hpp b/include/boost/graph/kamada_kawai_spring_layout.hpp
index 0262e1fc2..63355c946 100644
--- a/include/boost/graph/kamada_kawai_spring_layout.hpp
+++ b/include/boost/graph/kamada_kawai_spring_layout.hpp
@@ -17,6 +17,7 @@
 #include <utility>
 #include <iterator>
 #include <vector>
+#include <iostream>
 #include <boost/limits.hpp>
 #include <boost/config/no_tr1/cmath.hpp>
 
@@ -216,11 +217,13 @@ namespace boost {
         weight_type edge_length = 
           detail::graph::compute_edge_length(g, distance, index,
                                              edge_or_side_length);
+
+        // std::cerr << "edge_length = " << edge_length << std::endl;
         
         // Compute l_{ij} and k_{ij}
         const weight_type K = spring_constant;
-        vertex_iterator ui, end = vertices(g).second;
-        for (ui = vertices(g).first; ui != end; ++ui) {
+        vertex_iterator ui, end;
+        for (ui = vertices(g).first, end = vertices(g).second; ui != end; ++ui) {
           vertex_iterator vi = ui;
           for (++vi; vi != end; ++vi) {
             weight_type dij = distance[get(index, *ui)][get(index, *vi)];
@@ -237,7 +240,7 @@ namespace boost {
         vertex_descriptor p = *vertices(g).first;
         weight_type delta_p(0);
 
-        for (ui = vertices(g).first; ui != end; ++ui) {
+        for (ui = vertices(g).first, end = vertices(g).second; ui != end; ++ui) {
           deriv_type deriv = compute_partial_derivatives(*ui);
           put(partial_derivatives, *ui, deriv);
 
@@ -255,12 +258,25 @@ namespace boost {
           // update the delta_i values in O(n) time instead of O(n^2)
           // time.
           std::vector<deriv_type> p_partials(num_vertices(g));
-          for (ui = vertices(g).first; ui != end; ++ui) {
+          for (ui = vertices(g).first, end = vertices(g).second; ui != end; ++ui) {
             vertex_descriptor i = *ui;
             p_partials[get(index, i)] = compute_partial_derivative(i, p);
           }
 
           do {
+            // For debugging, compute the energy value E
+            double E = 0.;
+            for (ui = vertices(g).first, end = vertices(g).second; ui != end; ++ui) {
+              vertex_iterator vi = ui;
+              for (++vi; vi != end; ++vi) {
+                double dist = topology.distance(position[*ui], position[*vi]);
+                weight_type k_ij = spring_strength[get(index,*ui)][get(index,*vi)];
+                weight_type l_ij = distance[get(index, *ui)][get(index, *vi)];
+                E += .5 * k_ij * (dist - l_ij) * (dist - l_ij);
+              }
+            }
+            // std::cerr << "E = " << E << std::endl;
+
             // Compute the elements of the Jacobian
             // From
             // http://www.cs.panam.edu/~rfowler/papers/1994_kumar_fowler_A_Spring_UTPACSTR.pdf
@@ -269,7 +285,7 @@ namespace boost {
             for (std::size_t i = 0; i < Point::dimensions; ++i)
               for (std::size_t j = 0; j < Point::dimensions; ++j)
                 dE_d_d[i][j] = 0.;
-            for (ui = vertices(g).first; ui != end; ++ui) {
+            for (ui = vertices(g).first, end = vertices(g).second; ui != end; ++ui) {
               vertex_descriptor i = *ui;
               if (i != p) {
                 point_difference_type diff = topology.difference(position[p], position[i]);
@@ -284,6 +300,7 @@ namespace boost {
                       dE_d_d[i][i] += k_mi * (1 + (l_mi * (diff[i] * diff[i] - dist_squared) * inv_dist_cubed));
                     } else {
                       dE_d_d[i][j] += k_mi * l_mi * diff[i] * diff[j] * inv_dist_cubed;
+                      // dE_d_d[i][j] += k_mi * l_mi * sqrt(hypot(diff[i], diff[j])) * inv_dist_cubed;
                     }
                   }
                 }
@@ -292,7 +309,7 @@ namespace boost {
 
             deriv_type dE_d = get(partial_derivatives, p);
 
-            // Solve dE_d_d * delta = dE_d to get delta
+            // Solve dE_d_d * delta = -dE_d to get delta
             point_difference_type delta = -linear_solver<Point::dimensions>::solve(dE_d_d, dE_d);
 
             // Move p by delta
@@ -307,7 +324,7 @@ namespace boost {
 
           // Select new p by updating each partial derivative and delta
           vertex_descriptor old_p = p;
-          for (ui = vertices(g).first; ui != end; ++ui) {
+          for (ui = vertices(g).first, end = vertices(g).second; ui != end; ++ui) {
             deriv_type old_deriv_p = p_partials[get(index, *ui)];
             deriv_type old_p_partial = 
               compute_partial_derivative(*ui, old_p);
@@ -458,12 +475,12 @@ namespace boost {
    * from every vertex to every other vertex, which is computed in the
    * first stages of the algorithm. This value's type must be a model
    * of BasicMatrix with value type equal to the value type of the
-   * weight map. The default is a a vector of vectors.
+   * weight map. The default is a vector of vectors.
    *
    * \param spring_strength (UTIL/OUT) will be used to store the
    * strength of the spring between every pair of vertices. This
    * value's type must be a model of BasicMatrix with value type equal
-   * to the value type of the weight map. The default is a a vector of
+   * to the value type of the weight map. The default is a vector of
    * vectors.
    *
    * \param partial_derivatives (UTIL) will be used to store the
diff --git a/include/boost/graph/king_ordering.hpp b/include/boost/graph/king_ordering.hpp
index 9d9a438f3..29e7ac970 100644
--- a/include/boost/graph/king_ordering.hpp
+++ b/include/boost/graph/king_ordering.hpp
@@ -37,7 +37,6 @@ namespace boost {
         typename graph_traits<Graph>::out_edge_iterator ei, ei_end;
         Vertex v, w;
 
-        typedef typename std::deque<Vertex>::iterator iterator;
         typedef typename std::deque<Vertex>::reverse_iterator reverse_iterator;
 
         reverse_iterator rend = Qptr->rend()-index_begin;
@@ -86,8 +85,6 @@ namespace boost {
       //this function replaces pop_heap, and tracks state information
       template <typename Vertex>
       void percolate_down(int offset){
-        typedef typename std::deque<Vertex>::reverse_iterator reverse_iterator;
-        
         int heap_last = index_begin + offset;
         int heap_first = Qptr->size() - 1;
         
@@ -267,7 +264,6 @@ namespace boost {
       return permutation;
 
     typedef typename boost::graph_traits<Graph>::vertex_descriptor Vertex;
-    typedef typename boost::graph_traits<Graph>::vertex_iterator   VerIter;
     typedef typename property_traits<ColorMap>::value_type ColorValue;
     typedef color_traits<ColorValue> Color;
 
@@ -302,7 +298,6 @@ namespace boost {
     if (has_no_vertices(G))
       return permutation;
 
-    typedef out_degree_property_map<Graph> DegreeMap;
     std::vector<default_color_type> colors(num_vertices(G));
     return king_ordering(G, permutation, 
                          make_iterator_property_map(&colors[0], index_map,
diff --git a/include/boost/graph/kolmogorov_max_flow.hpp b/include/boost/graph/kolmogorov_max_flow.hpp
deleted file mode 100644
index c2b94c094..000000000
--- a/include/boost/graph/kolmogorov_max_flow.hpp
+++ /dev/null
@@ -1,814 +0,0 @@
-//  Copyright (c) 2006, Stephan Diederich
-//
-//  This code may be used under either of the following two licences:
-//
-//    Permission is hereby granted, free of charge, to any person
-//    obtaining a copy of this software and associated documentation
-//    files (the "Software"), to deal in the Software without
-//    restriction, including without limitation the rights to use,
-//    copy, modify, merge, publish, distribute, sublicense, and/or
-//    sell copies of the Software, and to permit persons to whom the
-//    Software is furnished to do so, subject to the following
-//    conditions:
-//
-//    The above copyright notice and this permission notice shall be
-//    included in all copies or substantial portions of the Software.
-//
-//    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-//    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-//    OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-//    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-//    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-//    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-//    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-//    OTHER DEALINGS IN THE SOFTWARE. OF SUCH DAMAGE.
-//
-//  Or:
-//
-//    Distributed under the Boost Software License, Version 1.0.
-//    (See accompanying file LICENSE_1_0.txt or copy at
-//    http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_KOLMOGOROV_MAX_FLOW_HPP
-#define BOOST_KOLMOGOROV_MAX_FLOW_HPP
-
-#if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__DMC__)
-#  pragma message ("The kolmogorov_max_flow.hpp header is deprecated and will be removed in Boost 1.46. Use boykov_kolmogorov_max_flow.hpp instead.")
-#elif defined(__GNUC__) || defined(__HP_aCC) || defined(__SUNPRO_CC) || defined(__IBMCPP__)
-#  warning "The kolmogorov_max_flow.hpp header is deprecated and will be removed in Boost 1.46. Use boykov_kolmogorov_max_flow.hpp instead."
-#endif
-
-#include <boost/config.hpp>
-#include <cassert>
-#include <vector>
-#include <list>
-#include <utility>
-#include <iosfwd>
-#include <algorithm> // for std::min and std::max
-
-#include <boost/pending/queue.hpp>
-#include <boost/limits.hpp>
-#include <boost/property_map/property_map.hpp>
-#include <boost/none_t.hpp>
-#include <boost/graph/graph_concepts.hpp>
-#include <boost/graph/named_function_params.hpp>
-#include <boost/graph/lookup_edge.hpp>
-
-namespace boost {
-  namespace detail {
-
-    template <class Graph,
-              class EdgeCapacityMap,
-              class ResidualCapacityEdgeMap,
-              class ReverseEdgeMap,
-              class PredecessorMap,
-              class ColorMap,
-              class DistanceMap,
-              class IndexMap>
-    class kolmogorov{
-      typedef typename property_traits<EdgeCapacityMap>::value_type tEdgeVal;
-      typedef graph_traits<Graph> tGraphTraits;
-      typedef typename tGraphTraits::vertex_iterator vertex_iterator;
-      typedef typename tGraphTraits::vertex_descriptor vertex_descriptor;
-      typedef typename tGraphTraits::edge_descriptor edge_descriptor;
-      typedef typename tGraphTraits::edge_iterator edge_iterator;
-      typedef typename tGraphTraits::out_edge_iterator out_edge_iterator;
-      typedef boost::queue<vertex_descriptor> tQueue;                               //queue of vertices, used in adoption-stage
-      typedef typename property_traits<ColorMap>::value_type tColorValue;
-      typedef color_traits<tColorValue> tColorTraits;
-      typedef typename property_traits<DistanceMap>::value_type tDistanceVal;
-
-        public:
-          kolmogorov(Graph& g,
-                     EdgeCapacityMap cap,
-                     ResidualCapacityEdgeMap res,
-                     ReverseEdgeMap rev,
-                     PredecessorMap pre,
-                     ColorMap color,
-                     DistanceMap dist,
-                     IndexMap idx,
-                     vertex_descriptor src,
-                     vertex_descriptor sink):
-          m_g(g),
-          m_index_map(idx),
-          m_cap_map(cap),
-          m_res_cap_map(res),
-          m_rev_edge_map(rev),
-          m_pre_map(pre),
-          m_tree_map(color),
-          m_dist_map(dist),
-          m_source(src),
-          m_sink(sink),
-          m_active_nodes(),
-          m_in_active_list_vec(num_vertices(g), false),
-          m_in_active_list_map(make_iterator_property_map(m_in_active_list_vec.begin(), m_index_map)),
-          m_has_parent_vec(num_vertices(g), false),
-          m_has_parent_map(make_iterator_property_map(m_has_parent_vec.begin(), m_index_map)),
-          m_time_vec(num_vertices(g), 0),
-          m_time_map(make_iterator_property_map(m_time_vec.begin(), m_index_map)),
-          m_flow(0),
-          m_time(1),
-          m_last_grow_vertex(graph_traits<Graph>::null_vertex()){
-            // initialize the color-map with gray-values
-            vertex_iterator vi, v_end;
-            for(boost::tie(vi, v_end) = vertices(m_g); vi != v_end; ++vi){
-              set_tree(*vi, tColorTraits::gray());
-            }
-            // Initialize flow to zero which means initializing
-            // the residual capacity equal to the capacity
-            edge_iterator ei, e_end;
-            for(boost::tie(ei, e_end) = edges(m_g); ei != e_end; ++ei) {
-              m_res_cap_map[*ei] = m_cap_map[*ei];
-              assert(m_rev_edge_map[m_rev_edge_map[*ei]] == *ei); //check if the reverse edge map is build up properly
-            }
-            //init the search trees with the two terminals
-            set_tree(m_source, tColorTraits::black());
-            set_tree(m_sink, tColorTraits::white());
-            m_time_map[m_source] = 1;
-            m_time_map[m_sink] = 1;
-          }
-
-          ~kolmogorov(){}
-
-          tEdgeVal max_flow(){
-            //augment direct paths from SOURCE->SINK and SOURCE->VERTEX->SINK
-            augment_direct_paths();
-            //start the main-loop
-            while(true){
-              bool path_found;
-              edge_descriptor connecting_edge;
-              boost::tie(connecting_edge, path_found) = grow(); //find a path from source to sink
-              if(!path_found){
-                //we're finished, no more paths were found
-                break;
-              }
-              ++m_time;
-              augment(connecting_edge); //augment that path
-              adopt(); //rebuild search tree structure
-            }
-            return m_flow;
-          }
-
-          //the complete class is protected, as we want access to members in derived test-class (see $(BOOST_ROOT)/libs/graph/test/kolmogorov_max_flow_test.cpp)
-        protected:
-          void augment_direct_paths(){
-            //in a first step, we augment all direct paths from source->NODE->sink
-            //and additionally paths from source->sink
-            //this improves especially graphcuts for segmentation, as most of the nodes have source/sink connects
-            //but shouldn't have an impact on other maxflow problems (this is done in grow() anyway)
-            out_edge_iterator ei, e_end;
-            for(boost::tie(ei, e_end) = out_edges(m_source, m_g); ei != e_end; ++ei){
-              edge_descriptor from_source = *ei;
-              vertex_descriptor current_node = target(from_source, m_g);
-              if(current_node == m_sink){
-                tEdgeVal cap = m_res_cap_map[from_source];
-                m_res_cap_map[from_source] = 0;
-                m_flow += cap;
-                continue;
-              }
-              edge_descriptor to_sink;
-              bool is_there;
-              boost::tie(to_sink, is_there) = lookup_edge(current_node, m_sink, m_g);
-              if(is_there){
-                tEdgeVal cap_from_source = m_res_cap_map[from_source];
-                tEdgeVal cap_to_sink = m_res_cap_map[to_sink];
-                if(cap_from_source > cap_to_sink){
-                  set_tree(current_node, tColorTraits::black());
-                  add_active_node(current_node);
-                  set_edge_to_parent(current_node, from_source);
-                  m_dist_map[current_node] = 1;
-                  m_time_map[current_node] = 1;
-                  //add stuff to flow and update residuals
-                  //we dont need to update reverse_edges, as incoming/outgoing edges to/from source/sink don't count for max-flow
-                  m_res_cap_map[from_source] -= cap_to_sink;
-                  m_res_cap_map[to_sink] = 0;
-                  m_flow += cap_to_sink;
-                } else if(cap_to_sink > 0){
-                  set_tree(current_node, tColorTraits::white());
-                  add_active_node(current_node);
-                  set_edge_to_parent(current_node, to_sink);
-                  m_dist_map[current_node] = 1;
-                  m_time_map[current_node] = 1;
-                  //add stuff to flow and update residuals
-                  //we dont need to update reverse_edges, as incoming/outgoing edges to/from source/sink don't count for max-flow
-                  m_res_cap_map[to_sink] -= cap_from_source;
-                  m_res_cap_map[from_source] = 0;
-                  m_flow += cap_from_source;
-                }
-              } else if(m_res_cap_map[from_source]){
-                //there is no sink connect, so we can't augment this path
-                //but to avoid adding m_source to the active nodes, we just activate this node and set the approciate things
-                set_tree(current_node, tColorTraits::black());
-                set_edge_to_parent(current_node, from_source);
-                m_dist_map[current_node] = 1;
-                m_time_map[current_node] = 1;
-                add_active_node(current_node);
-              }
-            }
-            for(boost::tie(ei, e_end) = out_edges(m_sink, m_g); ei != e_end; ++ei){
-              edge_descriptor to_sink = m_rev_edge_map[*ei];
-              vertex_descriptor current_node = source(to_sink, m_g);
-              if(m_res_cap_map[to_sink]){
-                set_tree(current_node, tColorTraits::white());
-                set_edge_to_parent(current_node, to_sink);
-                m_dist_map[current_node] = 1;
-                m_time_map[current_node] = 1;
-                add_active_node(current_node);
-              }
-            }
-          }
-
-          /**
-          * returns a pair of an edge and a boolean. if the bool is true, the edge is a connection of a found path from s->t , read "the link" and
-          *   source(returnVal, m_g) is the end of the path found in the source-tree
-          *   target(returnVal, m_g) is the beginning of the path found in the sink-tree
-          */
-          std::pair<edge_descriptor, bool> grow(){
-            assert(m_orphans.empty());
-            vertex_descriptor current_node;
-            while((current_node = get_next_active_node()) != graph_traits<Graph>::null_vertex()){ //if there is one
-              assert(get_tree(current_node) != tColorTraits::gray()  && (has_parent(current_node) || current_node==m_source || current_node==m_sink));
-              if(get_tree(current_node) == tColorTraits::black()){
-                //source tree growing
-                out_edge_iterator ei, e_end;
-                if(current_node != m_last_grow_vertex){
-                  m_last_grow_vertex = current_node;
-                  boost::tie(m_last_grow_edge_it, m_last_grow_edge_end) = out_edges(current_node, m_g);
-                }
-                for(; m_last_grow_edge_it != m_last_grow_edge_end; ++m_last_grow_edge_it){
-                  edge_descriptor out_edge = *m_last_grow_edge_it;
-                  if(m_res_cap_map[out_edge] > 0){ //check if we have capacity left on this edge
-                    vertex_descriptor other_node = target(out_edge, m_g);
-                    if(get_tree(other_node) == tColorTraits::gray()){ //it's a free node
-                      set_tree(other_node, tColorTraits::black()); //aquire other node to our search tree
-                      set_edge_to_parent(other_node, out_edge);   //set us as parent
-                      m_dist_map[other_node] = m_dist_map[current_node] + 1;  //and update the distance-heuristic
-                      m_time_map[other_node] = m_time_map[current_node];
-                      add_active_node(other_node);
-                    } else if(get_tree(other_node) == tColorTraits::black()){
-                      if(is_closer_to_terminal(current_node, other_node)){ //we do this to get shorter paths. check if we are nearer to the source as its parent is
-                        set_edge_to_parent(other_node, out_edge);
-                        m_dist_map[other_node] = m_dist_map[current_node] + 1;
-                        m_time_map[other_node] = m_time_map[current_node];
-                      }
-                    } else{
-                      assert(get_tree(other_node)==tColorTraits::white());
-                      //kewl, found a path from one to the other search tree, return the connecting edge in src->sink dir
-                      return std::make_pair(out_edge, true);
-                    }
-                  }
-                } //for all out-edges
-              } //source-tree-growing
-              else{
-                assert(get_tree(current_node) == tColorTraits::white());
-                out_edge_iterator ei, e_end;
-                if(current_node != m_last_grow_vertex){
-                  m_last_grow_vertex = current_node;
-                  boost::tie(m_last_grow_edge_it, m_last_grow_edge_end) = out_edges(current_node, m_g);
-                }
-                for(; m_last_grow_edge_it != m_last_grow_edge_end; ++m_last_grow_edge_it){
-                  edge_descriptor in_edge = m_rev_edge_map[*m_last_grow_edge_it];
-                  if(m_res_cap_map[in_edge] > 0){ //check if there is capacity left
-                    vertex_descriptor other_node = source(in_edge, m_g);
-                    if(get_tree(other_node) == tColorTraits::gray()){ //it's a free node
-                      set_tree(other_node, tColorTraits::white());      //aquire that node to our search tree
-                      set_edge_to_parent(other_node, in_edge);          //set us as parent
-                      add_active_node(other_node);                      //activate that node
-                      m_dist_map[other_node] = m_dist_map[current_node] + 1; //set its distance
-                      m_time_map[other_node] = m_time_map[current_node];     //and time
-                    } else if(get_tree(other_node) == tColorTraits::white()){
-                      if(is_closer_to_terminal(current_node, other_node)){
-                        //we are closer to the sink than its parent is, so we "adopt" him
-                        set_edge_to_parent(other_node, in_edge);
-                        m_dist_map[other_node] = m_dist_map[current_node] + 1;
-                        m_time_map[other_node] = m_time_map[current_node];
-                      }
-                    } else{
-                      assert(get_tree(other_node)==tColorTraits::black());
-                      //kewl, found a path from one to the other search tree, return the connecting edge in src->sink dir
-                      return std::make_pair(in_edge, true);
-                    }
-                  }
-                } //for all out-edges
-              } //sink-tree growing
-              //all edges of that node are processed, and no more paths were found. so remove if from the front of the active queue
-              finish_node(current_node);
-            } //while active_nodes not empty
-            return std::make_pair(edge_descriptor(), false); //no active nodes anymore and no path found, we're done
-          }
-
-          /**
-          * augments path from s->t and updates residual graph
-          * source(e, m_g) is the end of the path found in the source-tree
-          * target(e, m_g) is the beginning of the path found in the sink-tree
-          * this phase generates orphans on satured edges, if the attached verts are from different search-trees
-          * orphans are ordered in distance to sink/source. first the farest from the source are front_inserted into the orphans list,
-          * and after that the sink-tree-orphans are front_inserted. when going to adoption stage the orphans are popped_front, and so we process the nearest
-          * verts to the terminals first
-          */
-          void augment(edge_descriptor e){
-            assert(get_tree(target(e, m_g)) == tColorTraits::white());
-            assert(get_tree(source(e, m_g)) == tColorTraits::black());
-            assert(m_orphans.empty());
-
-            const tEdgeVal bottleneck = find_bottleneck(e);
-            //now we push the found flow through the path
-            //for each edge we saturate we have to look for the verts that belong to that edge, one of them becomes an orphans
-            //now process the connecting edge
-            m_res_cap_map[e] -= bottleneck;
-            assert(m_res_cap_map[e] >= 0);
-            m_res_cap_map[m_rev_edge_map[e]] += bottleneck;
-
-            //now we follow the path back to the source
-            vertex_descriptor current_node = source(e, m_g);
-            while(current_node != m_source){
-              edge_descriptor pred = get_edge_to_parent(current_node);
-              m_res_cap_map[pred] -= bottleneck;
-              assert(m_res_cap_map[pred] >= 0);
-              m_res_cap_map[m_rev_edge_map[pred]] += bottleneck;
-              if(m_res_cap_map[pred] == 0){
-                set_no_parent(current_node);
-                m_orphans.push_front(current_node);
-              }
-              current_node = source(pred, m_g);
-            }
-            //then go forward in the sink-tree
-            current_node = target(e, m_g);
-            while(current_node != m_sink){
-              edge_descriptor pred = get_edge_to_parent(current_node);
-              m_res_cap_map[pred] -= bottleneck;
-              assert(m_res_cap_map[pred] >= 0);
-              m_res_cap_map[m_rev_edge_map[pred]] += bottleneck;
-              if(m_res_cap_map[pred] == 0){
-                set_no_parent(current_node);
-                m_orphans.push_front(current_node);
-              }
-              current_node = target(pred, m_g);
-            }
-            //and add it to the max-flow
-            m_flow += bottleneck;
-          }
-
-          /**
-           * returns the bottleneck of a s->t path (end_of_path is last vertex in source-tree, begin_of_path is first vertex in sink-tree)
-           */
-          inline tEdgeVal find_bottleneck(edge_descriptor e){
-            BOOST_USING_STD_MIN();
-            tEdgeVal minimum_cap = m_res_cap_map[e];
-            vertex_descriptor current_node = source(e, m_g);
-            //first go back in the source tree
-            while(current_node != m_source){
-              edge_descriptor pred = get_edge_to_parent(current_node);
-              minimum_cap = min BOOST_PREVENT_MACRO_SUBSTITUTION(minimum_cap, m_res_cap_map[pred]);
-              current_node = source(pred, m_g);
-            }
-            //then go forward in the sink-tree
-            current_node = target(e, m_g);
-            while(current_node != m_sink){
-              edge_descriptor pred = get_edge_to_parent(current_node);
-              minimum_cap = min BOOST_PREVENT_MACRO_SUBSTITUTION(minimum_cap, m_res_cap_map[pred]);
-              current_node = target(pred, m_g);
-            }
-            return minimum_cap;
-          }
-
-          /**
-          * rebuild search trees
-          * empty the queue of orphans, and find new parents for them or just drop them from the search trees
-          */
-          void adopt(){
-            while(!m_orphans.empty() || !m_child_orphans.empty()){
-              vertex_descriptor current_node;
-              if(m_child_orphans.empty()){
-                //get the next orphan from the main-queue  and remove it
-                current_node = m_orphans.front();
-                m_orphans.pop_front();
-              } else{
-                current_node = m_child_orphans.front();
-                m_child_orphans.pop();
-              }
-              if(get_tree(current_node) == tColorTraits::black()){
-                //we're in the source-tree
-                tDistanceVal min_distance = (std::numeric_limits<tDistanceVal>::max)();
-                edge_descriptor new_parent_edge;
-                out_edge_iterator ei, e_end;
-                for(boost::tie(ei, e_end) = out_edges(current_node, m_g); ei != e_end; ++ei){
-                  const edge_descriptor in_edge = m_rev_edge_map[*ei];
-                  assert(target(in_edge, m_g) == current_node); //we should be the target of this edge
-                  if(m_res_cap_map[in_edge] > 0){
-                    vertex_descriptor other_node = source(in_edge, m_g);
-                    if(get_tree(other_node) == tColorTraits::black() && has_source_connect(other_node)){
-                      if(m_dist_map[other_node] < min_distance){
-                        min_distance = m_dist_map[other_node];
-                        new_parent_edge = in_edge;
-                      }
-                    }
-                  }
-                }
-                if(min_distance != (std::numeric_limits<tDistanceVal>::max)()){
-                  set_edge_to_parent(current_node, new_parent_edge);
-                  m_dist_map[current_node] = min_distance + 1;
-                  m_time_map[current_node] = m_time;
-                } else{
-                  m_time_map[current_node] = 0;
-                  for(boost::tie(ei, e_end) = out_edges(current_node, m_g); ei != e_end; ++ei){
-                    edge_descriptor in_edge = m_rev_edge_map[*ei];
-                    vertex_descriptor other_node = source(in_edge, m_g);
-                    if(get_tree(other_node) == tColorTraits::black() && has_parent(other_node)){
-                      if(m_res_cap_map[in_edge] > 0){
-                        add_active_node(other_node);
-                      }
-                      if(source(get_edge_to_parent(other_node), m_g) == current_node){
-                        //we are the parent of that node
-                        //it has to find a new parent, too
-                        set_no_parent(other_node);
-                        m_child_orphans.push(other_node);
-                      }
-                    }
-                  }
-                  set_tree(current_node, tColorTraits::gray());
-                } //no parent found
-              } //source-tree-adoption
-              else{
-                //now we should be in the sink-tree, check that...
-                assert(get_tree(current_node) == tColorTraits::white());
-                out_edge_iterator ei, e_end;
-                edge_descriptor new_parent_edge;
-                tDistanceVal min_distance = (std::numeric_limits<tDistanceVal>::max)();
-                for(boost::tie(ei, e_end) = out_edges(current_node, m_g); ei != e_end; ++ei){
-                  const edge_descriptor out_edge = *ei;
-                  if(m_res_cap_map[out_edge] > 0){
-                    const vertex_descriptor other_node = target(out_edge, m_g);
-                    if(get_tree(other_node) == tColorTraits::white() && has_sink_connect(other_node))
-                      if(m_dist_map[other_node] < min_distance){
-                        min_distance = m_dist_map[other_node];
-                        new_parent_edge = out_edge;
-                      }
-                  }
-                }
-                if(min_distance != (std::numeric_limits<tDistanceVal>::max)()){
-                  set_edge_to_parent(current_node, new_parent_edge);
-                  m_dist_map[current_node] = min_distance + 1;
-                  m_time_map[current_node] = m_time;
-                } else{
-                  m_time_map[current_node] = 0;
-                  for(boost::tie(ei, e_end) = out_edges(current_node, m_g); ei != e_end; ++ei){
-                    const edge_descriptor out_edge = *ei;
-                    const vertex_descriptor other_node = target(out_edge, m_g);
-                    if(get_tree(other_node) == tColorTraits::white() && has_parent(other_node)){
-                      if(m_res_cap_map[out_edge] > 0){
-                        add_active_node(other_node);
-                      }
-                      if(target(get_edge_to_parent(other_node), m_g) == current_node){
-                        //we were it's parent, so it has to find a new one, too
-                        set_no_parent(other_node);
-                        m_child_orphans.push(other_node);
-                      }
-                    }
-                  }
-                  set_tree(current_node, tColorTraits::gray());
-                } //no parent found
-              } //sink-tree adoption
-            } //while !orphans.empty()
-          } //adopt
-
-          /**
-          * return next active vertex if there is one, otherwise a null_vertex
-          */
-          inline vertex_descriptor get_next_active_node(){
-            while(true){
-              if(m_active_nodes.empty())
-                return graph_traits<Graph>::null_vertex();
-              vertex_descriptor v = m_active_nodes.front();
-
-              if(!has_parent(v) && v != m_source && v != m_sink){ //if it has no parent, this node can't be active(if its not source or sink)
-                m_active_nodes.pop();
-                m_in_active_list_map[v] = false;
-              } else{
-                assert(get_tree(v) == tColorTraits::black() || get_tree(v) == tColorTraits::white());
-                return v;
-              }
-            }
-          }
-
-          /**
-          * adds v as an active vertex, but only if its not in the list already
-          */
-          inline void add_active_node(vertex_descriptor v){
-            assert(get_tree(v) != tColorTraits::gray());
-            if(m_in_active_list_map[v]){
-              return;
-            } else{
-              m_in_active_list_map[v] = true;
-              m_active_nodes.push(v);
-            }
-          }
-
-          /**
-           * finish_node removes a node from the front of the active queue (its called in grow phase, if no more paths can be found using this node)
-           */
-          inline void finish_node(vertex_descriptor v){
-            assert(m_active_nodes.front() == v);
-            m_active_nodes.pop();
-            m_in_active_list_map[v] = false;
-            m_last_grow_vertex = graph_traits<Graph>::null_vertex();
-          }
-
-          /**
-          * removes a vertex from the queue of active nodes (actually this does nothing,
-          * but checks if this node has no parent edge, as this is the criteria for beeing no more active)
-          */
-          inline void remove_active_node(vertex_descriptor v){
-            assert(!has_parent(v));
-          }
-
-          /**
-          * returns the search tree of v; tColorValue::black() for source tree, white() for sink tree, gray() for no tree
-          */
-          inline tColorValue get_tree(vertex_descriptor v) const {
-            return m_tree_map[v];
-          }
-
-          /**
-          * sets search tree of v; tColorValue::black() for source tree, white() for sink tree, gray() for no tree
-          */
-          inline void set_tree(vertex_descriptor v, tColorValue t){
-            m_tree_map[v] = t;
-          }
-
-          /**
-           * returns edge to parent vertex of v;
-           */
-          inline edge_descriptor get_edge_to_parent(vertex_descriptor v) const{
-            return m_pre_map[v];
-          }
-
-          /**
-           * returns true if the edge stored in m_pre_map[v] is a valid entry
-           */
-          inline bool has_parent(vertex_descriptor v) const{
-            return m_has_parent_map[v];
-          }
-
-          /**
-           * sets edge to parent vertex of v;
-          */
-          inline void set_edge_to_parent(vertex_descriptor v, edge_descriptor f_edge_to_parent){
-            assert(m_res_cap_map[f_edge_to_parent] > 0);
-            m_pre_map[v] = f_edge_to_parent;
-            m_has_parent_map[v] = true;
-          }
-
-          /**
-           * removes the edge to parent of v (this is done by invalidating the entry an additional map)
-           */
-          inline void set_no_parent(vertex_descriptor v){
-            m_has_parent_map[v] = false;
-          }
-
-          /**
-           * checks if vertex v has a connect to the sink-vertex (@var m_sink)
-           * @param v the vertex which is checked
-           * @return true if a path to the sink was found, false if not
-           */
-          inline bool has_sink_connect(vertex_descriptor v){
-            tDistanceVal current_distance = 0;
-            vertex_descriptor current_vertex = v;
-            while(true){
-              if(m_time_map[current_vertex] == m_time){
-                //we found a node which was already checked this round. use it for distance calculations
-                current_distance += m_dist_map[current_vertex];
-                break;
-              }
-              if(current_vertex == m_sink){
-                m_time_map[m_sink] = m_time;
-                break;
-              }
-              if(has_parent(current_vertex)){
-                //it has a parent, so get it
-                current_vertex = target(get_edge_to_parent(current_vertex), m_g);
-                ++current_distance;
-              } else{
-                //no path found
-                return false;
-              }
-            }
-            current_vertex=v;
-            while(m_time_map[current_vertex] != m_time){
-              m_dist_map[current_vertex] = current_distance--;
-              m_time_map[current_vertex] = m_time;
-              current_vertex = target(get_edge_to_parent(current_vertex), m_g);
-            }
-            return true;
-          }
-
-          /**
-           * checks if vertex v has a connect to the source-vertex (@var m_source)
-           * @param v the vertex which is checked
-           * @return true if a path to the source was found, false if not
-           */
-          inline bool has_source_connect(vertex_descriptor v){
-            tDistanceVal current_distance = 0;
-            vertex_descriptor current_vertex = v;
-            while(true){
-              if(m_time_map[current_vertex] == m_time){
-                //we found a node which was already checked this round. use it for distance calculations
-                current_distance += m_dist_map[current_vertex];
-                break;
-              }
-              if(current_vertex == m_source){
-                m_time_map[m_source] = m_time;
-                break;
-              }
-              if(has_parent(current_vertex)){
-                //it has a parent, so get it
-                current_vertex = source(get_edge_to_parent(current_vertex), m_g);
-                ++current_distance;
-              } else{
-                //no path found
-                return false;
-              }
-            }
-            current_vertex=v;
-            while(m_time_map[current_vertex] != m_time){
-                m_dist_map[current_vertex] = current_distance-- ;
-                m_time_map[current_vertex] = m_time;
-                current_vertex = source(get_edge_to_parent(current_vertex), m_g);
-            }
-            return true;
-          }
-
-          /**
-          * returns true, if p is closer to a terminal than q
-          */
-          inline bool is_closer_to_terminal(vertex_descriptor p, vertex_descriptor q){
-            //checks the timestamps first, to build no cycles, and after that the real distance
-            return (m_time_map[q] <= m_time_map[p] && m_dist_map[q] > m_dist_map[p]+1);
-          }
-
-          ////////
-          // member vars
-          ////////
-          Graph& m_g;
-          IndexMap m_index_map;
-          EdgeCapacityMap m_cap_map;
-          ResidualCapacityEdgeMap m_res_cap_map;
-          ReverseEdgeMap m_rev_edge_map;
-          PredecessorMap m_pre_map; //stores paths found in the growth stage
-          ColorMap m_tree_map; //maps each vertex into one of the two search tree or none (gray())
-          DistanceMap m_dist_map; //stores distance to source/sink nodes
-          vertex_descriptor m_source;
-          vertex_descriptor m_sink;
-
-          tQueue m_active_nodes;
-          std::vector<bool> m_in_active_list_vec;
-          iterator_property_map<std::vector<bool>::iterator, IndexMap> m_in_active_list_map;
-
-          std::list<vertex_descriptor> m_orphans;
-          tQueue m_child_orphans; // we use a second queuqe for child orphans, as they are FIFO processed
-
-          std::vector<bool> m_has_parent_vec;
-          iterator_property_map<std::vector<bool>::iterator, IndexMap> m_has_parent_map;
-
-          std::vector<long> m_time_vec; //timestamp of each node, used for sink/source-path calculations
-          iterator_property_map<std::vector<long>::iterator, IndexMap> m_time_map;
-          tEdgeVal m_flow;
-          long m_time;
-          vertex_descriptor m_last_grow_vertex;
-          out_edge_iterator m_last_grow_edge_it;
-          out_edge_iterator m_last_grow_edge_end;
-    };
-  } //namespace detail
-
-  /**
-   * non-named-parameter version, given everything
-   * this is the catch all version
-   */
-  template <class Graph, class CapacityEdgeMap, class ResidualCapacityEdgeMap, class ReverseEdgeMap,
-    class PredecessorMap, class ColorMap, class DistanceMap, class IndexMap>
-  typename property_traits<CapacityEdgeMap>::value_type
-  kolmogorov_max_flow
-      (Graph& g,
-       CapacityEdgeMap cap,
-       ResidualCapacityEdgeMap res_cap,
-       ReverseEdgeMap rev_map,
-       PredecessorMap pre_map,
-       ColorMap color,
-       DistanceMap dist,
-       IndexMap idx,
-       typename graph_traits<Graph>::vertex_descriptor src,
-       typename graph_traits<Graph>::vertex_descriptor sink
-       )
-  {
-    typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor;
-    typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor;
-    //as this method is the last one before we instantiate the solver, we do the concept checks here
-    function_requires<VertexListGraphConcept<Graph> >(); //to have vertices(), num_vertices(),
-    function_requires<EdgeListGraphConcept<Graph> >(); //to have edges()
-    function_requires<IncidenceGraphConcept<Graph> >(); //to have source(), target() and out_edges()
-    function_requires<LvaluePropertyMapConcept<CapacityEdgeMap, edge_descriptor> >(); //read flow-values from edges
-    function_requires<Mutable_LvaluePropertyMapConcept<ResidualCapacityEdgeMap, edge_descriptor> >(); //write flow-values to residuals
-    function_requires<LvaluePropertyMapConcept<ReverseEdgeMap, edge_descriptor> >(); //read out reverse edges
-    function_requires<Mutable_LvaluePropertyMapConcept<PredecessorMap, vertex_descriptor> >(); //store predecessor there
-    function_requires<Mutable_LvaluePropertyMapConcept<ColorMap, vertex_descriptor> >(); //write corresponding tree
-    function_requires<Mutable_LvaluePropertyMapConcept<DistanceMap, vertex_descriptor> >(); //write distance to source/sink
-    function_requires<ReadablePropertyMapConcept<IndexMap, vertex_descriptor> >(); //get index 0...|V|-1
-    assert(num_vertices(g) >= 2 && src != sink);
-    detail::kolmogorov<Graph, CapacityEdgeMap, ResidualCapacityEdgeMap, ReverseEdgeMap, PredecessorMap, ColorMap, DistanceMap, IndexMap>
-        algo(g, cap, res_cap, rev_map, pre_map, color, dist, idx, src, sink);
-        return algo.max_flow();
-  }
-
-  /**
-   * non-named-parameter version, given: capacity, residucal_capacity, reverse_edges, and an index map.
-   */
-  template <class Graph, class CapacityEdgeMap, class ResidualCapacityEdgeMap, class ReverseEdgeMap, class IndexMap>
-  typename property_traits<CapacityEdgeMap>::value_type
-   kolmogorov_max_flow
-       (Graph& g,
-       CapacityEdgeMap cap,
-       ResidualCapacityEdgeMap res_cap,
-       ReverseEdgeMap rev,
-       IndexMap idx,
-       typename graph_traits<Graph>::vertex_descriptor src,
-       typename graph_traits<Graph>::vertex_descriptor sink)
-   {
-     typename graph_traits<Graph>::vertices_size_type n_verts = num_vertices(g);
-     std::vector<typename graph_traits<Graph>::edge_descriptor> predecessor_vec(n_verts);
-     std::vector<default_color_type> color_vec(n_verts);
-     std::vector<typename graph_traits<Graph>::vertices_size_type> distance_vec(n_verts);
-     return kolmogorov_max_flow
-         (g, cap, res_cap, rev,
-          make_iterator_property_map(predecessor_vec.begin(), idx),
-          make_iterator_property_map(color_vec.begin(), idx),
-          make_iterator_property_map(distance_vec.begin(), idx),
-          idx, src, sink);
-   }
-
-  /**
-   * non-named-parameter version, some given: capacity, residual_capacity, reverse_edges, color_map and an index map.
-   * Use this if you are interested in the minimum cut, as the color map provides that info
-   */
-   template <class Graph, class CapacityEdgeMap, class ResidualCapacityEdgeMap, class ReverseEdgeMap, class ColorMap, class IndexMap>
-   typename property_traits<CapacityEdgeMap>::value_type
-   kolmogorov_max_flow
-       (Graph& g,
-        CapacityEdgeMap cap,
-        ResidualCapacityEdgeMap res_cap,
-        ReverseEdgeMap rev,
-        ColorMap color,
-        IndexMap idx,
-        typename graph_traits<Graph>::vertex_descriptor src,
-        typename graph_traits<Graph>::vertex_descriptor sink)
-   {
-     typename graph_traits<Graph>::vertices_size_type n_verts = num_vertices(g);
-     std::vector<typename graph_traits<Graph>::edge_descriptor> predecessor_vec(n_verts);
-     std::vector<typename graph_traits<Graph>::vertices_size_type> distance_vec(n_verts);
-
-     return kolmogorov_max_flow
-         (g, cap, res_cap, rev,
-          make_iterator_property_map(predecessor_vec.begin(), idx),
-          color,
-          make_iterator_property_map(distance_vec.begin(), idx),
-          idx, src, sink);
-   }
-
-  /**
-   * named-parameter version, some given
-   */
-   template <class Graph, class P, class T, class R>
-   typename property_traits<typename property_map<Graph, edge_capacity_t>::const_type>::value_type
-   kolmogorov_max_flow
-       (Graph& g,
-        typename graph_traits<Graph>::vertex_descriptor src,
-        typename graph_traits<Graph>::vertex_descriptor sink,
-        const bgl_named_params<P, T, R>& params)
-   {
-     return kolmogorov_max_flow(g,
-                                choose_const_pmap(get_param(params, edge_capacity), g, edge_capacity),
-                                choose_pmap(get_param(params, edge_residual_capacity), g, edge_residual_capacity),
-                                choose_const_pmap(get_param(params, edge_reverse), g, edge_reverse),
-                                choose_pmap(get_param(params, vertex_predecessor), g, vertex_predecessor),
-                                choose_pmap(get_param(params, vertex_color), g, vertex_color),
-                                choose_pmap(get_param(params, vertex_distance), g, vertex_distance),
-                                choose_const_pmap(get_param(params, vertex_index), g, vertex_index),
-                                src, sink);
-   }
-
-  /**
-   * named-parameter version, none given
-   */
-   template <class Graph>
-   typename property_traits<typename property_map<Graph, edge_capacity_t>::const_type>::value_type
-   kolmogorov_max_flow
-       (Graph& g,
-        typename graph_traits<Graph>::vertex_descriptor src,
-        typename graph_traits<Graph>::vertex_descriptor sink)
-   {
-     bgl_named_params<int, buffer_param_t> params(0); // bogus empty param
-     return kolmogorov_max_flow(g, src, sink, params);
-   }
-} // namespace boost
-
-#endif // BOOST_KOLMOGOROV_MAX_FLOW_HPP
-
diff --git a/include/boost/graph/kruskal_min_spanning_tree.hpp b/include/boost/graph/kruskal_min_spanning_tree.hpp
index a847e3f15..b7e815770 100644
--- a/include/boost/graph/kruskal_min_spanning_tree.hpp
+++ b/include/boost/graph/kruskal_min_spanning_tree.hpp
@@ -28,6 +28,7 @@
 #include <boost/graph/named_function_params.hpp>
 #include <boost/pending/disjoint_sets.hpp>
 #include <boost/pending/indirect_cmp.hpp>
+#include <boost/concept/assert.hpp>
 
 
 namespace boost {
@@ -51,18 +52,18 @@ namespace boost {
       if (num_vertices(G) == 0) return; // Nothing to do in this case
       typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
       typedef typename graph_traits<Graph>::edge_descriptor Edge;
-      function_requires<VertexListGraphConcept<Graph> >();
-      function_requires<EdgeListGraphConcept<Graph> >();
-      function_requires<OutputIteratorConcept<OutputIterator, Edge> >();
-      function_requires<ReadWritePropertyMapConcept<Rank, Vertex> >();
-      function_requires<ReadWritePropertyMapConcept<Parent, Vertex> >();
-      function_requires<ReadablePropertyMapConcept<Weight, Edge> >();
+      BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+      BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+      BOOST_CONCEPT_ASSERT(( OutputIteratorConcept<OutputIterator, Edge> ));
+      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<Rank, Vertex> ));
+      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<Parent, Vertex> ));
+      BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<Weight, Edge> ));
       typedef typename property_traits<Weight>::value_type W_value;
       typedef typename property_traits<Rank>::value_type R_value;
       typedef typename property_traits<Parent>::value_type P_value;
-      function_requires<ComparableConcept<W_value> >();
-      function_requires<ConvertibleConcept<P_value, Vertex> >();
-      function_requires<IntegerConcept<R_value> >();
+      BOOST_CONCEPT_ASSERT(( ComparableConcept<W_value> ));
+      BOOST_CONCEPT_ASSERT(( ConvertibleConcept<P_value, Vertex> ));
+      BOOST_CONCEPT_ASSERT(( IntegerConcept<R_value> ));
 
       disjoint_sets<Rank, Parent>  dset(rank, parent);
 
@@ -101,7 +102,6 @@ namespace boost {
   {
     typedef typename graph_traits<Graph>::vertices_size_type size_type;
     typedef typename graph_traits<Graph>::vertex_descriptor vertex_t;
-    typedef typename property_map<Graph, vertex_index_t>::type index_map_t;
     if (num_vertices(g) == 0) return; // Nothing to do in this case
     typename graph_traits<Graph>::vertices_size_type
       n = num_vertices(g);
diff --git a/include/boost/graph/labeled_graph.hpp b/include/boost/graph/labeled_graph.hpp
index e1a2f7c2d..5b688b02e 100644
--- a/include/boost/graph/labeled_graph.hpp
+++ b/include/boost/graph/labeled_graph.hpp
@@ -21,7 +21,7 @@
 #include <boost/graph/graph_traits.hpp>
 
 // This file implements a utility for creating mappings from arbitrary
-// identifers to the vertices of a graph.
+// identifiers to the vertices of a graph.
 
 namespace boost {
 
@@ -104,7 +104,7 @@ namespace graph_detail {
     // Tag dispatch on random access containers (i.e., vectors). This function
     // basically requires a) that Container is vector<Label> and that Label
     // is an unsigned integral value. Note that this will resize the vector
-    // to accomodate indices.
+    // to accommodate indices.
     template <typename Container, typename Graph, typename Label, typename Prop>
     std::pair<typename graph_traits<Graph>::vertex_descriptor, bool>
     insert_labeled_vertex(Container& c, Graph& g, Label const& l, Prop const& p,
@@ -112,7 +112,7 @@ namespace graph_detail {
     {
         typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
 
-        // If the label is out of bounds, resize the vector to accomodate.
+        // If the label is out of bounds, resize the vector to accommodate.
         // Resize by 2x the index so we don't cause quadratic insertions over
         // time.
         if(l >= c.size()) {
@@ -140,7 +140,7 @@ namespace graph_detail {
     // Tag dispatch on unique associative containers (i.e. maps).
     template <typename Container, typename Graph, typename Label, typename Prop>
     std::pair<typename graph_traits<Graph>::vertex_descriptor, bool>
-    insert_labeled_vertex(Container& c, Graph& g, Label const& l, Prop const&,
+    insert_labeled_vertex(Container& c, Graph& g, Label const& l, Prop const& p,
                           unique_associative_container_tag)
     {
         // Here, we actually have to try the insertion first, and only add
@@ -150,6 +150,7 @@ namespace graph_detail {
         std::pair<Iterator, bool> x = c.insert(std::make_pair(l, Vertex()));
         if(x.second) {
             x.first->second = add_vertex(g);
+            put(boost::vertex_all, g, x.first->second, p);
         }
         return std::make_pair(x.first->second, x.second);
     }
@@ -196,7 +197,7 @@ namespace graph_detail {
     {
         // If the element is already occupied, then we probably don't want to
         // overwrite it.
-        if(c[l] == Graph::null_vertex()) return false;
+        if(c[l] == graph_traits<Graph>::null_vertex()) return false;
         c[l] = v;
         return true;
     }
@@ -246,7 +247,7 @@ struct labeled_graph_types {
  * vertex labels and vertex descriptors.
  *
  * @todo This class is somewhat redundant for adjacency_list<*, vecS>  if
- * the intended label is an unsigned int (and perhpahs some other cases), but
+ * the intended label is an unsigned int (and perhaps some other cases), but
  * it does avoid some weird ambiguities (i.e. adding a vertex with a label that
  * does not match its target index).
  *
@@ -310,7 +311,7 @@ class labeled_graph
         _map.insert(_map.end(), rng.first, rng.second);
     }
 
-    // Construct a grpah over n vertices, each of which receives a label from
+    // Construct a graph over n vertices, each of which receives a label from
     // the range [l, l + n). Note that the graph is not directly constructed
     // over the n vertices, but added sequentially. This constructor is
     // necessarily slower than the underlying counterpart.
@@ -411,7 +412,7 @@ class labeled_graph
 
     /** Return a null descriptor */
     static vertex_descriptor null_vertex()
-    { return graph_type::null_vertex(); }
+    { return graph_traits<graph_type>::null_vertex(); }
 
 private:
     graph_type _graph;
@@ -525,7 +526,7 @@ class labeled_graph<Graph*, Label, Selector>
 #endif
 
     static vertex_descriptor null_vertex()
-    { return graph_type::null_vertex(); }
+    { return graph_traits<graph_type>::null_vertex(); }
 
 private:
     graph_type* _graph;
@@ -544,8 +545,9 @@ inline bool label_vertex(typename LABELED_GRAPH::vertex_descriptor v,
 { return g.label_vertex(v, l); }
 
 template <LABELED_GRAPH_PARAMS>
-inline bool vertex_by_label(typename LABELED_GRAPH::label_type const l,
-                            LABELED_GRAPH& g)
+inline typename LABELED_GRAPH::vertex_descriptor
+vertex_by_label(typename LABELED_GRAPH::label_type const l,
+                LABELED_GRAPH& g)
 { return g.vertex(l); }
 //@}
 
diff --git a/include/boost/graph/leda_graph.hpp b/include/boost/graph/leda_graph.hpp
index 687a10dde..a6ab5152b 100644
--- a/include/boost/graph/leda_graph.hpp
+++ b/include/boost/graph/leda_graph.hpp
@@ -17,9 +17,9 @@
 #include <boost/graph/graph_traits.hpp>
 #include <boost/graph/properties.hpp>
 
-#include <LEDA/graph.h>
-#include <LEDA/node_array.h>
-#include <LEDA/node_map.h>
+#include <LEDA/graph/graph.h>
+#include <LEDA/graph/node_array.h>
+#include <LEDA/graph/node_map.h>
 
 // The functions and classes in this file allows the user to
 // treat a LEDA GRAPH object as a boost graph "as is". No
@@ -30,7 +30,6 @@
 
 // Warning: this implementation is in alpha and has not been tested
 
-#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 namespace boost {
 
   struct leda_graph_traversal_category : 
@@ -336,7 +335,6 @@ namespace boost {
   };
 
 } // namespace boost
-#endif
 
 namespace boost {
 
@@ -884,7 +882,7 @@ namespace boost {
   inline
   typename boost::property_traits<
     typename boost::property_map<leda::GRAPH<vtype, etype>,PropertyTag>::const_type
-::value_type
+   >::value_type
   get(PropertyTag p, const leda::GRAPH<vtype, etype>& g, const Key& key) {
     return get(get(p, g), key);
   }
diff --git a/include/boost/graph/loop_erased_random_walk.hpp b/include/boost/graph/loop_erased_random_walk.hpp
index 6e6752a79..712c45d7c 100644
--- a/include/boost/graph/loop_erased_random_walk.hpp
+++ b/include/boost/graph/loop_erased_random_walk.hpp
@@ -15,7 +15,7 @@
 #include <boost/graph/random.hpp>
 #include <boost/next_prior.hpp>
 #include <vector>
-#include <cassert>
+#include <boost/assert.hpp>
 
 namespace boost {
 
@@ -51,7 +51,7 @@ namespace boost {
     typedef typename boost::property_traits<ColorMap>::value_type color_t;
     typedef boost::color_traits<color_t> color_gen;
     
-    assert (get(color, s) == color_gen::white());
+    BOOST_ASSERT (get(color, s) == color_gen::white());
     path.clear();
     path.push_back(s);
     put(color, s, color_gen::gray());
@@ -67,7 +67,7 @@ namespace boost {
         // Found a loop; delete from path from the first occurrence of t to the
         // end, coloring vertices white.
         typename std::vector<vertex_descriptor>::iterator it = std::find(path.begin(), path.end(), t);
-        assert (it != path.end());
+        BOOST_ASSERT (it != path.end());
         ++it;
         for (typename std::vector<vertex_descriptor>::iterator j = it; j != path.end(); ++j) {
           put(color, *j, color_gen::white());
diff --git a/include/boost/graph/make_connected.hpp b/include/boost/graph/make_connected.hpp
index de6c861dd..a2f8b1ee4 100644
--- a/include/boost/graph/make_connected.hpp
+++ b/include/boost/graph/make_connected.hpp
@@ -9,7 +9,7 @@
 #define __MAKE_CONNECTED_HPP__
 
 #include <boost/config.hpp>
-#include <boost/utility.hpp> //for next
+#include <boost/next_prior.hpp>
 #include <boost/tuple/tuple.hpp>   //for tie
 #include <boost/graph/connected_components.hpp>
 #include <boost/property_map/property_map.hpp>
diff --git a/include/boost/graph/make_maximal_planar.hpp b/include/boost/graph/make_maximal_planar.hpp
index 70a1e08ab..8248573b4 100644
--- a/include/boost/graph/make_maximal_planar.hpp
+++ b/include/boost/graph/make_maximal_planar.hpp
@@ -62,7 +62,7 @@ namespace boost
       degree(degree_vector.begin(), vm)
     {
       vertex_iterator_t vi, vi_end;
-      for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
+      for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
         put(degree, *vi, out_degree(*vi, g));
     }
 
@@ -117,7 +117,7 @@ namespace boost
 
       // Mark all of the min degree vertex's neighbors
       adjacency_iterator_t ai, ai_end;
-      for(tie(ai,ai_end) = adjacent_vertices(vertices_on_face.front(),g); 
+      for(boost::tie(ai,ai_end) = adjacent_vertices(vertices_on_face.front(),g); 
           ai != ai_end; ++ai
           )
         {
diff --git a/include/boost/graph/matrix_as_graph.hpp b/include/boost/graph/matrix_as_graph.hpp
index b39d126a2..fb727940d 100644
--- a/include/boost/graph/matrix_as_graph.hpp
+++ b/include/boost/graph/matrix_as_graph.hpp
@@ -14,7 +14,7 @@
 #include <utility>
 #include <boost/config.hpp>
 #include <boost/operators.hpp>
-#include <boost/int_iterator.hpp>
+#include <boost/pending/detail/int_iterator.hpp>
 #include <boost/graph/graph_traits.hpp>
 
 namespace boost {
diff --git a/include/boost/graph/max_cardinality_matching.hpp b/include/boost/graph/max_cardinality_matching.hpp
index 043f70147..1549345a2 100644
--- a/include/boost/graph/max_cardinality_matching.hpp
+++ b/include/boost/graph/max_cardinality_matching.hpp
@@ -16,7 +16,6 @@
 #include <algorithm>                     // for std::sort and std::stable_sort
 #include <utility>                       // for std::pair
 #include <boost/property_map/property_map.hpp>
-#include <boost/utility.hpp>             // for boost::tie
 #include <boost/graph/graph_traits.hpp>  
 #include <boost/graph/visitors.hpp>
 #include <boost/graph/depth_first_search.hpp>
@@ -220,7 +219,12 @@ namespace boost
           vertex_state[u] = graph::detail::V_EVEN;
           out_edge_iterator_t ei, ei_end;
           for(boost::tie(ei,ei_end) = out_edges(u,g); ei != ei_end; ++ei)
-            even_edges.push_back( *ei );
+          {
+            if (target(*ei,g) != u)
+            {
+              even_edges.push_back( *ei );
+            }
+          }
         }
         else
           vertex_state[u] = graph::detail::V_UNREACHED;      
@@ -259,10 +263,16 @@ namespace boost
         if (vertex_state[w_prime] == graph::detail::V_UNREACHED)
         {
           vertex_state[w_prime] = graph::detail::V_ODD;
-          vertex_state[mate[w_prime]] = graph::detail::V_EVEN;
+          vertex_descriptor_t w_prime_mate = mate[w_prime];
+          vertex_state[w_prime_mate] = graph::detail::V_EVEN;
           out_edge_iterator_t ei, ei_end;
-          for( boost::tie(ei,ei_end) = out_edges(mate[w_prime], g); ei != ei_end; ++ei)
-            even_edges.push_back(*ei);
+          for( boost::tie(ei,ei_end) = out_edges(w_prime_mate, g); ei != ei_end; ++ei)
+          {
+            if (target(*ei,g) != w_prime_mate)
+            {
+              even_edges.push_back(*ei);
+            }
+          }
           pred[w_prime] = v;
         }
         
@@ -404,7 +414,12 @@ namespace boost
           bridge[v] = the_bridge;
           out_edge_iterator_t oei, oei_end;
           for(boost::tie(oei, oei_end) = out_edges(v,g); oei != oei_end; ++oei)
-            even_edges.push_back(*oei);
+          {
+            if (target(*oei,g) != v)
+            {
+              even_edges.push_back(*oei);
+            }
+          }
         }
       }
     }
@@ -530,7 +545,7 @@ namespace boost
         vertex_descriptor_t u = source(e,g);
         vertex_descriptor_t v = target(e,g);
       
-        if (get(mate,u) == get(mate,v))  
+        if (u != v && get(mate,u) == get(mate,v))  
         //only way equality can hold is if
         //   mate[u] == mate[v] == null_vertex
         {
@@ -607,6 +622,7 @@ namespace boost
         edge_descriptor_t e = *ei;
         vertex_descriptor_t u = source(e,g);
         vertex_descriptor_t v = target(e,g);
+        if (u == v) continue;
         edge_list.push_back(std::make_pair(u,v));
         edge_list.push_back(std::make_pair(v,u));
       }
diff --git a/include/boost/graph/maximum_adjacency_search.hpp b/include/boost/graph/maximum_adjacency_search.hpp
new file mode 100644
index 000000000..e27a7a048
--- /dev/null
+++ b/include/boost/graph/maximum_adjacency_search.hpp
@@ -0,0 +1,319 @@
+//
+//=======================================================================
+// Copyright 2012 Fernando Vilas
+//           2010 Daniel Trebbien
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//=======================================================================
+//
+
+// The maximum adjacency search algorithm was originally part of the
+// Stoer-Wagner min cut implementation by Daniel Trebbien. It has been
+// broken out into its own file to be a public search algorithm, with
+// visitor concepts.
+#ifndef BOOST_GRAPH_MAXIMUM_ADJACENCY_SEARCH_H
+#define BOOST_GRAPH_MAXIMUM_ADJACENCY_SEARCH_H
+
+/**
+ * This is an implementation of the maximum adjacency search on an
+ * undirected graph. It allows a visitor object to perform some
+ * operation on each vertex as that vertex is visited.
+ *
+ * The algorithm runs as follows:
+ *
+ * Initialize all nodes to be unvisited (reach count = 0)
+ *   and call vis.initialize_vertex
+ * For i = number of nodes in graph downto 1
+ *   Select the unvisited node with the highest reach count
+ *     The user provides the starting node to break the first tie,
+ *     but future ties are broken arbitrarily
+ *   Visit the node by calling vis.start_vertex
+ *   Increment the reach count for all unvisited neighbors
+ *     and call vis.examine_edge for each of these edges
+ *   Mark the node as visited and call vis.finish_vertex
+ *
+ */
+
+#include <boost/concept_check.hpp>
+#include <boost/concept/assert.hpp>
+#include <boost/graph/buffer_concepts.hpp>
+#include <boost/graph/exception.hpp>
+#include <boost/graph/graph_concepts.hpp>
+#include <boost/graph/iteration_macros.hpp>
+#include <boost/graph/named_function_params.hpp>
+#include <boost/graph/visitors.hpp>
+#include <boost/tuple/tuple.hpp>
+
+#include <set>
+
+namespace boost {
+  template <class Visitor, class Graph>
+  struct MASVisitorConcept {
+    void constraints() {
+      boost::function_requires< boost::CopyConstructibleConcept<Visitor> >();
+      vis.initialize_vertex(u, g);
+      vis.start_vertex(u, g);
+      vis.examine_edge(e, g);
+      vis.finish_vertex(u, g);
+    }
+    Visitor vis;
+    Graph g;
+    typename boost::graph_traits<Graph>::vertex_descriptor u;
+    typename boost::graph_traits<Graph>::edge_descriptor e;
+  };
+
+  template <class Visitors = null_visitor>
+  class mas_visitor {
+  public:
+    mas_visitor() { }
+    mas_visitor(Visitors vis) : m_vis(vis) { }
+
+    template <class Vertex, class Graph>
+    void
+    initialize_vertex(Vertex u, Graph& g)
+    {
+      invoke_visitors(m_vis, u, g, ::boost::on_initialize_vertex());
+    }
+
+    template <class Vertex, class Graph>
+    void
+    start_vertex(Vertex u, Graph& g)
+    {
+      invoke_visitors(m_vis, u, g, ::boost::on_start_vertex());
+    }
+
+    template <class Edge, class Graph>
+    void
+    examine_edge(Edge e, Graph& g)
+    {
+      invoke_visitors(m_vis, e, g, ::boost::on_examine_edge());
+    }
+
+    template <class Vertex, class Graph>
+    void
+    finish_vertex(Vertex u, Graph& g)
+    {
+      invoke_visitors(m_vis, u, g, ::boost::on_finish_vertex());
+    }
+
+    BOOST_GRAPH_EVENT_STUB(on_initialize_vertex,mas)
+    BOOST_GRAPH_EVENT_STUB(on_start_vertex,mas)
+    BOOST_GRAPH_EVENT_STUB(on_examine_edge,mas)
+    BOOST_GRAPH_EVENT_STUB(on_finish_vertex,mas)
+
+  protected:
+    Visitors m_vis;
+  };
+  template <class Visitors>
+  mas_visitor<Visitors>
+  make_mas_visitor(Visitors vis) {
+    return mas_visitor<Visitors>(vis);
+  }
+  typedef mas_visitor<> default_mas_visitor;
+
+  namespace detail {
+    template <class Graph, class WeightMap, class MASVisitor, class VertexAssignmentMap, class KeyedUpdatablePriorityQueue>
+      void
+      maximum_adjacency_search(const Graph& g, WeightMap weights, MASVisitor vis, const typename boost::graph_traits<Graph>::vertex_descriptor start, VertexAssignmentMap assignments, KeyedUpdatablePriorityQueue pq) {
+      typedef typename boost::graph_traits<Graph>::vertex_descriptor vertex_descriptor;
+      typedef typename boost::property_traits<WeightMap>::value_type weight_type;
+
+     std::set<vertex_descriptor> assignedVertices;
+
+     // initialize `assignments` (all vertices are initially
+     // assigned to themselves)
+     BGL_FORALL_VERTICES_T(v, g, Graph) {
+       put(assignments, v, v);
+     }
+
+      typename KeyedUpdatablePriorityQueue::key_map keys = pq.keys();
+
+      // set number of visited neighbors for all vertices to 0
+      BGL_FORALL_VERTICES_T(v, g, Graph) {
+        if (v == get(assignments, v)) { // foreach u \in V do
+          put(keys, v, weight_type(0));          vis.initialize_vertex(v, g);
+
+          pq.push(v);
+        }
+      }
+      BOOST_ASSERT(pq.size() >= 2);
+
+      // Give the starting vertex high priority
+      put(keys, start, get(keys, start) + num_vertices(g) + 1);
+      pq.update(start);
+
+      // start traversing the graph
+      //vertex_descriptor s, t;
+      weight_type w;
+      while (!pq.empty()) { // while PQ \neq {} do
+        const vertex_descriptor u = pq.top(); // u = extractmax(PQ)
+        w = get(keys, u);                        vis.start_vertex(u, g);
+        pq.pop();                  //            vis.start_vertex(u, g);
+
+        BGL_FORALL_OUTEDGES_T(u, e, g, Graph) { // foreach (u, v) \in E do
+                                                 vis.examine_edge(e, g);
+
+          const vertex_descriptor v = get(assignments, target(e, g));
+
+          if (pq.contains(v)) { // if v \in PQ then
+            put(keys, v, get(keys, v) + get(weights, e)); // increasekey(PQ, v, wA(v) + w(u, v))
+            pq.update(v);
+          }
+        }
+
+        typename std::set<vertex_descriptor>::const_iterator assignedVertexIt, assignedVertexEnd = assignedVertices.end();
+        for (assignedVertexIt = assignedVertices.begin(); assignedVertexIt != assignedVertexEnd; ++assignedVertexIt) {
+          const vertex_descriptor uPrime = *assignedVertexIt;
+
+          if (get(assignments, uPrime) == u) {
+            BGL_FORALL_OUTEDGES_T(uPrime, e, g, Graph) { // foreach (u, v) \in E do
+                                                 vis.examine_edge(e, g);
+
+              const vertex_descriptor v = get(assignments, target(e, g));
+
+              if (pq.contains(v)) { // if v \in PQ then
+                put(keys, v, get(keys, v) + get(weights, e)); // increasekey(PQ, v, wA(v) + w(u, v))
+                pq.update(v);
+              }
+            }
+          }
+        }
+                                                 vis.finish_vertex(u, g);
+      }
+    }
+  } // end namespace detail
+
+  template <class Graph, class WeightMap, class MASVisitor, class VertexAssignmentMap, class KeyedUpdatablePriorityQueue>
+    void
+maximum_adjacency_search(const Graph& g, WeightMap weights, MASVisitor vis, const typename boost::graph_traits<Graph>::vertex_descriptor start, VertexAssignmentMap assignments, KeyedUpdatablePriorityQueue pq) {
+    BOOST_CONCEPT_ASSERT((boost::IncidenceGraphConcept<Graph>));
+    BOOST_CONCEPT_ASSERT((boost::VertexListGraphConcept<Graph>));
+    typedef typename boost::graph_traits<Graph>::vertex_descriptor vertex_descriptor;
+    typedef typename boost::graph_traits<Graph>::vertices_size_type vertices_size_type;
+    typedef typename boost::graph_traits<Graph>::edge_descriptor edge_descriptor;
+    BOOST_CONCEPT_ASSERT((boost::Convertible<typename boost::graph_traits<Graph>::directed_category, boost::undirected_tag>));
+    BOOST_CONCEPT_ASSERT((boost::ReadablePropertyMapConcept<WeightMap, edge_descriptor>));
+    // typedef typename boost::property_traits<WeightMap>::value_type weight_type;
+    boost::function_requires< MASVisitorConcept<MASVisitor, Graph> >();
+    BOOST_CONCEPT_ASSERT((boost::ReadWritePropertyMapConcept<VertexAssignmentMap, vertex_descriptor>));
+    BOOST_CONCEPT_ASSERT((boost::Convertible<vertex_descriptor, typename boost::property_traits<VertexAssignmentMap>::value_type>));
+    BOOST_CONCEPT_ASSERT((boost::KeyedUpdatableQueueConcept<KeyedUpdatablePriorityQueue>));
+
+    vertices_size_type n = num_vertices(g);
+    if (n < 2)
+      throw boost::bad_graph("the input graph must have at least two vertices.");
+    else if (!pq.empty())
+      throw std::invalid_argument("the max-priority queue must be empty initially.");
+
+    detail::maximum_adjacency_search(g, weights,
+                                            vis, start,
+                                            assignments, pq);
+  }
+
+  namespace graph {
+    namespace detail {
+      template <typename WeightMap>
+      struct mas_dispatch {
+        typedef void result_type;
+        template <typename Graph, typename ArgPack>
+        static result_type apply(const Graph& g, 
+                          //const bgl_named_params<P,T,R>& params, 
+                          const ArgPack& params, 
+                          WeightMap w) {
+
+          using namespace boost::graph::keywords;
+          typedef typename boost::graph_traits<Graph>::vertex_descriptor vertex_descriptor;
+          typedef typename WeightMap::value_type weight_type;
+
+          typedef boost::detail::make_priority_queue_from_arg_pack_gen<boost::graph::keywords::tag::max_priority_queue, weight_type, vertex_descriptor, std::greater<weight_type> > default_pq_gen_type;
+
+          default_pq_gen_type pq_gen(choose_param(get_param(params, boost::distance_zero_t()), weight_type(0)));
+
+          typename boost::result_of<default_pq_gen_type(const Graph&, const ArgPack&)>::type pq = pq_gen(g, params);
+
+          boost::maximum_adjacency_search
+               (g,
+                w,
+                params [ _visitor | make_mas_visitor(null_visitor())],
+                params [ _root_vertex | *vertices(g).first],
+                params [ _vertex_assignment_map | boost::detail::make_property_map_from_arg_pack_gen<boost::graph::keywords::tag::vertex_assignment_map, vertex_descriptor>(vertex_descriptor())(g, params)],
+                pq
+                );
+        }
+      };
+
+      template <>
+      struct mas_dispatch<boost::param_not_found> {
+        typedef void result_type;
+
+        template <typename Graph, typename ArgPack>
+        static result_type apply(const Graph& g, 
+                          const ArgPack& params, 
+                          param_not_found) {
+
+          using namespace boost::graph::keywords;
+          typedef typename boost::graph_traits<Graph>::vertex_descriptor vertex_descriptor;
+
+          // get edge_weight_t as the weight type
+          typedef typename boost::property_map<Graph, edge_weight_t> WeightMap;
+          typedef typename WeightMap::value_type weight_type;
+
+          typedef boost::detail::make_priority_queue_from_arg_pack_gen<boost::graph::keywords::tag::max_priority_queue, weight_type, vertex_descriptor, std::greater<weight_type> > default_pq_gen_type;
+
+          default_pq_gen_type pq_gen(choose_param(get_param(params, boost::distance_zero_t()), weight_type(0)));
+
+          typename boost::result_of<default_pq_gen_type(const Graph&, const ArgPack&)>::type pq = pq_gen(g, params);
+
+          boost::maximum_adjacency_search
+               (g,
+                get(edge_weight, g),
+                params [ _visitor | make_mas_visitor(null_visitor())],
+                params [ _root_vertex | *vertices(g).first],
+                params [ _vertex_assignment_map | boost::detail::make_property_map_from_arg_pack_gen<boost::graph::keywords::tag::vertex_assignment_map, vertex_descriptor>(vertex_descriptor())(g, params)],
+                pq
+                );
+        }
+      };
+    } // end namespace detail
+  } // end namespace graph
+
+  // Named parameter interface
+  //BOOST_GRAPH_MAKE_OLD_STYLE_PARAMETER_FUNCTION(maximum_adjacency_search, 1)
+  template <typename Graph, typename P, typename T, typename R>
+  void
+  maximum_adjacency_search (const Graph& g,
+      const bgl_named_params<P,T,R>& params) {
+
+    typedef bgl_named_params<P, T, R> params_type;
+    BOOST_GRAPH_DECLARE_CONVERTED_PARAMETERS(params_type, params)
+
+    // do the dispatch based on WeightMap
+    typedef typename get_param_type<edge_weight_t, bgl_named_params<P,T,R> >::type W;
+    graph::detail::mas_dispatch<W>::apply(g, arg_pack, get_param(params, edge_weight));
+  }
+
+  namespace graph {
+    namespace detail {
+      template <typename Graph>
+      struct maximum_adjacency_search_impl {
+        typedef void result_type;
+
+        template <typename ArgPack>
+        void
+        operator() (const Graph& g, const ArgPack& arg_pack) const {
+          // call the function that does the dispatching
+          typedef typename get_param_type<edge_weight_t, ArgPack >::type W;
+          graph::detail::mas_dispatch<W>::apply(g, arg_pack, get_param(arg_pack, edge_weight));
+        }
+      };
+    } // end namespace detail
+    BOOST_GRAPH_MAKE_FORWARDING_FUNCTION(maximum_adjacency_search,1,5)
+  } // end namespace graph
+
+} // end namespace boost
+
+#include <boost/graph/iteration_macros_undef.hpp>
+
+#endif // BOOST_GRAPH_MAXIMUM_ADJACENCY_SEARCH_H
diff --git a/include/boost/graph/mcgregor_common_subgraphs.hpp b/include/boost/graph/mcgregor_common_subgraphs.hpp
index c46f72156..9fd544dd0 100644
--- a/include/boost/graph/mcgregor_common_subgraphs.hpp
+++ b/include/boost/graph/mcgregor_common_subgraphs.hpp
@@ -121,7 +121,6 @@ namespace boost {
      VertexEquivalencePredicate vertices_equivalent,
      bool only_connected_subgraphs)
     {
-      typedef typename graph_traits<GraphFirst>::vertex_descriptor VertexFirst;
       typedef typename graph_traits<GraphSecond>::vertex_descriptor VertexSecond;
       
       typedef typename graph_traits<GraphFirst>::edge_descriptor EdgeFirst;
@@ -328,15 +327,11 @@ namespace boost {
             put(correspondence_map_2_to_1, new_vertex2, new_vertex1);
             vertex_stack1.push(new_vertex1);
 
-            // Only output sub-graphs larger than a single vertex
-            if (new_graph_size > 1) {
-            
-              // Returning false from the callback will cancel iteration
-              if (!subgraph_callback(correspondence_map_1_to_2,
-                                     correspondence_map_2_to_1,
-                                     new_graph_size)) {
-                return (false);
-              }
+            // Returning false from the callback will cancel iteration
+            if (!subgraph_callback(correspondence_map_1_to_2,
+                                   correspondence_map_2_to_1,
+                                   new_graph_size)) {
+              return (false);
             }
       
             // Depth-first search into the state space of possible sub-graphs
diff --git a/include/boost/graph/mesh_graph_generator.hpp b/include/boost/graph/mesh_graph_generator.hpp
index 5bf1d47f3..141eca30f 100644
--- a/include/boost/graph/mesh_graph_generator.hpp
+++ b/include/boost/graph/mesh_graph_generator.hpp
@@ -11,7 +11,7 @@
 
 #include <iterator>
 #include <utility>
-#include <cassert>
+#include <boost/assert.hpp>
 #include <boost/graph/graph_traits.hpp>
 #include <boost/type_traits/is_base_and_derived.hpp>
 #include <boost/type_traits/is_same.hpp>
@@ -47,7 +47,7 @@ namespace boost {
                   bool toroidal = true)
       : x(x), y(y), n(x*y), source(0), target(1), current(0,1), 
         toroidal(toroidal), done(false)
-    { assert(x > 1 && y > 1); }
+    { BOOST_ASSERT(x > 1 && y > 1); }
 
     reference operator*() const { return current; }
     pointer operator->() const { return &current; }
diff --git a/include/boost/graph/metric_tsp_approx.hpp b/include/boost/graph/metric_tsp_approx.hpp
index ff81b9f0d..c8e7dba59 100644
--- a/include/boost/graph/metric_tsp_approx.hpp
+++ b/include/boost/graph/metric_tsp_approx.hpp
@@ -173,7 +173,6 @@ namespace boost
 
         // We build a custom graph in this algorithm.
         typedef adjacency_list <vecS, vecS, directedS, no_property, no_property > MSTImpl;
-        typedef graph_traits<MSTImpl>::edge_descriptor Edge;
         typedef graph_traits<MSTImpl>::vertex_descriptor Vertex;
         typedef graph_traits<MSTImpl>::vertex_iterator VItr;
 
@@ -216,7 +215,7 @@ namespace boost
         // Create tour using a preorder traversal of the mst
         vector<Node> tour;
         PreorderTraverser<Node, Tree> tvis(tour);
-        traverse_tree(0, t, tvis);
+        traverse_tree(indexmap[start], t, tvis);
 
         pair<GVItr, GVItr> g_verts(vertices(g));
         for(PreorderTraverser<Node, Tree>::const_iterator curr(tvis.begin());
@@ -228,7 +227,7 @@ namespace boost
         }
 
         // Connect back to the start of the tour
-        vis.visit_vertex(*g_verts.first, g);
+        vis.visit_vertex(start, g);
     }
 
     // Default tsp tour visitor that puts the tour in an OutputIterator
diff --git a/include/boost/graph/minimum_degree_ordering.hpp b/include/boost/graph/minimum_degree_ordering.hpp
index 85e6e7bed..1e171da6c 100644
--- a/include/boost/graph/minimum_degree_ordering.hpp
+++ b/include/boost/graph/minimum_degree_ordering.hpp
@@ -12,7 +12,7 @@
 #define MINIMUM_DEGREE_ORDERING_HPP
 
 #include <vector>
-#include <cassert>
+#include <boost/assert.hpp>
 #include <boost/config.hpp>
 #include <boost/pending/bucket_sorter.hpp>
 #include <boost/detail/numeric_traits.hpp> // for integer_traits
@@ -53,7 +53,7 @@ namespace boost {
           : data(_data), current(-(std::numeric_limits<value_type>::max)()) {}
         
         void pop() {
-          assert(! empty());
+          BOOST_ASSERT(! empty());
           current = data[current];
         }
         void push(value_type v) {
diff --git a/include/boost/graph/named_function_params.hpp b/include/boost/graph/named_function_params.hpp
index 47535fbda..26d3d5e40 100644
--- a/include/boost/graph/named_function_params.hpp
+++ b/include/boost/graph/named_function_params.hpp
@@ -12,12 +12,14 @@
 
 #include <functional>
 #include <vector>
+#include <boost/limits.hpp>
 #include <boost/ref.hpp>
+#include <boost/utility/result_of.hpp>
+#include <boost/preprocessor.hpp>
 #include <boost/parameter/name.hpp>
 #include <boost/parameter/binding.hpp>
-#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits.hpp>
 #include <boost/mpl/not.hpp>
-#include <boost/type_traits/add_reference.hpp>
 #include <boost/graph/properties.hpp>
 #include <boost/graph/detail/d_ary_heap.hpp>
 #include <boost/property_map/property_map.hpp>
@@ -62,6 +64,7 @@ namespace boost {
     BOOST_BGL_ONE_PARAM_CREF(weight_map, edge_weight) \
     BOOST_BGL_ONE_PARAM_CREF(weight_map2, edge_weight2) \
     BOOST_BGL_ONE_PARAM_CREF(distance_map, vertex_distance) \
+    BOOST_BGL_ONE_PARAM_CREF(distance_map2, vertex_distance2) \
     BOOST_BGL_ONE_PARAM_CREF(predecessor_map, vertex_predecessor) \
     BOOST_BGL_ONE_PARAM_CREF(rank_map, vertex_rank) \
     BOOST_BGL_ONE_PARAM_CREF(root_map, vertex_root) \
@@ -111,15 +114,16 @@ namespace boost {
     BOOST_BGL_ONE_PARAM_REF(max_priority_queue, max_priority_queue)
 
   template <typename T, typename Tag, typename Base = no_property>
-  struct bgl_named_params : public Base
+  struct bgl_named_params
   {
     typedef bgl_named_params self;
     typedef Base next_type;
     typedef Tag tag_type;
     typedef T value_type;
     bgl_named_params(T v = T()) : m_value(v) { }
-    bgl_named_params(T v, const Base& b) : Base(b), m_value(v) { }
+    bgl_named_params(T v, const Base& b) : m_value(v), m_base(b) { }
     T m_value;
+    Base m_base;
 
 #define BOOST_BGL_ONE_PARAM_REF(name, key) \
     template <typename PType> \
@@ -182,145 +186,147 @@ BOOST_BGL_DECLARE_NAMED_PARAMS
   //===========================================================================
   // Functions for extracting parameters from bgl_named_params
 
-  template <class Tag1, class Tag2, class T1, class Base>
-  inline
-  typename property_value< bgl_named_params<T1,Tag1,Base>, Tag2>::type
-  get_param(const bgl_named_params<T1,Tag1,Base>& p, Tag2 tag2)
-  {
-    enum { match = detail::same_property<Tag1,Tag2>::value };
-    typedef typename
-      property_value< bgl_named_params<T1,Tag1,Base>, Tag2>::type T2;
-    T2* t2 = 0;
-    typedef detail::property_value_dispatch<match> Dispatcher;
-    return Dispatcher::const_get_value(p, t2, tag2);
-  }
+  template <typename Tag, typename Args>
+  struct lookup_named_param {};
 
+  template <typename T, typename Tag, typename Base>
+  struct lookup_named_param<Tag, bgl_named_params<T, Tag, Base> > {
+    typedef T type;
+    static const T& get(const bgl_named_params<T, Tag, Base>& p) {
+      return p.m_value;
+    }
+  };
 
-  namespace detail {
-    // MSVC++ workaround
-    template <class Param>
-    struct choose_param_helper {
-      template <class Default> struct result { typedef Param type; };
-      template <typename Default>
-      static const Param& apply(const Param& p, const Default&) { return p; }
-    };
-    template <>
-    struct choose_param_helper<error_property_not_found> {
-      template <class Default> struct result { typedef Default type; };
-      template <typename Default>
-      static const Default& apply(const error_property_not_found&, const Default& d)
-        { return d; }
-    };
-  } // namespace detail
+  template <typename Tag1, typename T, typename Tag, typename Base>
+  struct lookup_named_param<Tag1, bgl_named_params<T, Tag, Base> > {
+    typedef typename lookup_named_param<Tag1, Base>::type type;
+    static const type& get(const bgl_named_params<T, Tag, Base>& p) {
+      return lookup_named_param<Tag1, Base>::get(p.m_base);
+    }
+  };
+
+  template <typename Tag, typename Args, typename Def>
+  struct lookup_named_param_def {
+    typedef Def type;
+    static const Def& get(const Args&, const Def& def) {return def;}
+  };
+
+  template <typename T, typename Tag, typename Base, typename Def>
+  struct lookup_named_param_def<Tag, bgl_named_params<T, Tag, Base>, Def> {
+    typedef T type;
+    static const type& get(const bgl_named_params<T, Tag, Base>& p, const Def&) {
+      return p.m_value;
+    }
+  };
+
+  template <typename Tag1, typename T, typename Tag, typename Base, typename Def>
+  struct lookup_named_param_def<Tag1, bgl_named_params<T, Tag, Base>, Def> {
+    typedef typename lookup_named_param_def<Tag1, Base, Def>::type type;
+    static const type& get(const bgl_named_params<T, Tag, Base>& p, const Def& def) {
+      return lookup_named_param_def<Tag1, Base, Def>::get(p.m_base, def);
+    }
+  };
+
+  struct param_not_found {};
+
+  template <typename Tag, typename Args>
+  struct get_param_type: 
+    lookup_named_param_def<Tag, Args, param_not_found> {};
+
+  template <class Tag, typename Args>
+  inline
+  const typename lookup_named_param_def<Tag, Args, param_not_found>::type&
+  get_param(const Args& p, Tag) {
+    return lookup_named_param_def<Tag, Args, param_not_found>::get(p, param_not_found());
+  }
 
   template <class P, class Default> 
-  const typename detail::choose_param_helper<P>::template result<Default>::type&
-  choose_param(const P& param, const Default& d) { 
-    return detail::choose_param_helper<P>::apply(param, d);
+  const P& choose_param(const P& param, const Default&) { 
+    return param;
+  }
+
+  template <class Default>
+  Default choose_param(const param_not_found&, const Default& d) {
+    return d;
   }
 
   template <typename T>
   inline bool is_default_param(const T&) { return false; }
 
-  inline bool is_default_param(const detail::error_property_not_found&)
+  inline bool is_default_param(const param_not_found&)
     { return true; }
 
   namespace detail {
+    template <typename T>
+    struct const_type_as_type {typedef typename T::const_type type;};
+  } // namespace detail
+  
 
-    struct choose_parameter {
-      template <class P, class Graph, class Tag>
-      struct bind_ {
-        typedef const P& const_result_type;
-        typedef const P& result_type;
-        typedef P type;
-      };
-
-      template <class P, class Graph, class Tag>
-      static typename bind_<P, Graph, Tag>::const_result_type
-      const_apply(const P& p, const Graph&, Tag&) 
-      { return p; }
+  // Use this function instead of choose_param() when you want
+  // to avoid requiring get(tag, g) when it is not used. 
+  namespace detail {
+    template <typename GraphIsConst, typename Graph, typename Param, typename Tag>
+    struct choose_impl_result:
+      boost::mpl::eval_if<
+        boost::is_same<Param, param_not_found>, 
+        boost::mpl::eval_if<
+          GraphIsConst,
+          detail::const_type_as_type<property_map<Graph, Tag> >,
+          property_map<Graph, Tag> >,
+        boost::mpl::identity<Param> > {};
+
+    // Parameters of f are (GraphIsConst, Graph, Param, Tag)
+    template <bool Found> struct choose_impl_helper;
+
+    template <> struct choose_impl_helper<false> {
+      template <typename Param, typename Graph, typename PropertyTag>
+      static typename property_map<typename boost::remove_const<Graph>::type, PropertyTag>::const_type
+      f(boost::mpl::true_, const Graph& g, const Param&, PropertyTag tag) {
+        return get(tag, g);
+      }
 
-      template <class P, class Graph, class Tag>
-      static typename bind_<P, Graph, Tag>::result_type
-      apply(const P& p, Graph&, Tag&) 
-      { return p; }
+      template <typename Param, typename Graph, typename PropertyTag>
+      static typename property_map<typename boost::remove_const<Graph>::type, PropertyTag>::type
+      f(boost::mpl::false_, Graph& g, const Param&, PropertyTag tag) {
+        return get(tag, g);
+      }
     };
 
-    struct choose_default_param {
-      template <class P, class Graph, class Tag>
-      struct bind_ {
-        typedef typename property_map<Graph, Tag>::type 
-          result_type;
-        typedef typename property_map<Graph, Tag>::const_type 
-          const_result_type;
-        typedef typename property_map<Graph, Tag>::const_type 
-          type;
-      };
-
-      template <class P, class Graph, class Tag>
-      static typename bind_<P, Graph, Tag>::const_result_type
-      const_apply(const P&, const Graph& g, Tag tag) { 
-        return get(tag, g); 
-      }
-      template <class P, class Graph, class Tag>
-      static typename bind_<P, Graph, Tag>::result_type
-      apply(const P&, Graph& g, Tag tag) { 
-        return get(tag, g); 
+    template <> struct choose_impl_helper<true> {
+      template <typename GraphIsConst, typename Param, typename Graph, typename PropertyTag>
+      static Param f(GraphIsConst, const Graph&, const Param& p, PropertyTag) {
+        return p;
       }
     };
+  }
 
-    template <class Param>
-    struct choose_property_map {
-      typedef choose_parameter type;
-    };
-    template <>
-    struct choose_property_map<detail::error_property_not_found> {
-      typedef choose_default_param type;
-    };
+  template <typename Param, typename Graph, typename PropertyTag>
+  typename detail::choose_impl_result<boost::mpl::true_, Graph, Param, PropertyTag>::type
+  choose_const_pmap(const Param& p, const Graph& g, PropertyTag tag)
+  { 
+    return detail::choose_impl_helper<!boost::is_same<Param, param_not_found>::value>
+             ::f(boost::mpl::true_(), g, p, tag);
+  }
 
-    template <class Param, class Graph, class Tag>
-    struct choose_pmap_helper {
-      typedef typename choose_property_map<Param>::type Selector;
-      typedef typename Selector:: template bind_<Param, Graph, Tag> Bind;
-      typedef Bind type;
-      typedef typename Bind::result_type result_type;
-      typedef typename Bind::const_result_type const_result_type;
-      typedef typename Bind::type result;
-    };
+  template <typename Param, typename Graph, typename PropertyTag>
+  typename detail::choose_impl_result<boost::mpl::false_, Graph, Param, PropertyTag>::type
+  choose_pmap(const Param& p, Graph& g, PropertyTag tag)
+  { 
+    return detail::choose_impl_helper<!boost::is_same<Param, param_not_found>::value>
+             ::f(boost::mpl::false_(), g, p, tag);
+  }
+
+  namespace detail {
 
     // used in the max-flow algorithms
     template <class Graph, class P, class T, class R>
     struct edge_capacity_value
     {
       typedef bgl_named_params<P, T, R> Params;
-      typedef typename property_value< Params, edge_capacity_t>::type Param;
-      typedef typename detail::choose_pmap_helper<Param, Graph,
-        edge_capacity_t>::result CapacityEdgeMap;
+      typedef typename detail::choose_impl_result<boost::mpl::true_, Graph, typename get_param_type<Params, edge_capacity_t>::type, edge_capacity_t>::type CapacityEdgeMap;
       typedef typename property_traits<CapacityEdgeMap>::value_type type;
     };
 
-  } // namespace detail
-  
-
-  // Use this function instead of choose_param() when you want
-  // to avoid requiring get(tag, g) when it is not used. 
-  template <typename Param, typename Graph, typename PropertyTag>
-  typename
-    detail::choose_pmap_helper<Param,Graph,PropertyTag>::const_result_type
-  choose_const_pmap(const Param& p, const Graph& g, PropertyTag tag)
-  { 
-    typedef typename 
-      detail::choose_pmap_helper<Param,Graph,PropertyTag>::Selector Choice;
-    return Choice::const_apply(p, g, tag);
-  }
-
-  template <typename Param, typename Graph, typename PropertyTag>
-  typename detail::choose_pmap_helper<Param,Graph,PropertyTag>::result_type
-  choose_pmap(const Param& p, Graph& g, PropertyTag tag)
-  { 
-    typedef typename 
-      detail::choose_pmap_helper<Param,Graph,PropertyTag>::Selector Choice;
-    return Choice::apply(p, g, tag);
   }
 
   // Declare all new tags
@@ -353,7 +359,7 @@ BOOST_BGL_DECLARE_NAMED_PARAMS
       typedef convert_bgl_params_to_boost_parameter<typename T::next_type> rest_conv;
       typedef boost::parameter::aux::arg_list<tagged_arg_type, typename rest_conv::type> type;
       static type conv(const T& x) {
-        return type(tagged_arg_type(x.m_value), rest_conv::conv(x));
+        return type(tagged_arg_type(x.m_value), rest_conv::conv(x.m_base));
       }
     };
 
@@ -362,7 +368,7 @@ BOOST_BGL_DECLARE_NAMED_PARAMS
       typedef convert_bgl_params_to_boost_parameter<R> rest_conv;
       typedef typename rest_conv::type type;
       static type conv(const bgl_named_params<P, int, R>& x) {
-        return rest_conv::conv(x);
+        return rest_conv::conv(x.m_base);
       }
     };
 
@@ -375,7 +381,7 @@ BOOST_BGL_DECLARE_NAMED_PARAMS
     template <>
     struct convert_bgl_params_to_boost_parameter<boost::no_named_parameters> {
       typedef boost::parameter::aux::empty_arg_list type;
-      static type conv(const boost::no_property&) {return type();}
+      static type conv(const boost::no_named_parameters&) {return type();}
     };
 
     struct bgl_parameter_not_found_type {};
@@ -392,8 +398,8 @@ BOOST_BGL_DECLARE_NAMED_PARAMS
 
     template <typename ArgType, typename Prop, typename Graph, bool Exists>
     struct override_const_property_t {
-      typedef ArgType result_type;
-      result_type operator()(const Graph&, const typename boost::add_reference<ArgType>::type a) const {return a;}
+      typedef typename boost::remove_const<ArgType>::type result_type;
+      result_type operator()(const Graph&, const ArgType& a) const {return a;}
     };
 
     template <typename ArgType, typename Prop, typename Graph>
@@ -428,13 +434,13 @@ BOOST_BGL_DECLARE_NAMED_PARAMS
     template <typename ArgType, typename Prop, typename Graph, bool Exists>
     struct override_property_t {
       typedef ArgType result_type;
-      result_type operator()(const Graph& g, const typename boost::add_reference<ArgType>::type a) const {return a;}
+      result_type operator()(const Graph&, const typename boost::add_reference<ArgType>::type a) const {return a;}
     };
 
     template <typename ArgType, typename Prop, typename Graph>
     struct override_property_t<ArgType, Prop, Graph, false> {
       typedef typename boost::property_map<Graph, Prop>::type result_type;
-      result_type operator()(const Graph& g, const ArgType& a) const {return get(Prop(), g);}
+      result_type operator()(const Graph& g, const ArgType&) const {return get(Prop(), g);}
     };
 
     template <typename ArgPack, typename Tag, typename Prop, typename Graph>
@@ -451,7 +457,7 @@ BOOST_BGL_DECLARE_NAMED_PARAMS
 
     template <typename ArgPack, typename Tag, typename Prop, typename Graph>
     typename override_property_result<ArgPack, Tag, Prop, Graph>::type
-    override_property(const ArgPack& ap, const boost::parameter::keyword<Tag>& t, const Graph& g, Prop prop) {
+    override_property(const ArgPack& ap, const boost::parameter::keyword<Tag>& t, const Graph& g, Prop) {
     return override_property_t<
              typename boost::parameter::value_type<ArgPack, Tag, int>::type,
              Prop,
@@ -460,6 +466,78 @@ BOOST_BGL_DECLARE_NAMED_PARAMS
            >()(g, ap[t | 0]);
     }
 
+    template <typename F> struct make_arg_pack_type;
+    template <> struct make_arg_pack_type<void()> {typedef boost::parameter::aux::empty_arg_list type;};
+    template <typename K, typename A>
+    struct make_arg_pack_type<void(K, A)> {
+      typedef boost::parameter::aux::tagged_argument<K, A> type;
+    };
+
+#define BOOST_GRAPH_OPENING_PART_OF_PAIR(z, i, n) boost::parameter::aux::arg_list<boost::parameter::aux::tagged_argument<BOOST_PP_CAT(Keyword, BOOST_PP_SUB(n, i)),  BOOST_PP_CAT(Arg, BOOST_PP_SUB(n, i))>,
+#define BOOST_GRAPH_MAKE_PAIR_PARAM(z, i, _) const boost::parameter::aux::tagged_argument<BOOST_PP_CAT(Keyword, i), BOOST_PP_CAT(Arg, i)>& BOOST_PP_CAT(kw, i)
+
+#define BOOST_GRAPH_MAKE_AP_TYPE_SPECIALIZATION(z, i, _) \
+    template <BOOST_PP_ENUM_PARAMS(i, typename Keyword), BOOST_PP_ENUM_PARAMS(i, typename Arg)> \
+    struct make_arg_pack_type<void(BOOST_PP_ENUM_PARAMS(i, Keyword), BOOST_PP_ENUM_PARAMS(i, Arg))> { \
+      typedef \
+        BOOST_PP_REPEAT(i, BOOST_GRAPH_OPENING_PART_OF_PAIR, BOOST_PP_DEC(i)) boost::parameter::aux::empty_arg_list BOOST_PP_REPEAT(i, > BOOST_PP_TUPLE_EAT(3), ~) \
+        type; \
+    };
+    BOOST_PP_REPEAT_FROM_TO(2, 11, BOOST_GRAPH_MAKE_AP_TYPE_SPECIALIZATION, ~)
+#undef BOOST_GRAPH_MAKE_AP_TYPE_SPECIALIZATION
+
+#define BOOST_GRAPH_MAKE_FORWARDING_FUNCTION(name, nfixed, nnamed_max) \
+  /* Entry point for conversion from BGL-style named parameters */ \
+  template <BOOST_PP_ENUM_PARAMS(nfixed, typename Param) BOOST_PP_COMMA_IF(nfixed) typename ArgPack> \
+  typename boost::result_of< \
+             detail::BOOST_PP_CAT(name, _impl)<BOOST_PP_ENUM_PARAMS(nfixed, Param)>(BOOST_PP_ENUM_PARAMS(nfixed, Param) BOOST_PP_COMMA_IF(nfixed) const ArgPack&) \
+           >::type \
+  BOOST_PP_CAT(name, _with_named_params)(BOOST_PP_ENUM_BINARY_PARAMS(nfixed, const Param, & param) BOOST_PP_COMMA_IF(nfixed) const ArgPack& arg_pack) { \
+    return detail::BOOST_PP_CAT(name, _impl)<BOOST_PP_ENUM_PARAMS(nfixed, Param)>()(BOOST_PP_ENUM_PARAMS(nfixed, param) BOOST_PP_COMMA_IF(nfixed) arg_pack); \
+  } \
+  /* Individual functions taking Boost.Parameter-style keyword arguments */ \
+  BOOST_PP_REPEAT(BOOST_PP_INC(nnamed_max), BOOST_GRAPH_MAKE_FORWARDING_FUNCTION_ONE, (name)(nfixed))
+
+#define BOOST_GRAPH_MAKE_FORWARDING_FUNCTION_ONE(z, nnamed, seq) \
+  BOOST_GRAPH_MAKE_FORWARDING_FUNCTION_ONEX(z, nnamed, BOOST_PP_SEQ_ELEM(0, seq), BOOST_PP_SEQ_ELEM(1, seq))
+
+#define BOOST_GRAPH_MAKE_FORWARDING_FUNCTION_ONEX(z, nnamed, name, nfixed) \
+  template <BOOST_PP_ENUM_PARAMS(nfixed, typename Param) BOOST_PP_ENUM_TRAILING_PARAMS(nnamed, typename Keyword) BOOST_PP_ENUM_TRAILING_PARAMS(nnamed, typename Arg)> \
+  typename boost::result_of< \
+             detail::BOOST_PP_CAT(name, _impl)<BOOST_PP_ENUM_PARAMS(nfixed, Param)> \
+               (BOOST_PP_ENUM_PARAMS(nfixed, Param) BOOST_PP_COMMA_IF(nfixed) \
+                const typename boost::detail::make_arg_pack_type<void(BOOST_PP_ENUM_PARAMS(nnamed, Keyword) BOOST_PP_COMMA_IF(nnamed) BOOST_PP_ENUM_PARAMS(nnamed, Arg))>::type&) \
+           >::type \
+  name(BOOST_PP_ENUM_BINARY_PARAMS(nfixed, const Param, & param) \
+       BOOST_PP_ENUM_TRAILING(nnamed, BOOST_GRAPH_MAKE_PAIR_PARAM, ~)) { \
+    return detail::BOOST_PP_CAT(name, _impl)<BOOST_PP_ENUM_PARAMS(nfixed, Param)>() \
+             (BOOST_PP_ENUM_PARAMS(nfixed, param), \
+              (boost::parameter::aux::empty_arg_list() BOOST_PP_ENUM_TRAILING_PARAMS(nnamed, kw))); \
+  }
+
+#define BOOST_GRAPH_MAKE_OLD_STYLE_PARAMETER_FUNCTION(name, nfixed) \
+  template <BOOST_PP_ENUM_PARAMS(nfixed, typename Param) BOOST_PP_COMMA_IF(nfixed) class P, class T, class R> \
+  typename boost::result_of< \
+    ::boost::graph::detail::BOOST_PP_CAT(name, _impl) BOOST_PP_EXPR_IF(nfixed, <) BOOST_PP_ENUM_PARAMS(nfixed, Param) BOOST_PP_EXPR_IF(nfixed, >) \
+      (BOOST_PP_ENUM_PARAMS(nfixed, Param) BOOST_PP_COMMA_IF(nfixed) \
+       const typename boost::detail::convert_bgl_params_to_boost_parameter<boost::bgl_named_params<P, T, R> >::type &) \
+    >::type \
+  name(BOOST_PP_ENUM_BINARY_PARAMS(nfixed, const Param, & param) BOOST_PP_COMMA_IF(nfixed) const boost::bgl_named_params<P, T, R>& old_style_params) { \
+    typedef boost::bgl_named_params<P, T, R> old_style_params_type; \
+    BOOST_GRAPH_DECLARE_CONVERTED_PARAMETERS(old_style_params_type, old_style_params) \
+    return ::boost::graph::BOOST_PP_CAT(name, _with_named_params)(BOOST_PP_ENUM_PARAMS(nfixed, param) BOOST_PP_COMMA_IF(nfixed) arg_pack); \
+  } \
+  \
+  BOOST_PP_EXPR_IF(nfixed, template <) BOOST_PP_ENUM_PARAMS(nfixed, typename Param) BOOST_PP_EXPR_IF(nfixed, >) \
+  BOOST_PP_EXPR_IF(nfixed, typename) boost::result_of< \
+    ::boost::graph::detail::BOOST_PP_CAT(name, _impl) BOOST_PP_EXPR_IF(nfixed, <) BOOST_PP_ENUM_PARAMS(nfixed, Param) BOOST_PP_EXPR_IF(nfixed, >) \
+      (BOOST_PP_ENUM_PARAMS(nfixed, Param) BOOST_PP_COMMA_IF(nfixed) const boost::parameter::aux::empty_arg_list &) \
+    >::type \
+  name(BOOST_PP_ENUM_BINARY_PARAMS(nfixed, const Param, & param)) { \
+    BOOST_GRAPH_DECLARE_CONVERTED_PARAMETERS(boost::no_named_parameters, boost::no_named_parameters()) \
+    return ::boost::graph::BOOST_PP_CAT(name, _with_named_params)(BOOST_PP_ENUM_PARAMS(nfixed, param) BOOST_PP_COMMA_IF(nfixed) arg_pack); \
+  }
+
   }
 
   namespace detail {
@@ -557,7 +635,7 @@ BOOST_BGL_DECLARE_NAMED_PARAMS
       typedef Q priority_queue_type;
 
       static priority_queue_type
-      make_queue(const Graph& g, const ArgPack& ap, KeyT defaultKey, const Q& q) {
+      make_queue(const Graph&, const ArgPack&, KeyT, const Q& q) {
         return q;
       }
     };
@@ -569,7 +647,7 @@ BOOST_BGL_DECLARE_NAMED_PARAMS
       typedef boost::d_ary_heap_indirect<ValueT, 4, index_in_heap_map, typename map_maker<Graph, ArgPack, KeyMapTag, KeyT>::helper::map_type, Compare> priority_queue_type;
 
       static priority_queue_type
-      make_queue(const Graph& g, const ArgPack& ap, KeyT defaultKey, const Q& q) {
+      make_queue(const Graph& g, const ArgPack& ap, KeyT defaultKey, const Q&) {
         return priority_queue_type(
             map_maker<Graph, ArgPack, KeyMapTag, KeyT>::make_map(g, ap, defaultKey),
             map_maker<Graph, ArgPack, IndexInHeapMapTag, default_index_in_heap_type>::make_map(g, ap, typename boost::property_traits<index_in_heap_map>::value_type(-1))
@@ -584,14 +662,18 @@ BOOST_BGL_DECLARE_NAMED_PARAMS
         g_hasQ =
           (parameter_exists<ArgPack, PriorityQueueTag>
            ::value));
+      typedef boost::reference_wrapper<int> int_refw;
+      typedef typename boost::parameter::value_type<
+                         ArgPack,
+                         PriorityQueueTag,
+                         int_refw
+                       >::type
+        param_value_type_wrapper;
+      typedef typename param_value_type_wrapper::type
+        param_value_type;
+      typedef typename boost::remove_const<param_value_type>::type param_value_type_no_const;
       typedef priority_queue_maker_helper<g_hasQ, Graph, ArgPack, KeyT, ValueT, KeyMapTag, IndexInHeapMapTag, Compare,
-                                          typename boost::remove_const<
-                                            typename boost::parameter::value_type<
-                                                       ArgPack,
-                                                       PriorityQueueTag,
-                                                       boost::reference_wrapper<int>
-                                                     >::type::type
-                                                   >::type> helper;
+                                          param_value_type_no_const> helper;
       typedef typename helper::priority_queue_type priority_queue_type;
 
       static priority_queue_type make_queue(const Graph& g, const ArgPack& ap, KeyT defaultKey) {
@@ -605,6 +687,13 @@ BOOST_BGL_DECLARE_NAMED_PARAMS
 
       make_priority_queue_from_arg_pack_gen(KeyT defaultKey_) : defaultKey(defaultKey_) { }
 
+      template <class F>
+      struct result {
+        typedef typename remove_const<typename remove_reference<typename function_traits<F>::arg1_type>::type>::type graph_type;
+        typedef typename remove_const<typename remove_reference<typename function_traits<F>::arg2_type>::type>::type arg_pack_type;
+        typedef typename priority_queue_maker<graph_type, arg_pack_type, KeyT, ValueT, PriorityQueueTag, KeyMapTag, IndexInHeapMapTag, Compare>::priority_queue_type type;
+      };
+
       template <class Graph, class ArgPack>
       typename priority_queue_maker<Graph, ArgPack, KeyT, ValueT, PriorityQueueTag, KeyMapTag, IndexInHeapMapTag, Compare>::priority_queue_type
       operator()(const Graph& g, const ArgPack& ap) const {
@@ -612,6 +701,34 @@ BOOST_BGL_DECLARE_NAMED_PARAMS
       }
     };
 
+    template <typename G>
+    typename boost::graph_traits<G>::vertex_descriptor
+    get_null_vertex(const G&) {return boost::graph_traits<G>::null_vertex();}
+
+    template <typename G>
+    typename boost::graph_traits<G>::vertex_descriptor
+    get_default_starting_vertex(const G& g) {
+      std::pair<typename boost::graph_traits<G>::vertex_iterator, typename boost::graph_traits<G>::vertex_iterator> iters = vertices(g);
+      return (iters.first == iters.second) ? boost::graph_traits<G>::null_vertex() : *iters.first;
+    }
+
+    template <typename G>
+    struct get_default_starting_vertex_t {
+      typedef typename boost::graph_traits<G>::vertex_descriptor result_type;
+      const G& g;
+      get_default_starting_vertex_t(const G& g): g(g) {}
+      result_type operator()() const {return get_default_starting_vertex(g);}
+    };
+
+    // Wrapper to avoid instantiating numeric_limits when users provide distance_inf value manually
+    template <typename T>
+    struct get_max {
+      T operator()() const {
+        return (std::numeric_limits<T>::max)();
+      }
+      typedef T result_type;
+    };
+
   } // namespace detail
 
 } // namespace boost
diff --git a/include/boost/graph/named_graph.hpp b/include/boost/graph/named_graph.hpp
index dda608d78..e4d3314a2 100644
--- a/include/boost/graph/named_graph.hpp
+++ b/include/boost/graph/named_graph.hpp
@@ -11,14 +11,26 @@
 #define BOOST_GRAPH_NAMED_GRAPH_HPP
 
 #include <boost/config.hpp>
-#include <boost/type_traits/remove_cv.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/multi_index_container.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/functional/hash.hpp>
+#include <boost/graph/graph_traits.hpp>
+#include <boost/graph/properties.hpp>
 #include <boost/multi_index/hashed_index.hpp>
 #include <boost/multi_index/member.hpp>
+#include <boost/multi_index_container.hpp>
 #include <boost/optional.hpp>
+#include <boost/pending/property.hpp> // for boost::lookup_one_property
+#include <boost/pending/container_traits.hpp>
 #include <boost/throw_exception.hpp>
+#include <boost/tuple/tuple.hpp> // for boost::make_tuple
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <functional> // for std::equal_to
 #include <stdexcept> // for std::runtime_error
+#include <utility> // for std::pair
 
 namespace boost { namespace graph {
 
@@ -50,7 +62,6 @@ struct internal_vertex_name
   typedef void type;
 };
 
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 /**
  * Extract the internal vertex name from a @c property structure by
  * looking at its base.
@@ -58,7 +69,6 @@ struct internal_vertex_name
 template<typename Tag, typename T, typename Base>
 struct internal_vertex_name<property<Tag, T, Base> >
   : internal_vertex_name<Base> { };
-#endif
 
 /**
  * Construct an instance of @c VertexProperty directly from its
@@ -105,7 +115,7 @@ struct cannot_add_vertex
   typedef vertex_name_type argument_type;
   typedef VertexProperty result_type;
 
-  VertexProperty operator()(const vertex_name_type& name)
+  VertexProperty operator()(const vertex_name_type&)
   {
       boost::throw_exception(std::runtime_error("add_vertex: "
                                                 "unable to create a vertex from its name"));
@@ -145,7 +155,6 @@ struct internal_vertex_constructor
   typedef cannot_add_vertex<VertexProperty> type;
 };
 
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 /**
  * Extract the internal vertex constructor from a @c property structure by
  * looking at its base.
@@ -153,52 +162,6 @@ struct internal_vertex_constructor
 template<typename Tag, typename T, typename Base>
 struct internal_vertex_constructor<property<Tag, T, Base> >
   : internal_vertex_constructor<Base> { };
-#endif
-
-/*******************************************************************
- * Named graph-specific metafunctions                              *
- *******************************************************************/
-namespace detail {
-  /** @internal
-   * Extracts the type of a bundled vertex property from a vertex
-   * property. The primary template matches when we have hit the end
-   * of the @c property<> list.
-   */
-  template<typename VertexProperty>
-  struct extract_bundled_vertex
-  {
-    typedef VertexProperty type;
-  };
-
-  /** @internal
-   * Recursively extract the bundled vertex property from a vertex
-   * property.
-   */
-  template<typename Tag, typename T, typename Base>
-  struct extract_bundled_vertex<property<Tag, T, Base> >
-    : extract_bundled_vertex<Base>
-  { };
-
-  /**
-   * We have found the bundled vertex property type, marked with
-   * vertex_bundle_t.
-   */
-  template<typename T, typename Base>
-  struct extract_bundled_vertex<property<vertex_bundle_t, T, Base> >
-  {
-    typedef T type;
-  };
-
-  /**
-   * Translate @c no_property into @c error_property_not_found when we
-   * have failed to extract a bundled vertex property type.
-   */
-  template<>
-  struct extract_bundled_vertex<no_property>
-  {
-    typedef boost::detail::error_property_not_found type;
-  };
-}
 
 /*******************************************************************
  * Named graph mixin                                               *
@@ -228,7 +191,7 @@ class named_graph
   typedef typename internal_vertex_name<VertexProperty>::type extract_name_type;
   /// The type of the "bundled" property, from which the name can be
   /// extracted.
-  typedef typename detail::extract_bundled_vertex<VertexProperty>::type
+  typedef typename lookup_one_property<VertexProperty, vertex_bundle_t>::type
     bundled_vertex_property_type;
 
   /// The type of the function object that generates vertex properties
@@ -289,7 +252,8 @@ class named_graph
 
   /// Notify the named_graph that we are removing the given
   /// vertex. The name of the vertex will be removed from the mapping.
-  void removing_vertex(Vertex vertex);
+  template <typename VertexIterStability>
+  void removing_vertex(Vertex vertex, VertexIterStability);
 
   /// Notify the named_graph that we are clearing the graph.
   /// This will clear out all of the name->vertex mappings
@@ -344,9 +308,13 @@ inline void BGL_NAMED_GRAPH::added_vertex(Vertex vertex)
 }
 
 template<BGL_NAMED_GRAPH_PARAMS>
-inline void BGL_NAMED_GRAPH::removing_vertex(Vertex vertex)
+template<typename VertexIterStability>
+inline void BGL_NAMED_GRAPH::removing_vertex(Vertex vertex, VertexIterStability)
 {
-  named_vertices.erase(vertex);
+  BOOST_STATIC_ASSERT_MSG ((boost::is_base_of<boost::graph_detail::stable_tag, VertexIterStability>::value), "Named graphs cannot use vecS as vertex container and remove vertices; the lack of vertex descriptor stability (which iterator stability is a proxy for) means that the name -> vertex mapping would need to be completely rebuilt after each deletion.  See https://svn.boost.org/trac/boost/ticket/7863 for more information and a test case.");
+  typedef typename BGL_NAMED_GRAPH::vertex_name_type vertex_name_type;
+  const vertex_name_type& vertex_name = extract_name(derived()[vertex]);
+  named_vertices.erase(vertex_name);
 }
 
 template<BGL_NAMED_GRAPH_PARAMS>
@@ -395,8 +363,15 @@ find_vertex(typename BGL_NAMED_GRAPH::vertex_name_type const& name,
 
 /// Retrieve the vertex associated with the given name, or add a new
 /// vertex with that name if no such vertex is available.
+/// Note: This is enabled only when the vertex property type is different
+///       from the vertex name to avoid ambiguous overload problems with
+///       the add_vertex() function that takes a vertex property.
 template<BGL_NAMED_GRAPH_PARAMS>
-Vertex
+    typename disable_if<is_same<
+        typename BGL_NAMED_GRAPH::vertex_name_type,
+        VertexProperty
+    >,
+Vertex>::type
 add_vertex(typename BGL_NAMED_GRAPH::vertex_name_type const& name,
            BGL_NAMED_GRAPH& g)
 {
@@ -444,6 +419,35 @@ add_edge(typename BGL_NAMED_GRAPH::vertex_name_type const& u_name,
                   g.derived());
 }
 
+// Overloads to support EdgeMutablePropertyGraph graphs
+template <BGL_NAMED_GRAPH_PARAMS>
+std::pair<typename graph_traits<Graph>::edge_descriptor, bool>
+add_edge(typename BGL_NAMED_GRAPH::vertex_descriptor const& u,
+         typename BGL_NAMED_GRAPH::vertex_name_type const& v_name,
+         typename edge_property_type<Graph>::type const& p,
+         BGL_NAMED_GRAPH& g) {
+    return add_edge(u, add_vertex(v_name, g.derived()), p, g.derived());
+}
+
+template <BGL_NAMED_GRAPH_PARAMS>
+std::pair<typename graph_traits<Graph>::edge_descriptor, bool>
+add_edge(typename BGL_NAMED_GRAPH::vertex_name_type const& u_name,
+         typename BGL_NAMED_GRAPH::vertex_descriptor const& v,
+         typename edge_property_type<Graph>::type const& p,
+         BGL_NAMED_GRAPH& g) {
+    return add_edge(add_vertex(u_name, g.derived()), v, p, g.derived());
+}
+
+template <BGL_NAMED_GRAPH_PARAMS>
+std::pair<typename graph_traits<Graph>::edge_descriptor, bool>
+add_edge(typename BGL_NAMED_GRAPH::vertex_name_type const& u_name,
+         typename BGL_NAMED_GRAPH::vertex_name_type const& v_name,
+         typename edge_property_type<Graph>::type const& p,
+         BGL_NAMED_GRAPH& g) {
+    return add_edge(add_vertex(u_name, g.derived()),
+                    add_vertex(v_name, g.derived()), p, g.derived());
+}
+
 #undef BGL_NAMED_GRAPH
 #undef BGL_NAMED_GRAPH_PARAMS
 
@@ -451,7 +455,6 @@ add_edge(typename BGL_NAMED_GRAPH::vertex_name_type const& u_name,
  * Maybe named graph mixin                                         *
  *******************************************************************/
 
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 /**
  * A graph mixin that can provide a mapping from names to vertices,
  * and use that mapping to simplify creation and manipulation of
@@ -475,38 +478,7 @@ struct maybe_named_graph<Graph, Vertex, VertexProperty, void>
 {
   /// The type of the "bundled" property, from which the name can be
   /// extracted.
-  typedef typename detail::extract_bundled_vertex<VertexProperty>::type
-    bundled_vertex_property_type;
-
-  /// Notify the named_graph that we have added the given vertex. This
-  /// is a no-op.
-  void added_vertex(Vertex) { }
-
-  /// Notify the named_graph that we are removing the given
-  /// vertex. This is a no-op.
-  void removing_vertex(Vertex) { }
-
-  /// Notify the named_graph that we are clearing the graph. This is a
-  /// no-op.
-  void clearing_graph() { }
-
-  /// Search for a vertex that has the given property (based on its
-  /// name). This always returns an empty optional<>
-  optional<Vertex>
-  vertex_by_property(const bundled_vertex_property_type&)
-  {
-    return optional<Vertex>();
-  }
-};
-#else
-template<typename Graph, typename Vertex, typename VertexProperty,
-         typename ExtractName
-           = typename internal_vertex_name<VertexProperty>::type>
-struct maybe_named_graph
-{
-  /// The type of the "bundled" property, from which the name can be
-  /// extracted.
-  typedef typename detail::extract_bundled_vertex<VertexProperty>::type
+  typedef typename lookup_one_property<VertexProperty, vertex_bundle_t>::type
     bundled_vertex_property_type;
 
   /// Notify the named_graph that we have added the given vertex. This
@@ -515,7 +487,8 @@ struct maybe_named_graph
 
   /// Notify the named_graph that we are removing the given
   /// vertex. This is a no-op.
-  void removing_vertex(Vertex) { }
+  template <typename VertexIterStability>
+  void removing_vertex(Vertex, VertexIterStability) { }
 
   /// Notify the named_graph that we are clearing the graph. This is a
   /// no-op.
@@ -523,14 +496,12 @@ struct maybe_named_graph
 
   /// Search for a vertex that has the given property (based on its
   /// name). This always returns an empty optional<>
-  template<typename Property>
   optional<Vertex>
   vertex_by_property(const bundled_vertex_property_type&)
   {
     return optional<Vertex>();
   }
 };
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
 } } // end namespace boost::graph
 
diff --git a/include/boost/graph/neighbor_bfs.hpp b/include/boost/graph/neighbor_bfs.hpp
index 3ed94fc54..4830dcc4e 100644
--- a/include/boost/graph/neighbor_bfs.hpp
+++ b/include/boost/graph/neighbor_bfs.hpp
@@ -24,13 +24,14 @@
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/visitors.hpp>
 #include <boost/graph/named_function_params.hpp>
+#include <boost/concept/assert.hpp>
 
 namespace boost {
 
   template <class Visitor, class Graph>
   struct NeighborBFSVisitorConcept {
     void constraints() {
-      function_requires< CopyConstructibleConcept<Visitor> >();
+      BOOST_CONCEPT_ASSERT(( CopyConstructibleConcept<Visitor> ));
       vis.initialize_vertex(u, g);
       vis.discover_vertex(u, g);
       vis.examine_vertex(u, g);
@@ -133,13 +134,13 @@ namespace boost {
        Buffer& Q, BFSVisitor vis, ColorMap color)
 
     {
-      function_requires< BidirectionalGraphConcept<BidirectionalGraph> >();
+      BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<BidirectionalGraph> ));
       typedef graph_traits<BidirectionalGraph> GTraits;
       typedef typename GTraits::vertex_descriptor Vertex;
       typedef typename GTraits::edge_descriptor Edge;
-      function_requires< 
-        NeighborBFSVisitorConcept<BFSVisitor, BidirectionalGraph> >();
-      function_requires< ReadWritePropertyMapConcept<ColorMap, Vertex> >();
+      BOOST_CONCEPT_ASSERT(( 
+        NeighborBFSVisitorConcept<BFSVisitor, BidirectionalGraph> ));
+      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<ColorMap, Vertex> ));
       typedef typename property_traits<ColorMap>::value_type ColorValue;
       typedef color_traits<ColorValue> Color;
       
@@ -249,13 +250,13 @@ namespace boost {
     };
 
     template <>
-    struct neighbor_bfs_dispatch<detail::error_property_not_found> {
+    struct neighbor_bfs_dispatch<param_not_found> {
       template <class VertexListGraph, class P, class T, class R>
       static void apply
       (VertexListGraph& g,
        typename graph_traits<VertexListGraph>::vertex_descriptor s,
        const bgl_named_params<P, T, R>& params,
-       detail::error_property_not_found)
+       param_not_found)
       {
         std::vector<default_color_type> color_vec(num_vertices(g));
         null_visitor null_vis;
@@ -287,8 +288,7 @@ namespace boost {
     // graph is not really const since we may write to property maps
     // of the graph.
     VertexListGraph& ng = const_cast<VertexListGraph&>(g);
-    typedef typename property_value< bgl_named_params<P,T,R>, 
-      vertex_color_t>::type C;
+    typedef typename get_param_type< vertex_color_t, bgl_named_params<P,T,R> >::type C;
     detail::neighbor_bfs_dispatch<C>::apply(ng, s, params, 
                                             get_param(params, vertex_color));
   }
diff --git a/include/boost/graph/one_bit_color_map.hpp b/include/boost/graph/one_bit_color_map.hpp
index 95a9604f6..b153b732f 100644
--- a/include/boost/graph/one_bit_color_map.hpp
+++ b/include/boost/graph/one_bit_color_map.hpp
@@ -18,6 +18,7 @@
 #include <boost/graph/properties.hpp>
 #include <boost/shared_array.hpp>
 #include <boost/config.hpp>
+#include <boost/assert.hpp>
 #include <algorithm>
 #include <limits>
 
@@ -65,7 +66,7 @@ get(const one_bit_color_map<IndexMap>& pm,
 {
   BOOST_STATIC_CONSTANT(int, bits_per_char = one_bit_color_map<IndexMap>::bits_per_char);
   typename property_traits<IndexMap>::value_type i = get(pm.index, key);
-  assert ((std::size_t)i < pm.n);
+  BOOST_ASSERT ((std::size_t)i < pm.n);
   return one_bit_color_type((pm.data.get()[i / bits_per_char] >> (i % bits_per_char)) & 1);
 }
 
@@ -77,8 +78,8 @@ put(const one_bit_color_map<IndexMap>& pm,
 {
   BOOST_STATIC_CONSTANT(int, bits_per_char = one_bit_color_map<IndexMap>::bits_per_char);
   typename property_traits<IndexMap>::value_type i = get(pm.index, key);
-  assert ((std::size_t)i < pm.n);
-  assert (value >= 0 && value < 2);
+  BOOST_ASSERT ((std::size_t)i < pm.n);
+  BOOST_ASSERT (value >= 0 && value < 2);
   std::size_t byte_num = i / bits_per_char;
   std::size_t bit_position = (i % bits_per_char);
     pm.data.get()[byte_num] =
diff --git a/include/boost/graph/planar_canonical_ordering.hpp b/include/boost/graph/planar_canonical_ordering.hpp
index d43ea4785..d470ee591 100644
--- a/include/boost/graph/planar_canonical_ordering.hpp
+++ b/include/boost/graph/planar_canonical_ordering.hpp
@@ -12,7 +12,7 @@
 #include <vector>
 #include <list>
 #include <boost/config.hpp>
-#include <boost/utility.hpp>  //for next and prior
+#include <boost/next_prior.hpp>
 #include <boost/graph/graph_traits.hpp>
 #include <boost/property_map/property_map.hpp>
 
@@ -41,10 +41,8 @@ namespace boost
     
     typedef typename graph_traits<Graph>::vertex_descriptor vertex_t;
     typedef typename graph_traits<Graph>::edge_descriptor edge_t;
-    typedef typename graph_traits<Graph>::vertex_iterator vertex_iterator_t;
     typedef typename graph_traits<Graph>::adjacency_iterator
       adjacency_iterator_t;
-    typedef typename std::pair<vertex_t, vertex_t> vertex_pair_t;
     typedef typename property_traits<PlanarEmbedding>::value_type 
       embedding_value_t;
     typedef typename embedding_value_t::const_iterator embedding_iterator_t;
@@ -67,7 +65,7 @@ namespace boost
     vertex_t first_vertex = *vertices(g).first;
     vertex_t second_vertex;
     adjacency_iterator_t ai, ai_end;
-    for(tie(ai,ai_end) = adjacent_vertices(first_vertex,g); ai != ai_end; ++ai)
+    for(boost::tie(ai,ai_end) = adjacent_vertices(first_vertex,g); ai != ai_end; ++ai)
       {
         if (*ai == first_vertex)
           continue;
diff --git a/include/boost/graph/planar_detail/boyer_myrvold_impl.hpp b/include/boost/graph/planar_detail/boyer_myrvold_impl.hpp
index 71607fcbc..41ba2bc57 100644
--- a/include/boost/graph/planar_detail/boyer_myrvold_impl.hpp
+++ b/include/boost/graph/planar_detail/boyer_myrvold_impl.hpp
@@ -10,7 +10,7 @@
 
 #include <vector>
 #include <list>
-#include <boost/utility.hpp>   //for boost::next
+#include <boost/next_prior.hpp>
 #include <boost/config.hpp>    //for std::min macros
 #include <boost/shared_ptr.hpp>
 #include <boost/tuple/tuple.hpp>
diff --git a/include/boost/graph/planar_face_traversal.hpp b/include/boost/graph/planar_face_traversal.hpp
index 2f8a2ee33..6befa43ba 100644
--- a/include/boost/graph/planar_face_traversal.hpp
+++ b/include/boost/graph/planar_face_traversal.hpp
@@ -10,8 +10,11 @@
 #define __PLANAR_FACE_TRAVERSAL_HPP__
 
 #include <vector>
-#include <boost/utility.hpp> //for next and prior
+#include <set>
+#include <map>
+#include <boost/next_prior.hpp>
 #include <boost/graph/graph_traits.hpp>
+#include <boost/graph/properties.hpp>
 
 
 namespace boost
@@ -98,7 +101,7 @@ namespace boost
     // PlanarEmbedding so that get(next_edge, e)[v] is the edge that comes
     // after e in the clockwise embedding around vertex v.
 
-    for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
+    for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
       {
         vertex_t v(*vi);
         pi_begin = embedding[v].begin();
@@ -122,7 +125,7 @@ namespace boost
     std::vector<edge_t> edges_cache;
     std::vector<vertex_t> vertices_in_edge;
 
-    for(tie(fi,fi_end) = edges(g); fi != fi_end; ++fi)
+    for(boost::tie(fi,fi_end) = edges(g); fi != fi_end; ++fi)
       {
         edge_t e(*fi);
         edges_cache.push_back(e);
diff --git a/include/boost/graph/properties.hpp b/include/boost/graph/properties.hpp
index fa8440e93..ca6a4e9b1 100644
--- a/include/boost/graph/properties.hpp
+++ b/include/boost/graph/properties.hpp
@@ -11,7 +11,7 @@
 #define BOOST_GRAPH_PROPERTIES_HPP
 
 #include <boost/config.hpp>
-#include <cassert>
+#include <boost/assert.hpp>
 #include <boost/pending/property.hpp>
 #include <boost/detail/workaround.hpp>
 
@@ -21,18 +21,12 @@
 #include <boost/graph/property_maps/null_property_map.hpp>
 
 #include <boost/graph/graph_traits.hpp>
-#include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits.hpp>
 #include <boost/limits.hpp>
 #include <boost/mpl/and.hpp>
 #include <boost/mpl/not.hpp>
 #include <boost/mpl/if.hpp>
 
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-// Stay out of the way of the concept checking class
-# define Graph Graph_
-# define RandomAccessContainer RandomAccessContainer_
-#endif
-
 namespace boost {
 
   enum default_color_type { white_color, gray_color, green_color, red_color, black_color };
@@ -53,41 +47,25 @@ namespace boost {
   inline default_color_type red(default_color_type) { return red_color; }
   inline default_color_type black(default_color_type) { return black_color; }
 
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-  template <>
-  struct property_traits<default_color_type*> {
-    typedef default_color_type value_type;
-    typedef std::ptrdiff_t key_type;
-    typedef default_color_type& reference;
-    typedef lvalue_property_map_tag category;
-  };
-  // get/put already defined for T*
-#endif
 
   struct graph_property_tag { };
   struct vertex_property_tag { };
   struct edge_property_tag { };
 
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
   // See examples/edge_property.cpp for how to use this.
 #define BOOST_INSTALL_PROPERTY(KIND, NAME) \
   template <> struct property_kind<KIND##_##NAME##_t> { \
     typedef KIND##_property_tag type; \
   }
-#else
-#define BOOST_INSTALL_PROPERTY(KIND, NAME) \
-  template <> struct property_kind<KIND##_##NAME##_t> { \
-    typedef KIND##_property_tag type; \
-  }
-#endif
 
 #define BOOST_DEF_PROPERTY(KIND, NAME) \
   enum KIND##_##NAME##_t { KIND##_##NAME }; \
   BOOST_INSTALL_PROPERTY(KIND, NAME)
 
-  BOOST_DEF_PROPERTY(vertex, all);
-  BOOST_DEF_PROPERTY(edge, all);
-  BOOST_DEF_PROPERTY(graph, all);
+  // These three are defined in boost/pending/property.hpp
+  BOOST_INSTALL_PROPERTY(vertex, all);
+  BOOST_INSTALL_PROPERTY(edge, all);
+  BOOST_INSTALL_PROPERTY(graph, all);
   BOOST_DEF_PROPERTY(vertex, index);
   BOOST_DEF_PROPERTY(vertex, index1);
   BOOST_DEF_PROPERTY(vertex, index2);
@@ -115,6 +93,7 @@ namespace boost {
   BOOST_DEF_PROPERTY(vertex, lowpoint);
   BOOST_DEF_PROPERTY(vertex, potential);
   BOOST_DEF_PROPERTY(vertex, update);
+  BOOST_DEF_PROPERTY(vertex, underlying);
   BOOST_DEF_PROPERTY(edge, reverse);
   BOOST_DEF_PROPERTY(edge, capacity);
   BOOST_DEF_PROPERTY(edge, flow);
@@ -123,12 +102,14 @@ namespace boost {
   BOOST_DEF_PROPERTY(edge, discover_time);
   BOOST_DEF_PROPERTY(edge, update);
   BOOST_DEF_PROPERTY(edge, finished);
+  BOOST_DEF_PROPERTY(edge, underlying);
   BOOST_DEF_PROPERTY(graph, visitor);
 
   // These tags are used for property bundles
-  BOOST_DEF_PROPERTY(graph, bundle);
-  BOOST_DEF_PROPERTY(vertex, bundle);
-  BOOST_DEF_PROPERTY(edge, bundle);
+  // These three are defined in boost/pending/property.hpp
+  BOOST_INSTALL_PROPERTY(graph, bundle);
+  BOOST_INSTALL_PROPERTY(vertex, bundle);
+  BOOST_INSTALL_PROPERTY(edge, bundle);
 
   // These tags are used to denote the owners and local descriptors
   // for the vertices and edges of a distributed graph.
@@ -145,6 +126,25 @@ namespace boost {
 
   namespace detail {
 
+    template <typename G, typename Tag>
+    struct property_kind_from_graph: property_kind<Tag> {};
+
+#ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES
+    template <typename G, typename R, typename T>
+    struct property_kind_from_graph<G, R T::*> {
+      typedef typename boost::mpl::if_<
+                boost::is_base_of<T, typename vertex_bundle_type<G>::type>,
+                vertex_property_tag,
+                typename boost::mpl::if_<
+                  boost::is_base_of<T, typename edge_bundle_type<G>::type>,
+                  edge_property_tag,
+                  typename boost::mpl::if_<
+                    boost::is_base_of<T, typename graph_bundle_type<G>::type>,
+                    graph_property_tag,
+                    void>::type>::type>::type type;
+    };
+#endif
+
     struct dummy_edge_property_selector {
       template <class Graph, class Property, class Tag>
       struct bind_ {
@@ -189,70 +189,32 @@ namespace boost {
     };
 
     template <class Graph, class PropertyTag>
-    struct edge_property_map {
-      typedef typename edge_property_type<Graph>::type Property;
-      typedef typename graph_tag_or_void<Graph>::type graph_tag;
-      typedef typename edge_property_selector<graph_tag>::type Selector;
-      typedef typename Selector::template bind_<Graph,Property,PropertyTag>
-        Bind;
-      typedef typename Bind::type type;
-      typedef typename Bind::const_type const_type;
-    };
+    struct edge_property_map
+      : edge_property_selector<
+          typename graph_tag_or_void<Graph>::type
+        >::type::template bind_<
+                            Graph,
+                            typename edge_property_type<Graph>::type,
+                            PropertyTag>
+      {};
     template <class Graph, class PropertyTag>
-    class vertex_property_map {
-    public:
-      typedef typename vertex_property_type<Graph>::type Property;
-      typedef typename graph_tag_or_void<Graph>::type graph_tag;
-      typedef typename vertex_property_selector<graph_tag>::type Selector;
-      typedef typename Selector::template bind_<Graph,Property,PropertyTag>
-        Bind;
-    public:
-      typedef typename Bind::type type;
-      typedef typename Bind::const_type const_type;
-    };
-
-    // This selects the kind of property map, whether is maps from
-    // edges or from vertices.
-    //
-    // It is overly complicated because it's a workaround for
-    // partial specialization.
-    struct choose_vertex_property_map {
-      template <class Graph, class Property>
-      struct bind_ {
-        typedef vertex_property_map<Graph, Property> type;
-      };
-    };
-    struct choose_edge_property_map {
-      template <class Graph, class Property>
-      struct bind_ {
-        typedef edge_property_map<Graph, Property> type;
-      };
-    };
-    template <class Kind>
-    struct property_map_kind_selector {
-      // VC++ gets confused if this isn't defined, even though
-      // this never gets used.
-      typedef choose_vertex_property_map type;
-    };
-    template <> struct property_map_kind_selector<vertex_property_tag> {
-      typedef choose_vertex_property_map type;
-    };
-    template <> struct property_map_kind_selector<edge_property_tag> {
-      typedef choose_edge_property_map type;
-    };
+    struct vertex_property_map
+      : vertex_property_selector<
+          typename graph_tag_or_void<Graph>::type
+        >::type::template bind_<
+                            Graph,
+                            typename vertex_property_type<Graph>::type,
+                            PropertyTag>
+      {};
   } // namespace detail
 
-  template <class Graph, class Property>
-  struct property_map {
-  // private:
-    typedef typename property_kind<Property>::type Kind;
-    typedef typename detail::property_map_kind_selector<Kind>::type Selector;
-    typedef typename Selector::template bind_<Graph, Property> Bind;
-    typedef typename Bind::type Map;
-  public:
-    typedef typename Map::type type;
-    typedef typename Map::const_type const_type;
-  };
+  template <class Graph, class Property, class Enable = void>
+  struct property_map:
+    mpl::if_<
+      is_same<typename detail::property_kind_from_graph<Graph, Property>::type, edge_property_tag>,
+      detail::edge_property_map<Graph, Property>,
+      detail::vertex_property_map<Graph, Property> >::type
+  {};
 
   // shortcut for accessing the value type of the property map
   template <class Graph, class Property>
@@ -266,20 +228,12 @@ namespace boost {
   class graph_property {
   public:
     typedef typename property_value<
-      typename Graph::graph_property_type, Property
+      typename boost::graph_property_type<Graph>::type, Property
     >::type type;
   };
 
-  template <class Graph>
-  class vertex_property {
-  public:
-    typedef typename Graph::vertex_property_type type;
-  };
-  template <class Graph>
-  class edge_property {
-  public:
-    typedef typename Graph::edge_property_type type;
-  };
+  template <typename Graph> struct vertex_property: vertex_property_type<Graph> {};
+  template <typename Graph> struct edge_property: edge_property_type<Graph> {};
 
   template <typename Graph>
   class degree_property_map
@@ -353,7 +307,7 @@ namespace boost {
   >
   make_container_vertex_map(RandomAccessContainer& c, const PropertyGraph& g)
   {
-    assert(c.size() >= num_vertices(g));
+    BOOST_ASSERT(c.size() >= num_vertices(g));
     return make_iterator_vertex_map(c.begin(), g);
   }
 
@@ -369,9 +323,6 @@ namespace boost {
     return make_iterator_vertex_map(c.begin());
   }
 
-#if defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-#  define BOOST_GRAPH_NO_BUNDLED_PROPERTIES
-#endif
 
 #if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590)) && !defined (BOOST_GRAPH_NO_BUNDLED_PROPERTIES)
 // This compiler cannot define a partial specialization based on a
@@ -380,99 +331,6 @@ namespace boost {
 #  define BOOST_GRAPH_NO_BUNDLED_PROPERTIES
 #endif
 
-#ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES
-  template<typename Graph, typename Descriptor, typename Bundle, typename T>
-  struct bundle_property_map
-    : put_get_helper<T&, bundle_property_map<Graph, Descriptor, Bundle, T> >
-  {
-    typedef Descriptor key_type;
-    typedef typename remove_const<T>::type value_type;
-    typedef T& reference;
-    typedef lvalue_property_map_tag category;
-
-    bundle_property_map() { }
-    bundle_property_map(Graph* g_, T Bundle::* pm_) : g(g_), pm(pm_) {}
-
-    reference operator[](key_type k) const { return (*g)[k].*pm; }
-  private:
-    Graph* g;
-    T Bundle::* pm;
-  };
-
-  namespace detail {
-    template<typename VertexBundle, typename EdgeBundle, typename Bundle>
-      struct is_vertex_bundle
-      : mpl::and_<is_convertible<VertexBundle*, Bundle*>,
-                  mpl::and_<mpl::not_<is_void<VertexBundle> >,
-                            mpl::not_<is_same<VertexBundle, no_property> > > >
-      { };
-  }
-
-  // Specialize the property map template to generate bundled property maps.
-  template <typename Graph, typename T, typename Bundle>
-  struct property_map<Graph, T Bundle::*>
-  {
-  private:
-    typedef graph_traits<Graph> traits;
-    typedef typename Graph::vertex_bundled vertex_bundled;
-    typedef typename Graph::edge_bundled edge_bundled;
-    typedef typename mpl::if_c<(detail::is_vertex_bundle<vertex_bundled, edge_bundled, Bundle>::value),
-                       typename traits::vertex_descriptor,
-                       typename traits::edge_descriptor>::type
-      descriptor;
-    typedef typename mpl::if_c<(detail::is_vertex_bundle<vertex_bundled, edge_bundled, Bundle>::value),
-                       vertex_bundled,
-                       edge_bundled>::type
-      actual_bundle;
-
-  public:
-    typedef bundle_property_map<Graph, descriptor, actual_bundle, T> type;
-    typedef bundle_property_map<const Graph, descriptor, actual_bundle, const T>
-      const_type;
-  };
-#endif
-
-// These metafunctions help implement the process of determining the vertex
-// and edge properties of a graph.
-namespace graph_detail {
-    template<typename Retag>
-    struct retagged_property {
-        typedef typename Retag::type type;
-    };
-
-    // Search the normalized PropList (as returned by retagged<>::type) for
-    // the given bundle. Return the type error if no such bundle can be found.
-    template <typename PropList, typename Bundle>
-    struct retagged_bundle {
-      typedef typename property_value<PropList, Bundle>::type Value;
-      typedef typename mpl::if_<
-        is_same<Value, detail::error_property_not_found>, no_bundle, Value
-      >::type type;
-    };
-
-    template<typename Prop, typename Bundle>
-    class normal_property {
-      // Normalize the property into a property list.
-      typedef detail::retag_property_list<Bundle, Prop> List;
-    public:
-      // Extract the normalized property and bundle types.
-      typedef typename retagged_property<List>::type property;
-      typedef typename retagged_bundle<property, Bundle>::type bundle;
-    };
-
-    template<typename Prop>
-    struct graph_prop : normal_property<Prop, graph_bundle_t>
-    { };
-
-    template<typename Prop>
-    struct vertex_prop : normal_property<Prop, vertex_bundle_t>
-    { };
-
-    template<typename Prop>
-    struct edge_prop : normal_property<Prop, edge_bundle_t>
-    { };
-} // namespace graph_detail
-
 // NOTE: These functions are declared, but never defined since they need to
 // be overloaded by graph implementations. However, we need them to be
 // declared for the functions below.
@@ -495,17 +353,11 @@ get_property(Graph& g) {
 
 template<typename Graph>
 inline typename graph_property<Graph, graph_bundle_t>::type const&
-get_property(Graph const& g) {
+get_property(const Graph& g) {
   return get_property(g, graph_bundle);
 }
 #endif
 
 } // namespace boost
 
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-// Stay out of the way of the concept checking class
-# undef Graph
-# undef RandomAccessIterator
-#endif
-
-#endif /* BOOST_GRAPH_PROPERTIES_HPPA */
+#endif /* BOOST_GRAPH_PROPERTIES_HPP */
diff --git a/include/boost/graph/property_maps/constant_property_map.hpp b/include/boost/graph/property_maps/constant_property_map.hpp
index dd2461e7e..9d83ea18c 100644
--- a/include/boost/graph/property_maps/constant_property_map.hpp
+++ b/include/boost/graph/property_maps/constant_property_map.hpp
@@ -54,6 +54,39 @@ inline constant_property_map<Key, Value>
 make_constant_property(const Value& value)
 { return constant_property_map<Key, Value>(value); }
 
+/**
+ * Same as above, but pretends to be writable as well.
+ */
+template <typename Key, typename Value>
+struct constant_writable_property_map {
+    typedef Key key_type;
+    typedef Value value_type;
+    typedef Value& reference;
+    typedef boost::read_write_property_map_tag category;
+
+    constant_writable_property_map()
+        : m_value()
+    { }
+
+    constant_writable_property_map(const value_type &value)
+        : m_value(value)
+    { }
+
+    constant_writable_property_map(const constant_writable_property_map& copy)
+        : m_value(copy.m_value)
+    { }
+
+    friend Value get(const constant_writable_property_map& me, Key) {return me.m_value;}
+    friend void put(const constant_writable_property_map&, Key, Value) {}
+
+    value_type m_value;
+};
+
+template <typename Key, typename Value>
+inline constant_writable_property_map<Key, Value>
+make_constant_writable_property(const Value& value)
+{ return constant_writable_property_map<Key, Value>(value); }
+
 } /* namespace boost */
 
 #endif
diff --git a/include/boost/graph/property_maps/null_property_map.hpp b/include/boost/graph/property_maps/null_property_map.hpp
index f6273481b..09ff55e34 100644
--- a/include/boost/graph/property_maps/null_property_map.hpp
+++ b/include/boost/graph/property_maps/null_property_map.hpp
@@ -29,7 +29,7 @@ namespace boost
 
     // The null_property_map<K,V> only has a put() function.
     template <typename K, typename V>
-    void put(null_property_map<K,V>& pm, const K& key, const V& value)
+    void put(null_property_map<K,V>& /*pm*/, const K& /*key*/, const V& /*value*/)
     { }
 
     // A helper function for intantiating null property maps.
diff --git a/include/boost/graph/push_relabel_max_flow.hpp b/include/boost/graph/push_relabel_max_flow.hpp
index fdea7a7e6..10215ff16 100644
--- a/include/boost/graph/push_relabel_max_flow.hpp
+++ b/include/boost/graph/push_relabel_max_flow.hpp
@@ -11,7 +11,7 @@
 #define BOOST_PUSH_RELABEL_MAX_FLOW_HPP
 
 #include <boost/config.hpp>
-#include <cassert>
+#include <boost/assert.hpp>
 #include <vector>
 #include <list>
 #include <iosfwd>
@@ -266,7 +266,7 @@ namespace boost {
       // but it is called "discharge" in the paper and in hi_pr.c.
       void discharge(vertex_descriptor u)
       {
-        assert(get(excess_flow, u) > 0);
+        BOOST_ASSERT(get(excess_flow, u) > 0);
         while (1) {
           out_edge_iterator ai, ai_end;
           for (boost::tie(ai, ai_end) = current[u]; ai != ai_end; ++ai) {
@@ -450,7 +450,7 @@ namespace boost {
         for (boost::tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter) {
           u = *u_iter;
           put(color, u, ColorTraits::white());
-          parent[u] = u;
+          parent[get(index, u)] = u;
           current[u] = out_edges(u, g);
         }
         // eliminate flow cycles and topologically order the vertices
@@ -468,7 +468,7 @@ namespace boost {
                   vertex_descriptor v = target(a, g);
                   if (get(color, v) == ColorTraits::white()) {
                     put(color, v, ColorTraits::gray());
-                    parent[v] = u;
+                    parent[get(index, v)] = u;
                     u = v;
                     break;
                   } else if (get(color, v) == ColorTraits::gray()) {
@@ -523,12 +523,12 @@ namespace boost {
                     bos_null = false;
                     tos = u;
                   } else {
-                    topo_next[u] = tos;
+                    topo_next[get(index, u)] = tos;
                     tos = u;
                   }
                 }
                 if (u != r) {
-                  u = parent[u];
+                  u = parent[get(index, u)];
                   ++current[u].first;
                 } else
                   break;
@@ -540,7 +540,7 @@ namespace boost {
         // return excess flows
         // note that the sink is not on the stack
         if (! bos_null) {
-          for (u = tos; u != bos; u = topo_next[u]) {
+          for (u = tos; u != bos; u = topo_next[get(index, u)]) {
             boost::tie(ai, a_end) = out_edges(u, g);
             while (get(excess_flow, u) > 0 && ai != a_end) {
               if (get(capacity, *ai) == 0 && is_residual_edge(*ai))
@@ -550,8 +550,8 @@ namespace boost {
           }
           // do the bottom
           u = bos;
-          ai = out_edges(u, g).first;
-          while (get(excess_flow, u) > 0) {
+          boost::tie(ai, a_end) = out_edges(u, g);
+          while (get(excess_flow, u) > 0 && ai != a_end) {
             if (get(capacity, *ai) == 0 && is_residual_edge(*ai))
               push_flow(*ai);
             ++ai;
@@ -703,8 +703,8 @@ namespace boost {
     
     algo.convert_preflow_to_flow();
     
-    assert(algo.is_flow());
-    assert(algo.is_optimal());
+    BOOST_ASSERT(algo.is_flow());
+    BOOST_ASSERT(algo.is_optimal());
     
     return flow;
   } // push_relabel_max_flow()
diff --git a/include/boost/graph/r_c_shortest_paths.hpp b/include/boost/graph/r_c_shortest_paths.hpp
index 37bf3f347..afa50cf08 100644
--- a/include/boost/graph/r_c_shortest_paths.hpp
+++ b/include/boost/graph/r_c_shortest_paths.hpp
@@ -13,6 +13,8 @@
 #include <vector>
 
 #include <boost/graph/graph_traits.hpp>
+#include <boost/graph/iteration_macros.hpp>
+#include <boost/property_map/property_map.hpp>
 
 namespace boost {
 
@@ -34,7 +36,8 @@ struct r_c_shortest_paths_label
     pred_edge( ed ), 
     resident_vertex( vd ), 
     b_is_dominated( false ), 
-    b_is_processed( false )
+    b_is_processed( false ),
+    b_is_valid( true )
   {}
   r_c_shortest_paths_label& operator=( const r_c_shortest_paths_label& other )
   {
@@ -51,6 +54,7 @@ struct r_c_shortest_paths_label
   const typename graph_traits<Graph>::vertex_descriptor resident_vertex;
   bool b_is_dominated;
   bool b_is_processed;
+  bool b_is_valid;
 }; // r_c_shortest_paths_label
 
 template<class Graph, class Resource_Container>
@@ -58,6 +62,7 @@ inline bool operator==
 ( const r_c_shortest_paths_label<Graph, Resource_Container>& l1, 
   const r_c_shortest_paths_label<Graph, Resource_Container>& l2 )
 {
+  assert (l1.b_is_valid && l2.b_is_valid);
   return 
     l1.cumulated_resource_consumption == l2.cumulated_resource_consumption;
 }
@@ -67,6 +72,7 @@ inline bool operator!=
 ( const r_c_shortest_paths_label<Graph, Resource_Container>& l1, 
   const r_c_shortest_paths_label<Graph, Resource_Container>& l2 )
 {
+  assert (l1.b_is_valid && l2.b_is_valid);
   return 
     !( l1 == l2 );
 }
@@ -76,6 +82,7 @@ inline bool operator<
 ( const r_c_shortest_paths_label<Graph, Resource_Container>& l1, 
   const r_c_shortest_paths_label<Graph, Resource_Container>& l2 )
 {
+  assert (l1.b_is_valid && l2.b_is_valid);
   return 
     l1.cumulated_resource_consumption < l2.cumulated_resource_consumption;
 }
@@ -85,6 +92,7 @@ inline bool operator>
 ( const r_c_shortest_paths_label<Graph, Resource_Container>& l1, 
   const r_c_shortest_paths_label<Graph, Resource_Container>& l2 )
 {
+  assert (l1.b_is_valid && l2.b_is_valid);
   return 
     l2.cumulated_resource_consumption < l1.cumulated_resource_consumption;
 }
@@ -94,6 +102,7 @@ inline bool operator<=
 ( const r_c_shortest_paths_label<Graph, Resource_Container>& l1, 
   const r_c_shortest_paths_label<Graph, Resource_Container>& l2 )
 {
+  assert (l1.b_is_valid && l2.b_is_valid);
   return 
     l1 < l2 || l1 == l2;
 }
@@ -103,6 +112,7 @@ inline bool operator>=
 ( const r_c_shortest_paths_label<Graph, Resource_Container>& l1, 
   const r_c_shortest_paths_label<Graph, Resource_Container>& l2 )
 {
+  assert (l1.b_is_valid && l2.b_is_valid);
   return l2 < l1 || l1 == l2;
 }
 
@@ -185,7 +195,7 @@ void r_c_shortest_paths_dispatch
   pareto_optimal_resource_containers.clear();
   pareto_optimal_solutions.clear();
 
-  unsigned long i_label_num = 0;
+  size_t i_label_num = 0;
   typedef 
     typename 
       Label_Allocator::template rebind
@@ -213,18 +223,40 @@ void r_c_shortest_paths_dispatch
 
   Splabel splabel_first_label = Splabel( first_label );
   unprocessed_labels.push( splabel_first_label );
-  std::vector<std::list<Splabel> > vec_vertex_labels( num_vertices( g ) );
-  vec_vertex_labels[vertex_index_map[s]].push_back( splabel_first_label );
-  std::vector<typename std::list<Splabel>::iterator> 
-    vec_last_valid_positions_for_dominance( num_vertices( g ) );
-  for( int i = 0; i < static_cast<int>( num_vertices( g ) ); ++i )
-    vec_last_valid_positions_for_dominance[i] = vec_vertex_labels[i].begin();
-  std::vector<int> vec_last_valid_index_for_dominance( num_vertices( g ), 0 );
+  std::vector<std::list<Splabel> > vec_vertex_labels_data( num_vertices( g ) );
+  iterator_property_map<typename std::vector<std::list<Splabel> >::iterator,
+                        VertexIndexMap>
+    vec_vertex_labels(vec_vertex_labels_data.begin(), vertex_index_map);
+  vec_vertex_labels[s].push_back( splabel_first_label );
+  typedef
+    std::vector<typename std::list<Splabel>::iterator> 
+    vec_last_valid_positions_for_dominance_data_type;
+  vec_last_valid_positions_for_dominance_data_type
+    vec_last_valid_positions_for_dominance_data( num_vertices( g ) );
+  iterator_property_map<
+      typename vec_last_valid_positions_for_dominance_data_type::iterator,
+      VertexIndexMap>
+    vec_last_valid_positions_for_dominance
+      (vec_last_valid_positions_for_dominance_data.begin(),
+       vertex_index_map);
+  BGL_FORALL_VERTICES_T(v, g, Graph) {
+    put(vec_last_valid_positions_for_dominance, v, vec_vertex_labels[v].begin());
+  }
+  std::vector<size_t> vec_last_valid_index_for_dominance_data( num_vertices( g ), 0 );
+  iterator_property_map<std::vector<size_t>::iterator, VertexIndexMap>
+    vec_last_valid_index_for_dominance
+      (vec_last_valid_index_for_dominance_data.begin(), vertex_index_map);
   std::vector<bool> 
-    b_vec_vertex_already_checked_for_dominance( num_vertices( g ), false );
-  while( unprocessed_labels.size() )
+    b_vec_vertex_already_checked_for_dominance_data( num_vertices( g ), false );
+  iterator_property_map<std::vector<bool>::iterator, VertexIndexMap>
+    b_vec_vertex_already_checked_for_dominance
+      (b_vec_vertex_already_checked_for_dominance_data.begin(),
+       vertex_index_map);
+
+  while( !unprocessed_labels.empty()  && vis.on_enter_loop(unprocessed_labels, g) )
   {
     Splabel cur_label = unprocessed_labels.top();
+    assert (cur_label->b_is_valid);
     unprocessed_labels.pop();
     vis.on_label_popped( *cur_label, g );
     // an Splabel object in unprocessed_labels and the respective Splabel 
@@ -239,14 +271,16 @@ void r_c_shortest_paths_dispatch
     // if there is a chance that extending the 
     // label leads to new undominated labels, which in turn is possible only 
     // if the label to be extended is undominated
+    assert (cur_label->b_is_valid);
     if( !cur_label->b_is_dominated )
     {
-      int i_cur_resident_vertex_num = cur_label->resident_vertex;
+      typename boost::graph_traits<Graph>::vertex_descriptor
+        i_cur_resident_vertex = cur_label->resident_vertex;
       std::list<Splabel>& list_labels_cur_vertex = 
-        vec_vertex_labels[i_cur_resident_vertex_num];
-      if( static_cast<int>( list_labels_cur_vertex.size() ) >= 2 
-          && vec_last_valid_index_for_dominance[i_cur_resident_vertex_num] 
-               < static_cast<int>( list_labels_cur_vertex.size() ) )
+        get(vec_vertex_labels, i_cur_resident_vertex);
+      if( list_labels_cur_vertex.size() >= 2 
+          && vec_last_valid_index_for_dominance[i_cur_resident_vertex] 
+               < list_labels_cur_vertex.size() )
       {
         typename std::list<Splabel>::iterator outer_iter = 
           list_labels_cur_vertex.begin();
@@ -254,14 +288,14 @@ void r_c_shortest_paths_dispatch
         while( outer_iter != list_labels_cur_vertex.end() )
         {
           Splabel cur_outer_splabel = *outer_iter;
+          assert (cur_outer_splabel->b_is_valid);
           typename std::list<Splabel>::iterator inner_iter = outer_iter;
           if( !b_outer_iter_at_or_beyond_last_valid_pos_for_dominance 
               && outer_iter == 
-                   vec_last_valid_positions_for_dominance
-                     [i_cur_resident_vertex_num] )
+                   get(vec_last_valid_positions_for_dominance,
+                       i_cur_resident_vertex) )
             b_outer_iter_at_or_beyond_last_valid_pos_for_dominance = true;
-          if( !b_vec_vertex_already_checked_for_dominance
-                [i_cur_resident_vertex_num] 
+          if( !get(b_vec_vertex_already_checked_for_dominance, i_cur_resident_vertex)
               || b_outer_iter_at_or_beyond_last_valid_pos_for_dominance )
           {
             ++inner_iter;
@@ -269,14 +303,15 @@ void r_c_shortest_paths_dispatch
           else
           {
             inner_iter = 
-              vec_last_valid_positions_for_dominance
-                [i_cur_resident_vertex_num];
+              get(vec_last_valid_positions_for_dominance,
+                  i_cur_resident_vertex);
             ++inner_iter;
           }
           bool b_outer_iter_erased = false;
           while( inner_iter != list_labels_cur_vertex.end() )
           {
             Splabel cur_inner_splabel = *inner_iter;
+            assert (cur_inner_splabel->b_is_valid);
             if( dominance( cur_outer_splabel->
                              cumulated_resource_consumption, 
                            cur_inner_splabel->
@@ -287,6 +322,7 @@ void r_c_shortest_paths_dispatch
               list_labels_cur_vertex.erase( buf );
               if( cur_inner_splabel->b_is_processed )
               {
+                cur_inner_splabel->b_is_valid = false;
                 l_alloc.destroy( cur_inner_splabel.get() );
                 l_alloc.deallocate( cur_inner_splabel.get(), 1 );
               }
@@ -305,8 +341,10 @@ void r_c_shortest_paths_dispatch
               ++outer_iter;
               list_labels_cur_vertex.erase( buf );
               b_outer_iter_erased = true;
+              assert (cur_outer_splabel->b_is_valid);
               if( cur_outer_splabel->b_is_processed )
               {
+                cur_outer_splabel->b_is_valid = false;
                 l_alloc.destroy( cur_outer_splabel.get() );
                 l_alloc.deallocate( cur_outer_splabel.get(), 1 );
               }
@@ -318,34 +356,38 @@ void r_c_shortest_paths_dispatch
           if( !b_outer_iter_erased )
             ++outer_iter;
         }
-        if( static_cast<int>( list_labels_cur_vertex.size() ) > 1 )
-          vec_last_valid_positions_for_dominance[i_cur_resident_vertex_num] = 
-            (--(list_labels_cur_vertex.end()));
+        if( list_labels_cur_vertex.size() > 1 )
+          put(vec_last_valid_positions_for_dominance, i_cur_resident_vertex,
+            (--(list_labels_cur_vertex.end())));
         else
-          vec_last_valid_positions_for_dominance[i_cur_resident_vertex_num] = 
-            list_labels_cur_vertex.begin();
-        b_vec_vertex_already_checked_for_dominance
-          [i_cur_resident_vertex_num] = true;
-        vec_last_valid_index_for_dominance[i_cur_resident_vertex_num] = 
-          static_cast<int>( list_labels_cur_vertex.size() ) - 1;
+          put(vec_last_valid_positions_for_dominance, i_cur_resident_vertex,
+            list_labels_cur_vertex.begin());
+        put(b_vec_vertex_already_checked_for_dominance,
+            i_cur_resident_vertex, true);
+        put(vec_last_valid_index_for_dominance, i_cur_resident_vertex,
+          list_labels_cur_vertex.size() - 1);
       }
     }
+    assert (b_all_pareto_optimal_solutions || cur_label->b_is_valid);
     if( !b_all_pareto_optimal_solutions && cur_label->resident_vertex == t )
     {
       // the devil don't sleep
       if( cur_label->b_is_dominated )
       {
+        cur_label->b_is_valid = false;
         l_alloc.destroy( cur_label.get() );
         l_alloc.deallocate( cur_label.get(), 1 );
       }
       while( unprocessed_labels.size() )
       {
         Splabel l = unprocessed_labels.top();
+        assert (l->b_is_valid);
         unprocessed_labels.pop();
         // delete only dominated labels, because nondominated labels are 
         // deleted at the end of the function
         if( l->b_is_dominated )
         {
+          l->b_is_valid = false;
           l_alloc.destroy( l.get() );
           l_alloc.deallocate( l.get(), 1 );
         }
@@ -383,6 +425,7 @@ void r_c_shortest_paths_dispatch
         if( !b_feasible )
         {
           vis.on_label_not_feasible( *new_label, g );
+          new_label->b_is_valid = false;
           l_alloc.destroy( new_label );
           l_alloc.deallocate( new_label, 1 );
         }
@@ -392,7 +435,7 @@ void r_c_shortest_paths_dispatch
             ref_new_label = *new_label;
           vis.on_label_feasible( ref_new_label, g );
           Splabel new_sp_label( new_label );
-          vec_vertex_labels[vertex_index_map[new_sp_label->resident_vertex]].
+          vec_vertex_labels[new_sp_label->resident_vertex].
             push_back( new_sp_label );
           unprocessed_labels.push( new_sp_label );
         }
@@ -400,16 +443,18 @@ void r_c_shortest_paths_dispatch
     }
     else
     {
+      assert (cur_label->b_is_valid);
       vis.on_label_dominated( *cur_label, g );
+      cur_label->b_is_valid = false;
       l_alloc.destroy( cur_label.get() );
       l_alloc.deallocate( cur_label.get(), 1 );
     }
   }
-  std::list<Splabel> dsplabels = vec_vertex_labels[vertex_index_map[t]];
+  std::list<Splabel> dsplabels = get(vec_vertex_labels, t);
   typename std::list<Splabel>::const_iterator csi = dsplabels.begin();
   typename std::list<Splabel>::const_iterator csi_end = dsplabels.end();
   // if d could be reached from o
-  if( dsplabels.size() )
+  if( !dsplabels.empty() )
   {
     for( ; csi != csi_end; ++csi )
     {
@@ -417,12 +462,14 @@ void r_c_shortest_paths_dispatch
         cur_pareto_optimal_path;
       const r_c_shortest_paths_label<Graph, Resource_Container>* p_cur_label = 
         (*csi).get();
+      assert (p_cur_label->b_is_valid);
       pareto_optimal_resource_containers.
         push_back( p_cur_label->cumulated_resource_consumption );
       while( p_cur_label->num != 0 )
       {
         cur_pareto_optimal_path.push_back( p_cur_label->pred_edge );
         p_cur_label = p_cur_label->p_pred_label;
+        assert (p_cur_label->b_is_valid);
       }
       pareto_optimal_solutions.push_back( cur_pareto_optimal_path );
       if( !b_all_pareto_optimal_solutions )
@@ -430,13 +477,13 @@ void r_c_shortest_paths_dispatch
     }
   }
 
-  int i_size = static_cast<int>( vec_vertex_labels.size() );
-  for( int i = 0; i < i_size; ++i )
-  {
+  BGL_FORALL_VERTICES_T(i, g, Graph) {
     const std::list<Splabel>& list_labels_cur_vertex = vec_vertex_labels[i];
     csi_end = list_labels_cur_vertex.end();
     for( csi = list_labels_cur_vertex.begin(); csi != csi_end; ++csi )
     {
+      assert ((*csi)->b_is_valid);
+      (*csi)->b_is_valid = false;
       l_alloc.destroy( (*csi).get() );
       l_alloc.deallocate( (*csi).get(), 1 );
     }
@@ -458,6 +505,8 @@ struct default_r_c_shortest_paths_visitor
   void on_label_dominated( const Label&, const Graph& ) {}
   template<class Label, class Graph>
   void on_label_not_dominated( const Label&, const Graph& ) {}
+  template<class Queue, class Graph>             
+  bool on_enter_loop(const Queue& queue, const Graph& graph) {return true;}
 }; // default_r_c_shortest_paths_visitor
 
 
@@ -559,8 +608,10 @@ void r_c_shortest_paths
                                dominance, 
                                la, 
                                vis );
-  pareto_optimal_solution = pareto_optimal_solutions[0];
-  pareto_optimal_resource_container = pareto_optimal_resource_containers[0];
+  if (!pareto_optimal_solutions.empty()) {
+    pareto_optimal_solution = pareto_optimal_solutions[0];
+    pareto_optimal_resource_container = pareto_optimal_resource_containers[0];
+  }
 }
 
 // third overload:
@@ -644,8 +695,10 @@ void r_c_shortest_paths
                                dominance, 
                                default_r_c_shortest_paths_allocator(), 
                                default_r_c_shortest_paths_visitor() );
-  pareto_optimal_solution = pareto_optimal_solutions[0];
-  pareto_optimal_resource_container = pareto_optimal_resource_containers[0];
+  if (!pareto_optimal_solutions.empty()) {
+    pareto_optimal_solution = pareto_optimal_solutions[0];
+    pareto_optimal_resource_container = pareto_optimal_resource_containers[0];
+  }
 }
 // r_c_shortest_paths
 
@@ -673,7 +726,7 @@ void check_r_c_path( const Graph& g,
                      typename graph_traits<Graph>::edge_descriptor& 
                        ed_last_extended_arc )
 {
-  int i_size_ed_vec_path = static_cast<int>( ed_vec_path.size() );
+  size_t i_size_ed_vec_path = ed_vec_path.size();
   std::vector<typename graph_traits<Graph>::edge_descriptor> buf_path;
   if( i_size_ed_vec_path == 0 )
     b_feasible = true;
@@ -683,9 +736,9 @@ void check_r_c_path( const Graph& g,
         || target( ed_vec_path[0], g ) == source( ed_vec_path[1], g ) )
       buf_path = ed_vec_path;
     else
-      for( int i = i_size_ed_vec_path - 1; i >= 0; --i )
-        buf_path.push_back( ed_vec_path[i] );
-    for( int i = 0; i < i_size_ed_vec_path - 1; ++i )
+      for( size_t i = i_size_ed_vec_path ; i > 0; --i )
+        buf_path.push_back( ed_vec_path[i - 1] );
+    for( size_t i = 0; i < i_size_ed_vec_path - 1; ++i )
     {
       if( target( buf_path[i], g ) != source( buf_path[i + 1], g ) )
       {
@@ -701,7 +754,7 @@ void check_r_c_path( const Graph& g,
   b_correctly_extended = false;
   Resource_Container current_resource_levels = initial_resource_levels;
   actual_final_resource_levels = current_resource_levels;
-  for( int i = 0; i < i_size_ed_vec_path; ++i )
+  for( size_t i = 0; i < i_size_ed_vec_path; ++i )
   {
     ed_last_extended_arc = buf_path[i];
     b_feasible = ref( g, 
diff --git a/include/boost/graph/random.hpp b/include/boost/graph/random.hpp
index c79c9c68f..f0153b2c4 100644
--- a/include/boost/graph/random.hpp
+++ b/include/boost/graph/random.hpp
@@ -26,7 +26,7 @@
 #include <boost/type_traits/is_convertible.hpp>
 
 #include <iostream>
-#include <cassert>
+#include <boost/assert.hpp>
 
 namespace boost {
 
@@ -86,8 +86,6 @@ namespace boost {
   template <typename Graph, typename WeightMap, typename RandomNumGen>
   typename graph_traits<Graph>::edge_descriptor
   weighted_random_out_edge(Graph& g, typename graph_traits<Graph>::vertex_descriptor src, WeightMap weight, RandomNumGen& gen) {
-    typedef graph_traits<Graph> gt;
-    typedef typename gt::vertex_descriptor vertex_descriptor;
     typedef typename property_traits<WeightMap>::value_type weight_type;
     weight_type weight_sum(0);
     BGL_FORALL_OUTEDGES_T(src, e, g, Graph) {weight_sum += get(weight, e);}
@@ -104,7 +102,7 @@ namespace boost {
         chosen_weight -= w;
       }
     }
-    assert (false); // Should not get here
+    BOOST_ASSERT (false); // Should not get here
   }
 
   namespace detail {
@@ -125,6 +123,7 @@ namespace boost {
      bool self_edges = false)
   {
     typedef graph_traits<MutableGraph> Traits;
+    typedef typename Traits::edge_descriptor edge_t;
     typedef typename Traits::vertices_size_type v_size_t;
     typedef typename Traits::edges_size_type e_size_t;
     typedef typename Traits::vertex_descriptor vertex_descriptor;
@@ -149,12 +148,23 @@ namespace boost {
       for (v_size_t i = 0; i < V; ++i)
         add_vertex(g);
 
-      for (e_size_t j = 0; j < E; ++j) {
+      e_size_t not_inserted_counter = 0; /* Number of edge insertion failures */
+      e_size_t num_vertices_squared = num_vertices(g) * num_vertices(g);
+      for (e_size_t j = 0; j < E; /* Increment in body */) {
         vertex_descriptor a = random_vertex(g, gen), b;
         do {
           b = random_vertex(g, gen);
         } while (self_edges == false && a == b);
-        add_edge(a, b, g);
+        edge_t e; bool inserted;
+        boost::tie(e, inserted) = add_edge(a, b, g);
+        if (inserted) {
+          ++j;
+        } else {
+          ++not_inserted_counter;
+        }
+        if (not_inserted_counter >= num_vertices_squared) {
+          return; /* Rather than looping forever on complete graph */
+        }
       }
     }
   }
@@ -191,15 +201,24 @@ namespace boost {
     for (v_size_t i = 0; i < V; ++i)
       *vertex_out++ = add_vertex(g);
 
-    for (e_size_t j = 0; j < E; ++j) {
+    e_size_t not_inserted_counter = 0; /* Number of edge insertion failures */
+    e_size_t num_vertices_squared = num_vertices(g) * num_vertices(g);
+    for (e_size_t j = 0; j < E; /* Increment in body */) {
       vertex_t a = random_vertex(g, gen), b;
       do {
         b = random_vertex(g, gen);
       } while (self_edges == false && a == b);
       edge_t e; bool inserted;
       boost::tie(e, inserted) = add_edge(a, b, g);
-      if (inserted)
+      if (inserted) {
         *edge_out++ = std::make_pair(source(e, g), target(e, g));
+        ++j;
+      } else {
+        ++not_inserted_counter;
+      }
+      if (not_inserted_counter >= num_vertices_squared) {
+        return; /* Rather than looping forever on complete graph */
+      }
     }
   }
 
diff --git a/include/boost/graph/random_spanning_tree.hpp b/include/boost/graph/random_spanning_tree.hpp
index 7e36388fc..76dc7f2b9 100644
--- a/include/boost/graph/random_spanning_tree.hpp
+++ b/include/boost/graph/random_spanning_tree.hpp
@@ -11,6 +11,7 @@
 #define BOOST_GRAPH_RANDOM_SPANNING_TREE_HPP
 
 #include <vector>
+#include <boost/assert.hpp>
 #include <boost/graph/loop_erased_random_walk.hpp>
 #include <boost/graph/random.hpp>
 #include <boost/graph/iteration_macros.hpp>
@@ -32,9 +33,8 @@ namespace boost {
     template <typename Graph, typename PredMap, typename ColorMap, typename NextEdge>
     void random_spanning_tree_internal(const Graph& g, typename graph_traits<Graph>::vertex_descriptor s, PredMap pred, ColorMap color, NextEdge next_edge) {
       typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor;
-      typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor;
 
-      assert (num_vertices(g) >= 1); // g must also be undirected (or symmetric) and connected
+      BOOST_ASSERT (num_vertices(g) >= 1); // g must also be undirected (or symmetric) and connected
 
       typedef color_traits<typename property_traits<ColorMap>::value_type> color_gen;
       BGL_FORALL_VERTICES_T(v, g, Graph) put(color, v, color_gen::white());
@@ -53,7 +53,7 @@ namespace boost {
              ++i) {
           typename std::vector<vertex_descriptor>::const_reverse_iterator j = i;
           ++j;
-          assert (get(color, *j) == color_gen::gray());
+          BOOST_ASSERT (get(color, *j) == color_gen::gray());
           put(color, *j, color_gen::black());
           put(pred, *j, *i);
         }
diff --git a/include/boost/graph/read_dimacs.hpp b/include/boost/graph/read_dimacs.hpp
index b19c81392..0297744c8 100644
--- a/include/boost/graph/read_dimacs.hpp
+++ b/include/boost/graph/read_dimacs.hpp
@@ -45,7 +45,6 @@ int read_dimacs_max_flow_internal(Graph& g,
   const int NODE_FIELDS = 2;    /* no of fields in node line  */
   const int P_FIELDS = 3;       /* no of fields in problem line */
 
-  typedef typename graph_traits<Graph>::vertices_size_type vertices_size_type;
   typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor;
   typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor;
 
@@ -90,7 +89,7 @@ int read_dimacs_max_flow_internal(Graph& g,
   const int EN20 = 19;
   const int EN22 = 20;
 
-  static char *err_message[] =
+  static const char *err_message[] =
   {
     /* 0*/    "more than one problem line.",
     /* 1*/    "wrong number of parameters in the problem line.",
@@ -281,8 +280,7 @@ int read_dimacs_max_flow_internal(Graph& g,
   std::printf ( "\nline %ld of input - %s\n",
                 no_lines, err_message[err_no] );
 
-  std::exit (1);
-  return (0); /* to avoid warning */
+  return -1;
 }
 /* --------------------   end of parser  -------------------*/
 
diff --git a/include/boost/graph/relax.hpp b/include/boost/graph/relax.hpp
index 1d2250a80..e3866df48 100644
--- a/include/boost/graph/relax.hpp
+++ b/include/boost/graph/relax.hpp
@@ -22,9 +22,13 @@ namespace boost {
     template <class T>
     struct closed_plus
     {
+      const T inf;
+
+      closed_plus() : inf((std::numeric_limits<T>::max)()) { }
+      closed_plus(T inf) : inf(inf) { }
+
       T operator()(const T& a, const T& b) const {
         using namespace std;
-       const T inf = (std::numeric_limits<T>::max)();
        if (a == inf) return inf;
        if (b == inf) return inf;
        return a + b;
@@ -45,20 +49,30 @@ namespace boost {
       Vertex u = source(e, g), v = target(e, g);
       typedef typename property_traits<DistanceMap>::value_type D;
       typedef typename property_traits<WeightMap>::value_type W;
-      D d_u = get(d, u), d_v = get(d, v);
-      W w_e = get(w, e);
+      const D d_u = get(d, u);
+      const D d_v = get(d, v);
+      const W& w_e = get(w, e);
       
-      // The redundant gets in the return statements are to ensure that extra
-      // floating-point precision in x87 registers does not lead to relax()
-      // returning true when the distance did not actually change.
+      // The seemingly redundant comparisons after the distance puts are to
+      // ensure that extra floating-point precision in x87 registers does not
+      // lead to relax() returning true when the distance did not actually
+      // change.
       if ( compare(combine(d_u, w_e), d_v) ) {
         put(d, v, combine(d_u, w_e));
-        put(p, v, u);
-        return compare(get(d, v), d_v);
+        if (compare(get(d, v), d_v)) {
+          put(p, v, u);
+          return true;
+        } else {
+          return false;
+        }
       } else if (is_undirected && compare(combine(d_v, w_e), d_u)) {
         put(d, u, combine(d_v, w_e));
-        put(p, u, v);
-        return compare(get(d, u), d_u);
+        if (compare(get(d, u), d_u)) {
+          put(p, u, v);
+          return true;
+        } else {
+          return false;
+        }
       } else
         return false;
     }
diff --git a/include/boost/graph/reverse_graph.hpp b/include/boost/graph/reverse_graph.hpp
index 60de2b0ee..24eb1c7c0 100644
--- a/include/boost/graph/reverse_graph.hpp
+++ b/include/boost/graph/reverse_graph.hpp
@@ -8,25 +8,82 @@
 
 #include <boost/graph/adjacency_iterator.hpp>
 #include <boost/graph/properties.hpp>
+#include <boost/iterator/transform_iterator.hpp>
 #include <boost/tuple/tuple.hpp>
 #include <boost/type_traits.hpp>
 #include <boost/mpl/if.hpp>
 
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-// Stay out of the way of the concept checking class
-# define BidirectionalGraph BidirectionalGraph_
-#endif
-
 namespace boost {
 
 struct reverse_graph_tag { };
 
   namespace detail {
 
+    template <typename EdgeDesc>
+    class reverse_graph_edge_descriptor {
+      public:
+      EdgeDesc underlying_descx; // Odd name is because this needs to be public but shouldn't be exposed to users anymore
+
+      private:
+      typedef EdgeDesc base_descriptor_type;
+
+      public:
+      explicit reverse_graph_edge_descriptor(const EdgeDesc& underlying_descx = EdgeDesc())
+        : underlying_descx(underlying_descx) {}
+
+      friend bool operator==(const reverse_graph_edge_descriptor& a, const reverse_graph_edge_descriptor& b) {
+        return a.underlying_descx == b.underlying_descx;
+      }
+      friend bool operator!=(const reverse_graph_edge_descriptor& a, const reverse_graph_edge_descriptor& b) {
+        return a.underlying_descx != b.underlying_descx;
+      }
+      friend bool operator<(const reverse_graph_edge_descriptor& a, const reverse_graph_edge_descriptor& b) {
+        return a.underlying_descx < b.underlying_descx;
+      }
+      friend bool operator>(const reverse_graph_edge_descriptor& a, const reverse_graph_edge_descriptor& b) {
+        return a.underlying_descx > b.underlying_descx;
+      }
+      friend bool operator<=(const reverse_graph_edge_descriptor& a, const reverse_graph_edge_descriptor& b) {
+        return a.underlying_descx <= b.underlying_descx;
+      }
+      friend bool operator>=(const reverse_graph_edge_descriptor& a, const reverse_graph_edge_descriptor& b) {
+        return a.underlying_descx >= b.underlying_descx;
+      }
+    };
+
+    template <typename EdgeDesc>
+    struct reverse_graph_edge_descriptor_maker {
+      typedef reverse_graph_edge_descriptor<EdgeDesc> result_type;
+
+      reverse_graph_edge_descriptor<EdgeDesc> operator()(const EdgeDesc& ed) const {
+        return reverse_graph_edge_descriptor<EdgeDesc>(ed);
+      }
+    };
+
+    template <typename EdgeDesc, typename Iter>
+    std::pair<transform_iterator<reverse_graph_edge_descriptor_maker<EdgeDesc>, Iter>,
+              transform_iterator<reverse_graph_edge_descriptor_maker<EdgeDesc>, Iter> >
+    reverse_edge_iter_pair(const std::pair<Iter, Iter>& ip) {
+      return std::make_pair(make_transform_iterator(ip.first, reverse_graph_edge_descriptor_maker<EdgeDesc>()),
+                            make_transform_iterator(ip.second, reverse_graph_edge_descriptor_maker<EdgeDesc>()));
+    }
+
+    // Get the underlying descriptor from a vertex or edge descriptor
+    template <typename Desc>
+    struct get_underlying_descriptor_from_reverse_descriptor {
+      typedef Desc type;
+      static Desc convert(const Desc& d) {return d;}
+    };
+    template <typename Desc>
+    struct get_underlying_descriptor_from_reverse_descriptor<reverse_graph_edge_descriptor<Desc> > {
+      typedef Desc type;
+      static Desc convert(const reverse_graph_edge_descriptor<Desc>& d) {return d.underlying_descx;}
+    };
+
     template <bool isEdgeList> struct choose_rev_edge_iter { };
     template <> struct choose_rev_edge_iter<true> {
       template <class G> struct bind_ {
-        typedef typename graph_traits<G>::edge_iterator type;
+        typedef transform_iterator<reverse_graph_edge_descriptor_maker<typename graph_traits<G>::edge_descriptor>, typename graph_traits<G>::edge_iterator> type;
       };
     };
     template <> struct choose_rev_edge_iter<false> {
@@ -43,27 +100,29 @@ class reverse_graph {
     typedef graph_traits<BidirectionalGraph> Traits;
  public:
     typedef BidirectionalGraph base_type;
+    typedef GraphRef base_ref_type;
 
     // Constructor
     reverse_graph(GraphRef g) : m_g(g) {}
+    // Conversion from reverse_graph on non-const reference to one on const reference
+    reverse_graph(const reverse_graph<BidirectionalGraph, BidirectionalGraph&>& o): m_g(o.m_g) {}
 
     // Graph requirements
     typedef typename Traits::vertex_descriptor vertex_descriptor;
-    typedef typename Traits::edge_descriptor edge_descriptor;
+    typedef detail::reverse_graph_edge_descriptor<typename Traits::edge_descriptor> edge_descriptor;
     typedef typename Traits::directed_category directed_category;
     typedef typename Traits::edge_parallel_category edge_parallel_category;
     typedef typename Traits::traversal_category traversal_category;
 
     // IncidenceGraph requirements
-    typedef typename Traits::in_edge_iterator out_edge_iterator;
+    typedef transform_iterator<detail::reverse_graph_edge_descriptor_maker<typename Traits::edge_descriptor>, typename Traits::in_edge_iterator> out_edge_iterator;
     typedef typename Traits::degree_size_type degree_size_type;
 
     // BidirectionalGraph requirements
-    typedef typename Traits::out_edge_iterator in_edge_iterator;
+    typedef transform_iterator<detail::reverse_graph_edge_descriptor_maker<typename Traits::edge_descriptor>, typename Traits::out_edge_iterator> in_edge_iterator;
 
     // AdjacencyGraph requirements
-  typedef typename adjacency_iterator_generator<Self,
-    vertex_descriptor, out_edge_iterator>::type adjacency_iterator;
+    typedef typename adjacency_iterator_generator<Self, vertex_descriptor, out_edge_iterator>::type adjacency_iterator;
 
     // VertexListGraph requirements
     typedef typename Traits::vertex_iterator vertex_iterator;
@@ -79,33 +138,23 @@ class reverse_graph {
 
     typedef reverse_graph_tag graph_tag;
 
-    // Graph, vertex, and edge properties
-    typedef typename graph_property_type<base_type>::type graph_property_type;
-    typedef typename graph_bundle_type<base_type>::type graph_bundled;
-
-    typedef typename vertex_property_type<base_type>::type vertex_property_type;
-    typedef typename vertex_bundle_type<base_type>::type vertex_bundled;
-
-    typedef typename edge_property_type<base_type>::type edge_property_type;
-    typedef typename edge_bundle_type<base_type>::type edge_bundled;
-
 #ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES
     // Bundled properties support
     template<typename Descriptor>
-    typename graph::detail::bundled_result<BidirectionalGraph, Descriptor>::type&
+    typename graph::detail::bundled_result<
+               BidirectionalGraph,
+               typename detail::get_underlying_descriptor_from_reverse_descriptor<Descriptor>::type
+             >::type&
     operator[](Descriptor x)
-    { return m_g[x]; }
+    { return m_g[detail::get_underlying_descriptor_from_reverse_descriptor<Descriptor>::convert(x)]; }
 
     template<typename Descriptor>
-    typename graph::detail::bundled_result<BidirectionalGraph, Descriptor>::type const&
+    typename graph::detail::bundled_result<
+               BidirectionalGraph,
+               typename detail::get_underlying_descriptor_from_reverse_descriptor<Descriptor>::type
+             >::type const&
     operator[](Descriptor x) const
-    { return m_g[x]; }
-
-    graph_bundled& operator[](graph_bundle_t)
-    { return get_property(*this); }
-
-    graph_bundled const& operator[](graph_bundle_t) const
-    { return get_property(*this); }
+    { return m_g[detail::get_underlying_descriptor_from_reverse_descriptor<Descriptor>::convert(x)]; }
 #endif // BOOST_GRAPH_NO_BUNDLED_PROPERTIES
 
     static vertex_descriptor null_vertex()
@@ -128,6 +177,11 @@ struct edge_property_type<reverse_graph<BidirectionalGraph, GraphRef> > {
   typedef typename boost::edge_property_type<BidirectionalGraph>::type type;
 };
 
+template <class BidirectionalGraph, class GraphRef>
+struct graph_property_type<reverse_graph<BidirectionalGraph, GraphRef> > {
+  typedef typename boost::graph_property_type<BidirectionalGraph>::type type;
+};
+
 #ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES
   template<typename Graph, typename GraphRef>
   struct vertex_bundle_type<reverse_graph<Graph, GraphRef> >
@@ -136,6 +190,10 @@ struct edge_property_type<reverse_graph<BidirectionalGraph, GraphRef> > {
   template<typename Graph, typename GraphRef>
   struct edge_bundle_type<reverse_graph<Graph, GraphRef> >
     : edge_bundle_type<Graph> { };
+
+  template<typename Graph, typename GraphRef>
+  struct graph_bundle_type<reverse_graph<Graph, GraphRef> >
+    : graph_bundle_type<Graph> { };
 #endif // BOOST_GRAPH_NO_BUNDLED_PROPERTIES
 
 template <class BidirectionalGraph>
@@ -165,16 +223,16 @@ std::pair<typename reverse_graph<BidirectionalGraph>::edge_iterator,
           typename reverse_graph<BidirectionalGraph>::edge_iterator>
 edges(const reverse_graph<BidirectionalGraph,GRef>& g)
 {
-    return edges(g.m_g);
+    return detail::reverse_edge_iter_pair<typename graph_traits<BidirectionalGraph>::edge_descriptor>(edges(g.m_g));
 }
 
 template <class BidirectionalGraph, class GRef>
-inline std::pair<typename graph_traits<BidirectionalGraph>::in_edge_iterator,
-                 typename graph_traits<BidirectionalGraph>::in_edge_iterator>
+inline std::pair<typename reverse_graph<BidirectionalGraph>::out_edge_iterator,
+                 typename reverse_graph<BidirectionalGraph>::out_edge_iterator>
 out_edges(const typename graph_traits<BidirectionalGraph>::vertex_descriptor u,
           const reverse_graph<BidirectionalGraph,GRef>& g)
 {
-    return in_edges(u, g.m_g);
+    return detail::reverse_edge_iter_pair<typename graph_traits<BidirectionalGraph>::edge_descriptor>(in_edges(u, g.m_g));
 }
 
 template <class BidirectionalGraph, class GRef>
@@ -208,22 +266,24 @@ vertex(const typename graph_traits<BidirectionalGraph>::vertices_size_type v,
 }
 
 template <class BidirectionalGraph, class GRef>
-inline std::pair<typename graph_traits<BidirectionalGraph>::edge_descriptor,
-                 bool>
+inline std::pair< typename graph_traits<reverse_graph<BidirectionalGraph,GRef> >::edge_descriptor,
+                  bool>
 edge(const typename graph_traits<BidirectionalGraph>::vertex_descriptor u,
      const typename graph_traits<BidirectionalGraph>::vertex_descriptor v,
      const reverse_graph<BidirectionalGraph,GRef>& g)
 {
-    return edge(v, u, g.m_g);
+    typedef typename graph_traits<BidirectionalGraph>::edge_descriptor underlying_edge_descriptor;
+    std::pair<underlying_edge_descriptor, bool> e = edge(v, u, g.m_g);
+    return std::make_pair(detail::reverse_graph_edge_descriptor<underlying_edge_descriptor>(e.first), e.second);
 }
 
 template <class BidirectionalGraph, class GRef>
-inline std::pair<typename graph_traits<BidirectionalGraph>::out_edge_iterator,
-                 typename graph_traits<BidirectionalGraph>::out_edge_iterator>
+inline std::pair<typename reverse_graph<BidirectionalGraph>::in_edge_iterator,
+                 typename reverse_graph<BidirectionalGraph>::in_edge_iterator>
 in_edges(const typename graph_traits<BidirectionalGraph>::vertex_descriptor u,
          const reverse_graph<BidirectionalGraph,GRef>& g)
 {
-    return out_edges(u, g.m_g);
+    return detail::reverse_edge_iter_pair<typename graph_traits<BidirectionalGraph>::edge_descriptor>(out_edges(u, g.m_g));
 }
 
 template <class BidirectionalGraph, class GRef>
@@ -250,85 +310,191 @@ in_degree(const typename graph_traits<BidirectionalGraph>::vertex_descriptor u,
 
 template <class Edge, class BidirectionalGraph, class GRef>
 inline typename graph_traits<BidirectionalGraph>::vertex_descriptor
-source(const Edge& e, const reverse_graph<BidirectionalGraph,GRef>& g)
+source(const detail::reverse_graph_edge_descriptor<Edge>& e, const reverse_graph<BidirectionalGraph,GRef>& g)
 {
-    return target(e, g.m_g);
+    return target(e.underlying_descx, g.m_g);
 }
 
 template <class Edge, class BidirectionalGraph, class GRef>
 inline typename graph_traits<BidirectionalGraph>::vertex_descriptor
-target(const Edge& e, const reverse_graph<BidirectionalGraph,GRef>& g)
+target(const detail::reverse_graph_edge_descriptor<Edge>& e, const reverse_graph<BidirectionalGraph,GRef>& g)
 {
-    return source(e, g.m_g);
+    return source(e.underlying_descx, g.m_g);
 }
 
 
 namespace detail {
 
-  struct reverse_graph_vertex_property_selector {
-    template <class ReverseGraph, class Property, class Tag>
-    struct bind_ {
-      typedef typename ReverseGraph::base_type Graph;
-      typedef property_map<Graph, Tag> PMap;
-      typedef typename PMap::type type;
-      typedef typename PMap::const_type const_type;
-    };
-  };
-
-  struct reverse_graph_edge_property_selector {
-    template <class ReverseGraph, class Property, class Tag>
-    struct bind_ {
-      typedef typename ReverseGraph::base_type Graph;
-      typedef property_map<Graph, Tag> PMap;
-      typedef typename PMap::type type;
-      typedef typename PMap::const_type const_type;
-    };
+  template <typename PM>
+  struct reverse_graph_edge_property_map {
+    private:
+    PM underlying_pm;
+
+    public:
+    typedef reverse_graph_edge_descriptor<typename property_traits<PM>::key_type> key_type;
+    typedef typename property_traits<PM>::value_type value_type;
+    typedef typename property_traits<PM>::reference reference;
+    typedef typename property_traits<PM>::category category;
+
+    explicit reverse_graph_edge_property_map(const PM& pm): underlying_pm(pm) {}
+
+    friend reference
+    get(const reverse_graph_edge_property_map& m,
+        const key_type& e) {
+      return get(m.underlying_pm, e.underlying_descx);
+    }
+
+    friend void
+    put(const reverse_graph_edge_property_map& m,
+        const key_type& e,
+        const value_type& v) {
+      put(m.underlying_pm, e.underlying_descx, v);
+    }
+
+    reference operator[](const key_type& k) const {
+      return (this->underlying_pm)[k.underlying_descx];
+    }
   };
 
 } // namespace detail
 
-template <>
-struct vertex_property_selector<reverse_graph_tag> {
-  typedef detail::reverse_graph_vertex_property_selector type;
+template <class BidirGraph, class GRef, class Property>
+struct property_map<reverse_graph<BidirGraph, GRef>, Property> {
+  typedef boost::is_same<typename detail::property_kind_from_graph<BidirGraph, Property>::type, edge_property_tag> is_edge_prop;
+  typedef boost::is_const<typename boost::remove_reference<GRef>::type> is_ref_const;
+  typedef typename boost::mpl::if_<
+                     is_ref_const,
+                     typename property_map<BidirGraph, Property>::const_type,
+                     typename property_map<BidirGraph, Property>::type>::type
+    orig_type;
+  typedef typename property_map<BidirGraph, Property>::const_type orig_const_type;
+  typedef typename boost::mpl::if_<is_edge_prop, detail::reverse_graph_edge_property_map<orig_type>, orig_type>::type type;
+  typedef typename boost::mpl::if_<is_edge_prop, detail::reverse_graph_edge_property_map<orig_const_type>, orig_const_type>::type const_type;
 };
 
-template <>
-struct edge_property_selector<reverse_graph_tag> {
-  typedef detail::reverse_graph_edge_property_selector type;
+template <class BidirGraph, class GRef, class Property>
+struct property_map<const reverse_graph<BidirGraph, GRef>, Property> {
+  typedef boost::is_same<typename detail::property_kind_from_graph<BidirGraph, Property>::type, edge_property_tag> is_edge_prop;
+  typedef typename property_map<BidirGraph, Property>::const_type orig_const_type;
+  typedef typename boost::mpl::if_<is_edge_prop, detail::reverse_graph_edge_property_map<orig_const_type>, orig_const_type>::type const_type;
+  typedef const_type type;
 };
 
 template <class BidirGraph, class GRef, class Property>
-typename property_map<reverse_graph<BidirGraph,GRef>, Property>::type
+typename disable_if<
+  is_same<Property, edge_underlying_t>,
+  typename property_map<reverse_graph<BidirGraph,GRef>, Property>::type>::type
 get(Property p, reverse_graph<BidirGraph,GRef>& g)
 {
-  return get(p, g.m_g);
+  return typename property_map<reverse_graph<BidirGraph,GRef>, Property>::type(get(p, g.m_g));
 }
 
 template <class BidirGraph, class GRef, class Property>
-typename property_map<reverse_graph<BidirGraph,GRef>, Property>::const_type
+typename disable_if<
+  is_same<Property, edge_underlying_t>,
+  typename property_map<reverse_graph<BidirGraph,GRef>, Property>::const_type>::type
 get(Property p, const reverse_graph<BidirGraph,GRef>& g)
 {
   const BidirGraph& gref = g.m_g; // in case GRef is non-const
-  return get(p, gref);
+  return typename property_map<reverse_graph<BidirGraph,GRef>, Property>::const_type(get(p, gref));
 }
 
 template <class BidirectionalGraph, class GRef, class Property, class Key>
-typename property_traits<
-  typename property_map<BidirectionalGraph, Property>::const_type
->::value_type
+typename disable_if<
+  is_same<Property, edge_underlying_t>,
+  typename property_traits<
+    typename property_map<reverse_graph<BidirectionalGraph, GRef>, Property>::const_type
+  >::value_type>::type
 get(Property p, const reverse_graph<BidirectionalGraph,GRef>& g, const Key& k)
 {
-  return get(p, g.m_g, k);
+  return get(get(p, g), k);
 }
 
 template <class BidirectionalGraph, class GRef, class Property, class Key, class Value>
 void
-put(Property p, const reverse_graph<BidirectionalGraph,GRef>& g, const Key& k,
+put(Property p, reverse_graph<BidirectionalGraph,GRef>& g, const Key& k,
     const Value& val)
 {
-  put(p, g.m_g, k, val);
+  put(get(p, g), k, val);
 }
 
+// Get the underlying descriptor from a reverse_graph's wrapped edge descriptor
+
+namespace detail {
+  template <class E>
+  struct underlying_edge_desc_map_type {
+    E operator[](const reverse_graph_edge_descriptor<E>& k) const {
+      return k.underlying_descx;
+    }
+  };
+
+  template <class E>
+  E
+  get(underlying_edge_desc_map_type<E> m,
+      const reverse_graph_edge_descriptor<E>& k)
+  {
+    return m[k];
+  }
+}
+
+template <class E>
+struct property_traits<detail::underlying_edge_desc_map_type<E> > {
+  typedef detail::reverse_graph_edge_descriptor<E> key_type;
+  typedef E value_type;
+  typedef const E& reference;
+  typedef readable_property_map_tag category;
+};
+
+template <class Graph, class GRef>
+struct property_map<reverse_graph<Graph, GRef>, edge_underlying_t> {
+  private:
+  typedef typename graph_traits<Graph>::edge_descriptor ed;
+
+  public:
+  typedef detail::underlying_edge_desc_map_type<ed> type;
+  typedef detail::underlying_edge_desc_map_type<ed> const_type;
+};
+
+template <typename T> struct is_reverse_graph: boost::mpl::false_ {};
+template <typename G, typename R> struct is_reverse_graph<reverse_graph<G, R> >: boost::mpl::true_ {};
+
+template <class G>
+typename enable_if<is_reverse_graph<G>,
+  detail::underlying_edge_desc_map_type<typename graph_traits<typename G::base_type>::edge_descriptor> >::type
+get(edge_underlying_t,
+    G&)
+{
+  return detail::underlying_edge_desc_map_type<typename graph_traits<typename G::base_type>::edge_descriptor>();
+}
+
+template <class G>
+typename enable_if<is_reverse_graph<G>, typename graph_traits<typename G::base_type>::edge_descriptor>::type
+get(edge_underlying_t,
+    G&,
+    const typename graph_traits<G>::edge_descriptor& k)
+{
+  return k.underlying_descx;
+}
+
+template <class G>
+typename enable_if<is_reverse_graph<G>, detail::underlying_edge_desc_map_type<typename graph_traits<typename G::base_type>::edge_descriptor> >::type
+get(edge_underlying_t,
+    const G&)
+{
+  return detail::underlying_edge_desc_map_type<typename graph_traits<typename G::base_type>::edge_descriptor>();
+}
+
+template <class G>
+typename enable_if<is_reverse_graph<G>, typename graph_traits<typename G::base_type>::edge_descriptor>::type
+get(edge_underlying_t,
+    const G&,
+    const typename graph_traits<G>::edge_descriptor& k)
+{
+  return k.underlying_descx;
+}
+
+// Access to wrapped graph's graph properties
+
 template<typename BidirectionalGraph, typename GRef, typename Tag,
          typename Value>
 inline void
@@ -351,9 +517,4 @@ get_property(const reverse_graph<BidirectionalGraph,GRef>& g, Tag tag)
 
 } // namespace boost
 
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-// Stay out of the way of the concept checking class
-# undef BidirectionalGraph
-#endif
-
 #endif
diff --git a/include/boost/graph/rmat_graph_generator.hpp b/include/boost/graph/rmat_graph_generator.hpp
index 7060673ce..f083fc555 100644
--- a/include/boost/graph/rmat_graph_generator.hpp
+++ b/include/boost/graph/rmat_graph_generator.hpp
@@ -16,12 +16,13 @@
 #include <queue>
 #include <map>
 #include <boost/shared_ptr.hpp>
+#include <boost/assert.hpp>
 #include <boost/random/uniform_int.hpp>
 #include <boost/random/uniform_01.hpp>
 #include <boost/graph/graph_traits.hpp>
 #include <boost/type_traits/is_base_and_derived.hpp>
 #include <boost/type_traits/is_same.hpp>
-#include <boost/test/floating_point_comparison.hpp>
+// #include <boost/test/floating_point_comparison.hpp>
 
 using boost::shared_ptr;
 using boost::uniform_01;
@@ -138,7 +139,7 @@ namespace boost {
     typedef std::pair<vertices_size_type, vertices_size_type> value_type;
     typedef const value_type& reference;
     typedef const value_type* pointer;
-    typedef void difference_type;
+    typedef std::ptrdiff_t difference_type; // Not used
 
     // No argument constructor, set to terminating condition
     rmat_iterator()
@@ -155,7 +156,7 @@ namespace boost {
     {
       this->gen.reset(new uniform_01<RandomGenerator>(gen));
 
-      assert(boost::test_tools::check_is_close(a + b + c + d, 1., 1.e-5));
+      // BOOST_ASSERT(boost::test_tools::check_is_close(a + b + c + d, 1., 1.e-5));
 
       if (permute_vertices)
         generate_permutation_vector(gen, vertexPermutation, n);
@@ -249,7 +250,7 @@ namespace boost {
     typedef std::pair<vertices_size_type, vertices_size_type> value_type;
     typedef const value_type& reference;
     typedef const value_type* pointer;
-    typedef void difference_type;
+    typedef std::ptrdiff_t difference_type; // Not used
 
     // No argument constructor, set to terminating condition
     sorted_rmat_iterator()
@@ -265,7 +266,7 @@ namespace boost {
         values(sort_pair<vertices_size_type>()), done(false)
 
     {
-      assert(boost::test_tools::check_is_close(a + b + c + d, 1., 1.e-5));
+      // BOOST_ASSERT(boost::test_tools::check_is_close(a + b + c + d, 1., 1.e-5));
 
       this->gen.reset(new uniform_01<RandomGenerator>(gen));
 
@@ -351,7 +352,7 @@ namespace boost {
     typedef std::pair<vertices_size_type, vertices_size_type> value_type;
     typedef const value_type& reference;
     typedef const value_type* pointer;
-    typedef void difference_type;
+    typedef std::ptrdiff_t difference_type; // Not used
 
     // No argument constructor, set to terminating condition
     unique_rmat_iterator()
@@ -366,7 +367,7 @@ namespace boost {
       : gen(), done(false)
 
     {
-      assert(boost::test_tools::check_is_close(a + b + c + d, 1., 1.e-5));
+      // BOOST_ASSERT(boost::test_tools::check_is_close(a + b + c + d, 1., 1.e-5));
 
       this->gen.reset(new uniform_01<RandomGenerator>(gen));
 
@@ -463,7 +464,7 @@ namespace boost {
     typedef std::pair<vertices_size_type, vertices_size_type> value_type;
     typedef const value_type& reference;
     typedef const value_type* pointer;
-    typedef void difference_type;
+    typedef std::ptrdiff_t difference_type; // Not used
 
     // No argument constructor, set to terminating condition
     sorted_unique_rmat_iterator()
@@ -479,7 +480,7 @@ namespace boost {
         values(sort_pair<vertices_size_type>()), done(false)
 
     {
-      assert(boost::test_tools::check_is_close(a + b + c + d, 1., 1.e-5));
+      // BOOST_ASSERT(boost::test_tools::check_is_close(a + b + c + d, 1., 1.e-5));
 
       this->gen.reset(new uniform_01<RandomGenerator>(gen));
 
diff --git a/include/boost/graph/sloan_ordering.hpp b/include/boost/graph/sloan_ordering.hpp
index 781e9c9f4..88ad1b297 100644
--- a/include/boost/graph/sloan_ordering.hpp
+++ b/include/boost/graph/sloan_ordering.hpp
@@ -46,9 +46,9 @@ namespace boost {
   //
   /////////////////////////////////////////////////////////////////////////
   template<class Distance>
-  unsigned RLS_depth(Distance& d)
+  typename Distance::value_type RLS_depth(Distance& d)
   {
-    unsigned h_s = 0;
+    typename Distance::value_type h_s = 0;
     typename Distance::iterator iter;
     
     for (iter = d.begin(); iter != d.end(); ++iter)
@@ -70,14 +70,16 @@ namespace boost {
   //
   /////////////////////////////////////////////////////////////////////////
   template<class Distance, class my_int>
-  unsigned RLS_max_width(Distance& d, my_int depth)
+  typename Distance::value_type RLS_max_width(Distance& d, my_int depth)
   {
+
+      typedef typename Distance::value_type Degree;
     
       //Searching for the maximum width of a level
-      std::vector<unsigned> dummy_width(depth+1, 0);
-      std::vector<unsigned>::iterator my_it;
+      std::vector<Degree> dummy_width(depth+1, 0);
+      typename std::vector<Degree>::iterator my_it;
       typename Distance::iterator iter;
-      unsigned w_max = 0;
+      Degree w_max = 0;
       
       for (iter = d.begin(); iter != d.end(); ++iter)
       {
@@ -117,10 +119,10 @@ namespace boost {
     s = *(vertices(G).first);
     Vertex e = s;
     Vertex i;
-    unsigned my_degree = get(degree, s ); 
-    unsigned dummy, h_i, h_s, w_i, w_e;
+    Degree my_degree = get(degree, s ); 
+    Degree dummy, h_i, h_s, w_i, w_e;
     bool new_start = true;
-    unsigned maximum_degree = 0;
+    Degree maximum_degree = 0;
     
     //Creating a std-vector for storing the distance from the start vertex in dist
     std::vector<typename graph_traits<Graph>::vertices_size_type> dist(num_vertices(G), 0);
@@ -196,7 +198,7 @@ namespace boost {
       
       // step 5
       // Initializing w
-      w_e = (std::numeric_limits<unsigned>::max)();
+      w_e = (std::numeric_limits<Degree>::max)();
       //end 5
       
       
@@ -290,7 +292,7 @@ namespace boost {
     typename property_map<Graph, vertex_index_t>::type index_map = get(vertex_index, g);
     
     //Sets the color and priority to their initial status
-    unsigned cdeg;    
+    Degree cdeg;    
     typename graph_traits<Graph>::vertex_iterator ui, ui_end;
     for (boost::tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui)
     {
diff --git a/include/boost/graph/stanford_graph.hpp b/include/boost/graph/stanford_graph.hpp
index 0bb798c0f..b2d3987d7 100644
--- a/include/boost/graph/stanford_graph.hpp
+++ b/include/boost/graph/stanford_graph.hpp
@@ -318,13 +318,15 @@ namespace boost {
   class sgb_vertex_util_map
     : public boost::put_get_helper<Ref, sgb_vertex_util_map<Tag, Ref> >
   {
+    Tag tag;
   public:
+    explicit sgb_vertex_util_map(Tag tag = Tag()): tag(tag) {}
     typedef boost::lvalue_property_map_tag category;
     typedef typename Tag::type value_type;
     typedef Vertex* key_type;
     typedef Ref reference;
     reference operator[](Vertex* v) const {
-      return get_util_field(v, Tag()); 
+      return get_util_field(v, tag); 
     }
   };
 
@@ -333,17 +335,18 @@ namespace boost {
   class sgb_edge_util_map
     : public boost::put_get_helper<Ref, sgb_edge_util_map<Tag, Ref> >
   {
+    Tag tag;
   public:
+    explicit sgb_edge_util_map(Tag tag = Tag()): tag(tag) {}
     typedef boost::lvalue_property_map_tag category;
     typedef typename Tag::type value_type;
     typedef Vertex* key_type;
     typedef Ref reference;
     reference operator[](const sgb_edge& e) const {
-      return get_util_field(e._arc, Tag()); 
+      return get_util_field(e._arc, tag); 
     }
   };
 
-#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION  
 
   template <class Tag>
   inline sgb_vertex_util_map<Tag, const typename Tag::type&>
@@ -367,7 +370,6 @@ namespace boost {
     return sgb_edge_util_map<Tag, typename Tag::type&>();
   }
 
-#endif // ! BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
   // Edge Length Access
   template <class Ref>
@@ -440,7 +442,6 @@ namespace boost {
     typedef sgb_vertex_name_map const_type;
   };
 
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 
   namespace detail {
     template <class Kind, class PropertyTag>
@@ -506,49 +507,6 @@ namespace boost {
     sgb_##KIND##_util_map< X##_property<T>, T&>()[key] = value; \
   }
 
-#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-#define SGB_UTIL_ACCESSOR_TYPE(KIND,TAG,TYPE) \
-  inline sgb_##KIND##_util_map< TAG<TYPE>, TYPE& > \
-  get(TAG<TYPE>, sgb_graph_ptr&) { \
-    return sgb_##KIND##_util_map< TAG<TYPE>, TYPE& >(); \
-  } \
-  inline sgb_##KIND##_util_map< TAG<TYPE>, const TYPE& > \
-  get(TAG<TYPE>, const sgb_graph_ptr&) { \
-    return sgb_##KIND##_util_map< TAG<TYPE>, const TYPE& >(); \
-  } \
-  inline sgb_##KIND##_util_map< TAG<TYPE>, const TYPE& > \
-  get(TAG<TYPE>, const sgb_const_graph_ptr&) { \
-    return sgb_##KIND##_util_map< TAG<TYPE>, const TYPE& >(); \
-  } \
-  template <class Key> \
-  inline typename sgb_##KIND##_util_map< TAG<TYPE>, const TYPE& >::value_type \
-  get(TAG<TYPE>, const sgb_graph_ptr&, const Key& key) { \
-    return sgb_##KIND##_util_map< TAG<TYPE>, const TYPE& >()[key]; \
-  } \
-  template <class Key> \
-  inline typename sgb_##KIND##_util_map< TAG<TYPE>, const TYPE& >::value_type \
-  get(TAG<TYPE>, const sgb_const_graph_ptr&, const Key& key) { \
-    return sgb_##KIND##_util_map< TAG<TYPE>, const TYPE& >()[key]; \
-  } \
-  template <class Key, class Value> \
-  inline  void \
-  put(TAG<TYPE>, sgb_graph_ptr&, const Key& key, const Value& value) { \
-    sgb_##KIND##_util_map< TAG<TYPE>, TYPE& >()[key] = value; \
-  } \
-  template <> struct property_map<sgb_graph_ptr, TAG<TYPE> > { \
-    typedef sgb_##KIND##_util_map< TAG<TYPE>, TYPE&> type; \
-    typedef sgb_##KIND##_util_map< TAG<TYPE>, const TYPE&> const_type; \
-  }
-
-#define SGB_UTIL_ACCESSOR(KIND,TAG) \
-  SGB_UTIL_ACCESSOR_TYPE(KIND, TAG##_property, Vertex*); \
-  SGB_UTIL_ACCESSOR_TYPE(KIND, TAG##_property, Arc*); \
-  SGB_UTIL_ACCESSOR_TYPE(KIND, TAG##_property, sgb_graph_ptr); \
-  SGB_UTIL_ACCESSOR_TYPE(KIND, TAG##_property, long); \
-  SGB_UTIL_ACCESSOR_TYPE(KIND, TAG##_property, char*);
-
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
   SGB_UTIL_ACCESSOR(vertex, u)
   SGB_UTIL_ACCESSOR(vertex, v)
diff --git a/include/boost/graph/stoer_wagner_min_cut.hpp b/include/boost/graph/stoer_wagner_min_cut.hpp
index 9cd2d0da0..eb5998c71 100644
--- a/include/boost/graph/stoer_wagner_min_cut.hpp
+++ b/include/boost/graph/stoer_wagner_min_cut.hpp
@@ -6,7 +6,7 @@
 #ifndef BOOST_GRAPH_STOER_WAGNER_MIN_CUT_HPP
 #define BOOST_GRAPH_STOER_WAGNER_MIN_CUT_HPP 1
 
-#include <cassert>
+#include <boost/assert.hpp>
 #include <set>
 #include <vector>
 #include <boost/concept_check.hpp>
@@ -15,103 +15,95 @@
 #include <boost/graph/buffer_concepts.hpp>
 #include <boost/graph/exception.hpp>
 #include <boost/graph/graph_traits.hpp>
-#include <boost/graph/iteration_macros.hpp>
+#include <boost/graph/maximum_adjacency_search.hpp>
 #include <boost/graph/named_function_params.hpp>
+#include <boost/graph/one_bit_color_map.hpp>
 #include <boost/graph/detail/d_ary_heap.hpp>
 #include <boost/property_map/property_map.hpp>
 #include <boost/tuple/tuple.hpp>
-#include <boost/typeof/typeof.hpp>
+#include <boost/utility/result_of.hpp>
+#include <boost/graph/iteration_macros.hpp>
 
 namespace boost {
-  
+
   namespace detail {
-    
-    /**
-     * \brief Performs a phase of the Stoer-Wagner min-cut algorithm
-     *
-     * Performs a phase of the Stoer-Wagner min-cut algorithm.
-     *
-     * As described by Stoer & Wagner (1997), a phase is simply a maximum adjacency search
-     * (also called a maximum cardinality search), which results in the selection of two vertices
-     * \em s and \em t, and, as a side product, a minimum <em>s</em>-<em>t</em> cut of
-     * the input graph. Here, the input graph is basically \p g, but some vertices are virtually
-     * assigned to others as a way of viewing \p g as a graph with some sets of
-     * vertices merged together.
-     *
-     * This implementation is a translation of pseudocode by Professor Uri Zwick,
-     * School of Computer Science, Tel Aviv University.
-     *
-     * \pre \p g is a connected, undirected graph
-     * \param[in] g the input graph
-     * \param[in] assignments a read/write property map from each vertex to the vertex that it is assigned to
-     * \param[in] assignedVertices a list of vertices that are assigned to others
-     * \param[in] weights a readable property map from each edge to its weight (a non-negative value)
-     * \param[out] pq a keyed, updatable max-priority queue
-     * \returns a tuple (\em s, \em t, \em w) of the "<em>s</em>" and "<em>t</em>"
-     *     of the minimum <em>s</em>-<em>t</em> cut and the cut weight \em w
-     *     of the minimum <em>s</em>-<em>t</em> cut.
-     * \see http://www.cs.tau.ac.il/~zwick/grad-algo-08/gmc.pdf
-     *
-     * \author Daniel Trebbien
-     * \date 2010-09-11
-     */
-    template <class UndirectedGraph, class VertexAssignmentMap, class WeightMap, class KeyedUpdatablePriorityQueue>
-    boost::tuple<typename boost::graph_traits<UndirectedGraph>::vertex_descriptor, typename boost::graph_traits<UndirectedGraph>::vertex_descriptor, typename boost::property_traits<WeightMap>::value_type>
-    stoer_wagner_phase(const UndirectedGraph& g, VertexAssignmentMap assignments, const std::set<typename boost::graph_traits<UndirectedGraph>::vertex_descriptor>& assignedVertices, WeightMap weights, KeyedUpdatablePriorityQueue& pq) {
-      typedef typename boost::graph_traits<UndirectedGraph>::vertex_descriptor vertex_descriptor;
+    template < typename ParityMap, typename WeightMap, typename IndexMap >
+    class mas_min_cut_visitor : public boost::default_mas_visitor {
+      typedef one_bit_color_map <IndexMap> InternalParityMap;
       typedef typename boost::property_traits<WeightMap>::value_type weight_type;
-      
-      assert(pq.empty());
-      typename KeyedUpdatablePriorityQueue::key_map keys = pq.keys();
-      
-      BGL_FORALL_VERTICES_T(v, g, UndirectedGraph) {
-        if (v == get(assignments, v)) { // foreach u \in V do
-          put(keys, v, weight_type(0));
-          
-          pq.push(v);
-        }
+    public:
+      template < typename Graph >
+      mas_min_cut_visitor(const Graph& g,
+                          ParityMap parity,
+                          weight_type& cutweight,
+                          const WeightMap& weight_map, 
+                          IndexMap index_map)
+        : m_bestParity(parity),
+          m_parity(make_one_bit_color_map(num_vertices(g), index_map)),
+          m_bestWeight(cutweight),
+          m_cutweight(0),
+          m_visited(0),
+          m_weightMap(weight_map)
+      {
+        // set here since the init list sets the reference
+        m_bestWeight = (std::numeric_limits<weight_type>::max)();
       }
-      
-      assert(pq.size() >= 2);
-      
-      vertex_descriptor s, t;
-      weight_type w;
-      while (!pq.empty()) { // while PQ \neq {} do
-        const vertex_descriptor u = pq.top(); // u = extractmax(PQ)
-        w = get(keys, u);
-        pq.pop();
-        
-        s = t; t = u;
-        
-        BGL_FORALL_OUTEDGES_T(u, e, g, UndirectedGraph) { // foreach (u, v) \in E do
-          const vertex_descriptor v = get(assignments, target(e, g));
-          
-          if (pq.contains(v)) { // if v \in PQ then
-            put(keys, v, get(keys, v) + get(weights, e)); // increasekey(PQ, v, wA(v) + w(u, v))
-            pq.update(v);
-          }
+
+      template < typename Vertex, typename Graph >
+      void initialize_vertex(Vertex u, const Graph & g)
+      {
+        typedef typename boost::property_traits<ParityMap>::value_type parity_type;
+        typedef typename boost::property_traits<InternalParityMap>::value_type internal_parity_type;
+
+        put(m_parity, u, internal_parity_type(0));
+        put(m_bestParity, u, parity_type(0));
+      }
+
+      template < typename Edge, typename Graph >
+      void examine_edge(Edge e, const Graph & g)
+      {
+        weight_type w = get(m_weightMap, e);
+
+        // if the target of e is already marked then decrease cutweight
+        // otherwise, increase it
+        if (get(m_parity, boost::target(e, g))) {
+          m_cutweight -= w;
+        } else {
+          m_cutweight += w;
         }
-        
-        typename std::set<vertex_descriptor>::const_iterator assignedVertexIt, assignedVertexEnd = assignedVertices.end();
-        for (assignedVertexIt = assignedVertices.begin(); assignedVertexIt != assignedVertexEnd; ++assignedVertexIt) {
-          const vertex_descriptor uPrime = *assignedVertexIt;
-          
-          if (get(assignments, uPrime) == u) {
-            BGL_FORALL_OUTEDGES_T(uPrime, e, g, UndirectedGraph) { // foreach (u, v) \in E do
-              const vertex_descriptor v = get(assignments, target(e, g));
-              
-              if (pq.contains(v)) { // if v \in PQ then
-                put(keys, v, get(keys, v) + get(weights, e)); // increasekey(PQ, v, wA(v) + w(u, v))
-                pq.update(v);
-              }
-            }
+      }
+
+      template < typename Vertex, typename Graph >
+      void finish_vertex(Vertex u, const Graph & g)
+      {
+        typedef typename boost::property_traits<InternalParityMap>::value_type internal_parity_type;
+
+        ++m_visited;
+        put(m_parity, u, internal_parity_type(1));
+
+        if (m_cutweight < m_bestWeight && m_visited < num_vertices(g)) {
+          m_bestWeight = m_cutweight;
+          BGL_FORALL_VERTICES_T(i, g, Graph) {
+            put(m_bestParity,i, get(m_parity,i));
           }
         }
       }
-      
-      return boost::make_tuple(s, t, w);
-    }
-    
+
+      inline void clear() {
+        m_bestWeight = (std::numeric_limits<weight_type>::max)();
+        m_visited = 0;
+        m_cutweight = 0;
+      }
+
+    private:
+      ParityMap m_bestParity;
+      InternalParityMap m_parity;
+      weight_type& m_bestWeight;
+      weight_type m_cutweight;
+      unsigned m_visited;
+      const WeightMap& m_weightMap;
+    };
+
     /**
      * \brief Computes a min-cut of the input graph
      *
@@ -134,9 +126,54 @@ namespace boost {
      * \author Daniel Trebbien
      * \date 2010-09-11
      */
-    template <class UndirectedGraph, class WeightMap, class ParityMap, class VertexAssignmentMap, class KeyedUpdatablePriorityQueue>
+    template <class UndirectedGraph, class WeightMap, class ParityMap, class VertexAssignmentMap, class KeyedUpdatablePriorityQueue, class IndexMap>
     typename boost::property_traits<WeightMap>::value_type
-    stoer_wagner_min_cut(const UndirectedGraph& g, WeightMap weights, ParityMap parities, VertexAssignmentMap assignments, KeyedUpdatablePriorityQueue& pq) {
+    stoer_wagner_min_cut(const UndirectedGraph& g, WeightMap weights, ParityMap parities, VertexAssignmentMap assignments, KeyedUpdatablePriorityQueue& pq, IndexMap index_map) {
+      typedef typename boost::graph_traits<UndirectedGraph>::vertex_descriptor vertex_descriptor;
+      typedef typename boost::property_traits<WeightMap>::value_type weight_type;
+
+      typename graph_traits<UndirectedGraph>::vertex_iterator u_iter, u_end;
+
+      weight_type bestW = (std::numeric_limits<weight_type>::max)();
+      weight_type bestThisTime = (std::numeric_limits<weight_type>::max)();
+      vertex_descriptor bestStart = boost::graph_traits<UndirectedGraph>::null_vertex();
+
+      detail::mas_min_cut_visitor<ParityMap, WeightMap, IndexMap>
+        vis(g, parities, bestThisTime, weights, index_map);
+
+      // for each node in the graph,
+      for (boost::tie(u_iter, u_end) = vertices(g); u_iter != u_end; ++u_iter) {
+        // run the MAS and find the min cut
+        vis.clear();
+        boost::maximum_adjacency_search(g,
+            boost::weight_map(weights).
+            visitor(vis).
+            root_vertex(*u_iter).
+            vertex_assignment_map(assignments).
+            max_priority_queue(pq));
+        if (bestThisTime < bestW) {
+          bestW = bestThisTime;
+          bestStart = *u_iter;
+        }
+      }
+
+      // Run one more time, starting from the best start location, to
+      // ensure the visitor has the best values.
+      vis.clear();
+      boost::maximum_adjacency_search(g,
+        boost::vertex_assignment_map(assignments).
+        weight_map(weights).
+        visitor(vis).
+        root_vertex(bestStart).
+        max_priority_queue(pq));
+
+      return bestW;
+    }
+  } // end `namespace detail` within `namespace boost`
+
+    template <class UndirectedGraph, class WeightMap, class ParityMap, class VertexAssignmentMap, class KeyedUpdatablePriorityQueue, class IndexMap>
+    typename boost::property_traits<WeightMap>::value_type
+    stoer_wagner_min_cut(const UndirectedGraph& g, WeightMap weights, ParityMap parities, VertexAssignmentMap assignments, KeyedUpdatablePriorityQueue& pq, IndexMap index_map) {
       BOOST_CONCEPT_ASSERT((boost::IncidenceGraphConcept<UndirectedGraph>));
       BOOST_CONCEPT_ASSERT((boost::VertexListGraphConcept<UndirectedGraph>));
       typedef typename boost::graph_traits<UndirectedGraph>::vertex_descriptor vertex_descriptor;
@@ -144,95 +181,68 @@ namespace boost {
       typedef typename boost::graph_traits<UndirectedGraph>::edge_descriptor edge_descriptor;
       BOOST_CONCEPT_ASSERT((boost::Convertible<typename boost::graph_traits<UndirectedGraph>::directed_category, boost::undirected_tag>));
       BOOST_CONCEPT_ASSERT((boost::ReadablePropertyMapConcept<WeightMap, edge_descriptor>));
-      typedef typename boost::property_traits<WeightMap>::value_type weight_type;
+      // typedef typename boost::property_traits<WeightMap>::value_type weight_type;
       BOOST_CONCEPT_ASSERT((boost::WritablePropertyMapConcept<ParityMap, vertex_descriptor>));
-      typedef typename boost::property_traits<ParityMap>::value_type parity_type;
+      // typedef typename boost::property_traits<ParityMap>::value_type parity_type;
       BOOST_CONCEPT_ASSERT((boost::ReadWritePropertyMapConcept<VertexAssignmentMap, vertex_descriptor>));
       BOOST_CONCEPT_ASSERT((boost::Convertible<vertex_descriptor, typename boost::property_traits<VertexAssignmentMap>::value_type>));
       BOOST_CONCEPT_ASSERT((boost::KeyedUpdatableQueueConcept<KeyedUpdatablePriorityQueue>));
-      
+
       vertices_size_type n = num_vertices(g);
       if (n < 2)
         throw boost::bad_graph("the input graph must have at least two vertices.");
       else if (!pq.empty())
         throw std::invalid_argument("the max-priority queue must be empty initially.");
-      
-      std::set<vertex_descriptor> assignedVertices;
-      
-      // initialize `assignments` (all vertices are initially assigned to themselves)
-      BGL_FORALL_VERTICES_T(v, g, UndirectedGraph) {
-        put(assignments, v, v);
-      }
-      
-      vertex_descriptor s, t;
-      weight_type bestW;
-      
-      boost::tie(s, t, bestW) = boost::detail::stoer_wagner_phase(g, assignments, assignedVertices, weights, pq);
-      assert(s != t);
-      BGL_FORALL_VERTICES_T(v, g, UndirectedGraph) {
-        put(parities, v, parity_type(v == t ? 1 : 0));
-      }
-      put(assignments, t, s);
-      assignedVertices.insert(t);
-      --n;
-      
-      for (; n >= 2; --n) {
-        weight_type w;
-        boost::tie(s, t, w) = boost::detail::stoer_wagner_phase(g, assignments, assignedVertices, weights, pq);
-        assert(s != t);
-        
-        if (w < bestW) {
-          BGL_FORALL_VERTICES_T(v, g, UndirectedGraph) {
-            put(parities, v, parity_type(get(assignments, v) == t ? 1 : 0));
-            
-            if (get(assignments, v) == t) // all vertices that were assigned to t are now assigned to s
-              put(assignments, v, s);
-          }
-          
-          bestW = w;
-        } else {
-          BGL_FORALL_VERTICES_T(v, g, UndirectedGraph) {
-            if (get(assignments, v) == t) // all vertices that were assigned to t are now assigned to s
-              put(assignments, v, s);
-          }
-        }
-        put(assignments, t, s);
-        assignedVertices.insert(t);
-      }
-      
-      assert(pq.empty());
-      
-      return bestW;
+
+      return detail::stoer_wagner_min_cut(g, weights,
+                                          parities, assignments, pq, index_map);
     }
-    
-  } // end `namespace detail` within `namespace boost`
-  
-  template <class UndirectedGraph, class WeightMap, class P, class T, class R>
-  inline typename boost::property_traits<WeightMap>::value_type
-  stoer_wagner_min_cut(const UndirectedGraph& g, WeightMap weights, const boost::bgl_named_params<P, T, R>& params) {
-    typedef typename boost::graph_traits<UndirectedGraph>::vertex_descriptor vertex_descriptor;
-    typedef typename std::vector<vertex_descriptor>::size_type heap_container_size_type;
-    typedef typename boost::property_traits<WeightMap>::value_type weight_type;
-    
-    typedef boost::bgl_named_params<P, T, R> params_type;
-    BOOST_GRAPH_DECLARE_CONVERTED_PARAMETERS(params_type, params)
-    
-    BOOST_AUTO(pq, (boost::detail::make_priority_queue_from_arg_pack_gen<boost::graph::keywords::tag::max_priority_queue, weight_type, vertex_descriptor, std::greater<weight_type> >(choose_param(get_param(params, boost::distance_zero_t()), weight_type(0)))(g, arg_pack)));
-    
-    return boost::detail::stoer_wagner_min_cut(g,
-        weights,
-        choose_param(get_param(params, boost::parity_map_t()), boost::dummy_property_map()),
-        boost::detail::make_property_map_from_arg_pack_gen<boost::graph::keywords::tag::vertex_assignment_map, vertex_descriptor>(vertex_descriptor())(g, arg_pack),
-        pq
-      );
-  }
-  
-  template <class UndirectedGraph, class WeightMap>
-  inline typename boost::property_traits<WeightMap>::value_type
-  stoer_wagner_min_cut(const UndirectedGraph& g, WeightMap weights) {
-    return boost::stoer_wagner_min_cut(g, weights, boost::vertex_index_map(get(boost::vertex_index, g)));
+
+namespace graph {
+  namespace detail {
+    template <class UndirectedGraph, class WeightMap>
+    struct stoer_wagner_min_cut_impl {
+      typedef typename boost::property_traits<WeightMap>::value_type result_type;
+      template <typename ArgPack>
+      result_type operator() (const UndirectedGraph& g, WeightMap weights, const ArgPack& arg_pack) const {
+        using namespace boost::graph::keywords;
+        typedef typename boost::graph_traits<UndirectedGraph>::vertex_descriptor vertex_descriptor;
+        typedef typename boost::property_traits<WeightMap>::value_type weight_type;
+
+        typedef boost::detail::make_priority_queue_from_arg_pack_gen<boost::graph::keywords::tag::max_priority_queue, weight_type, vertex_descriptor, std::greater<weight_type> > gen_type;
+
+        gen_type gen(choose_param(get_param(arg_pack, boost::distance_zero_t()), weight_type(0)));
+
+        typename boost::result_of<gen_type(const UndirectedGraph&, const ArgPack&)>::type pq = gen(g, arg_pack);
+
+        return boost::stoer_wagner_min_cut(g,
+          weights,
+          arg_pack [_parity_map | boost::dummy_property_map()],
+          boost::detail::make_property_map_from_arg_pack_gen<tag::vertex_assignment_map, vertex_descriptor>(vertex_descriptor())(g, arg_pack),
+          pq,
+          boost::detail::override_const_property(arg_pack, _vertex_index_map, g, vertex_index)
+        );
+      }
+    };
   }
-  
+  BOOST_GRAPH_MAKE_FORWARDING_FUNCTION(stoer_wagner_min_cut,2,4)
+}
+
+  // Named parameter interface
+  BOOST_GRAPH_MAKE_OLD_STYLE_PARAMETER_FUNCTION(stoer_wagner_min_cut, 2)
+namespace graph {
+    // version without IndexMap kept for backwards compatibility
+    // (but requires vertex_index_t to be defined in the graph)
+    // Place after the macro to avoid compilation errors
+    template <class UndirectedGraph, class WeightMap, class ParityMap, class VertexAssignmentMap, class KeyedUpdatablePriorityQueue>
+    typename boost::property_traits<WeightMap>::value_type
+    stoer_wagner_min_cut(const UndirectedGraph& g, WeightMap weights, ParityMap parities, VertexAssignmentMap assignments, KeyedUpdatablePriorityQueue& pq) {
+
+      return stoer_wagner_min_cut(g, weights,
+                                  parities, assignments, pq,
+                                  get(vertex_index, g));
+    }
+} // end `namespace graph`
 } // end `namespace boost`
 
 #include <boost/graph/iteration_macros_undef.hpp>
diff --git a/include/boost/graph/strong_components.hpp b/include/boost/graph/strong_components.hpp
index 6494283e5..61345bdcb 100644
--- a/include/boost/graph/strong_components.hpp
+++ b/include/boost/graph/strong_components.hpp
@@ -18,6 +18,7 @@
 #include <boost/type_traits/conversion_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/graph/overloading.hpp>
+#include <boost/concept/assert.hpp>
 
 namespace boost {
 
@@ -93,11 +94,11 @@ namespace boost {
        const bgl_named_params<P, T, R>& params)
     {
       typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
-      function_requires< ReadWritePropertyMapConcept<ComponentMap, Vertex> >();
-      function_requires< ReadWritePropertyMapConcept<RootMap, Vertex> >();
+      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<ComponentMap, Vertex> ));
+      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<RootMap, Vertex> ));
       typedef typename property_traits<RootMap>::value_type RootV;
-      function_requires< ConvertibleConcept<RootV, Vertex> >();
-      function_requires< ReadWritePropertyMapConcept<DiscoverTime, Vertex> >();
+      BOOST_CONCEPT_ASSERT(( ConvertibleConcept<RootV, Vertex> ));
+      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<DiscoverTime, Vertex> ));
 
       typename property_traits<ComponentMap>::value_type total = 0;
 
@@ -130,7 +131,7 @@ namespace boost {
 
 
     template <>
-    struct strong_comp_dispatch2<detail::error_property_not_found> {
+    struct strong_comp_dispatch2<param_not_found> {
       template <class Graph, class ComponentMap, class RootMap,
                 class P, class T, class R>
       inline static typename property_traits<ComponentMap>::value_type
@@ -138,7 +139,7 @@ namespace boost {
             ComponentMap comp,
             RootMap r_map,
             const bgl_named_params<P, T, R>& params,
-            detail::error_property_not_found)
+            param_not_found)
       {
         typedef typename graph_traits<Graph>::vertices_size_type size_type;
         size_type       n = num_vertices(g) > 0 ? num_vertices(g) : 1;
@@ -178,7 +179,7 @@ namespace boost {
       }
     };
     template <>
-    struct strong_comp_dispatch1<detail::error_property_not_found> {
+    struct strong_comp_dispatch1<param_not_found> {
 
       template <class Graph, class ComponentMap, 
                 class P, class T, class R>
@@ -186,7 +187,7 @@ namespace boost {
       apply(const Graph& g,
             ComponentMap comp,
             const bgl_named_params<P, T, R>& params,
-            detail::error_property_not_found)
+            param_not_found)
       {
         typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
         typename std::vector<Vertex>::size_type
@@ -282,7 +283,7 @@ namespace boost {
   kosaraju_strong_components(Graph& G, ComponentsMap c,
                              FinishTime finish_time, ColorMap color)
   {
-    function_requires< MutableGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( MutableGraphConcept<Graph> ));
     // ...
     
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
diff --git a/include/boost/graph/subgraph.hpp b/include/boost/graph/subgraph.hpp
index 093da7b03..22706bc61 100644
--- a/include/boost/graph/subgraph.hpp
+++ b/include/boost/graph/subgraph.hpp
@@ -16,14 +16,17 @@
 #include <list>
 #include <vector>
 #include <map>
-#include <cassert>
+#include <boost/assert.hpp>
 #include <boost/graph/graph_traits.hpp>
 #include <boost/graph/graph_mutability_traits.hpp>
 #include <boost/graph/properties.hpp>
 #include <boost/iterator/indirect_iterator.hpp>
 
 #include <boost/static_assert.hpp>
-#include <boost/type_traits/is_same.hpp>
+#include <boost/assert.hpp>
+#include <boost/type_traits.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/or.hpp>
 
 namespace boost {
 
@@ -78,12 +81,12 @@ class subgraph {
     typedef graph_traits<Graph> Traits;
     typedef std::list<subgraph<Graph>*> ChildrenList;
 public:
-// Graph requirements
-typedef typename Traits::vertex_descriptor         vertex_descriptor;
-typedef typename Traits::edge_descriptor           edge_descriptor;
-typedef typename Traits::directed_category         directed_category;
-typedef typename Traits::edge_parallel_category    edge_parallel_category;
-typedef typename Traits::traversal_category        traversal_category;
+    // Graph requirements
+    typedef typename Traits::vertex_descriptor         vertex_descriptor;
+    typedef typename Traits::edge_descriptor           edge_descriptor;
+    typedef typename Traits::directed_category         directed_category;
+    typedef typename Traits::edge_parallel_category    edge_parallel_category;
+    typedef typename Traits::traversal_category        traversal_category;
 
     // IncidenceGraph requirements
     typedef typename Traits::out_edge_iterator         out_edge_iterator;
@@ -102,13 +105,11 @@ typedef typename Traits::traversal_category        traversal_category;
 
     typedef typename Traits::in_edge_iterator          in_edge_iterator;
 
-    typedef typename Graph::edge_property_type         edge_property_type;
-    typedef typename Graph::vertex_property_type       vertex_property_type;
-    typedef typename Graph::vertex_bundled             vertex_bundled;
-    typedef typename Graph::edge_bundled               edge_bundled;
+    typedef typename edge_property_type<Graph>::type   edge_property_type;
+    typedef typename vertex_property_type<Graph>::type vertex_property_type;
     typedef subgraph_tag                               graph_tag;
     typedef Graph                                      graph_type;
-    typedef typename Graph::graph_property_type        graph_property_type;
+    typedef typename graph_property_type<Graph>::type  graph_property_type;
 
     // Create the main graph, the root of the subgraph tree
     subgraph()
@@ -130,15 +131,29 @@ typedef typename Traits::traversal_category        traversal_category;
 
     // copy constructor
     subgraph(const subgraph& x)
-        : m_graph(x.m_graph), m_parent(x.m_parent), m_edge_counter(x.m_edge_counter)
+        : m_parent(x.m_parent), m_edge_counter(x.m_edge_counter)
         , m_global_vertex(x.m_global_vertex), m_global_edge(x.m_global_edge)
     {
-        // Do a deep copy (recursive).
-        for(typename ChildrenList::const_iterator i = x.m_children.begin();
-            i != x.m_children.end(); ++i)
+        if(x.is_root())
         {
-            m_children.push_back(new subgraph<Graph>( **i ));
+         m_graph = x.m_graph;
         }
+        // Do a deep copy (recursive).
+        // Only the root graph is copied, the subgraphs contain
+        // only references to the global vertices they own.
+        typename subgraph<Graph>::children_iterator i,i_end;
+        boost::tie(i,i_end) = x.children();
+        for(; i != i_end; ++i)
+        {         
+         subgraph<Graph> child = this->create_subgraph();
+         child = *i;
+         vertex_iterator vi,vi_end;   
+         boost::tie(vi,vi_end) = vertices(*i);
+         for (;vi!=vi_end;++vi)  
+         {
+          add_vertex(*vi,child);
+         }
+       }
     }
 
 
@@ -181,7 +196,7 @@ typedef typename Traits::traversal_category        traversal_category;
         vertex_descriptor u_local; bool in_subgraph;
         if (is_root()) return u_global;
         boost::tie(u_local, in_subgraph) = this->find_vertex(u_global);
-        assert(in_subgraph == true);
+        BOOST_ASSERT(in_subgraph == true);
         return u_local;
     }
 
@@ -196,12 +211,22 @@ typedef typename Traits::traversal_category        traversal_category;
     std::pair<vertex_descriptor, bool>
     find_vertex(vertex_descriptor u_global) const {
         if (is_root()) return std::make_pair(u_global, true);
-        typename std::map<vertex_descriptor, vertex_descriptor>::const_iterator
-            i = m_local_vertex.find(u_global);
+        typename LocalVertexMap::const_iterator i = m_local_vertex.find(u_global);
         bool valid = i != m_local_vertex.end();
         return std::make_pair((valid ? (*i).second : null_vertex()), valid);
     }
 
+    // Is edge e (of the root graph) contained in this subgraph?
+    // If so, return the matching local edge.
+    std::pair<edge_descriptor, bool>
+    find_edge(edge_descriptor e_global) const {
+        if (is_root()) return std::make_pair(e_global, true);
+        typename LocalEdgeMap::const_iterator i =
+          m_local_edge.find(get(get(edge_index, root().m_graph), e_global));
+        bool valid = i != m_local_edge.end();
+        return std::make_pair((valid ? (*i).second : edge_descriptor()), valid);
+    }
+
     // Return the parent graph.
     subgraph& parent() { return *m_parent; }
     const subgraph& parent() const { return *m_parent; }
@@ -323,9 +348,6 @@ typedef typename Traits::traversal_category        traversal_category;
     }
 };
 
-#ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES
-// TODO: I don't think these are required since the default metafunction
-// returns Graph::vertex_bundled.
 template <typename Graph>
 struct vertex_bundle_type<subgraph<Graph> >
     : vertex_bundle_type<Graph>
@@ -335,7 +357,11 @@ template<typename Graph>
 struct edge_bundle_type<subgraph<Graph> >
     : edge_bundle_type<Graph>
 { };
-#endif // BOOST_GRAPH_NO_BUNDLED_PROPERTIES
+
+template<typename Graph>
+struct graph_bundle_type<subgraph<Graph> >
+    : graph_bundle_type<Graph>
+{ };
 
 //===========================================================================
 // Functions special to the Subgraph Class
@@ -345,8 +371,8 @@ typename subgraph<G>::vertex_descriptor
 add_vertex(typename subgraph<G>::vertex_descriptor u_global,
            subgraph<G>& g)
 {
-    assert(!g.is_root());
-    typename subgraph<G>::vertex_descriptor u_local, v_global, uu_global;
+    BOOST_ASSERT(!g.is_root());
+    typename subgraph<G>::vertex_descriptor u_local, v_global;
     typename subgraph<G>::edge_descriptor e_global;
 
     u_local = add_vertex(g.m_graph);
@@ -371,11 +397,13 @@ add_vertex(typename subgraph<G>::vertex_descriptor u_global,
         typename subgraph<G>::out_edge_iterator ei, ei_end;
         for(boost::tie(vi, vi_end) = vertices(r); vi != vi_end; ++vi) {
             v_global = *vi;
-            if(g.find_vertex(v_global).second)
+            if (v_global == u_global)
+                continue; // don't insert self loops twice!
+            if (!g.find_vertex(v_global).second)
+                continue; // not a subgraph vertex => try next one
             for(boost::tie(ei, ei_end) = out_edges(*vi, r); ei != ei_end; ++ei) {
                 e_global = *ei;
-                uu_global = target(e_global, r);
-                if(uu_global == u_global && g.find_vertex(v_global).second) {
+                if(target(e_global, r) == u_global) {
                     g.local_add_edge(g.global_to_local(v_global), u_local, e_global);
                 }
             }
@@ -615,38 +643,18 @@ namespace detail {
 
     //-------------------------------------------------------------------------
     // implementation of remove_edge(e,g)
-    template <typename Edge, typename Graph>
-    void remove_edge_recur_down(Edge e_global, subgraph<Graph>& g);
 
-    template <typename Edge, typename Children>
+    template <typename G, typename Edge, typename Children>
     void children_remove_edge(Edge e_global, Children& c)
     {
         for(typename Children::iterator i = c.begin(); i != c.end(); ++i) {
-            if((*i)->find_vertex(source(e_global, **i)).second &&
-               (*i)->find_vertex(target(e_global, **i)).second)
-            {
-                remove_edge_recur_down(source(e_global, **i),
-                                       target(e_global, **i),
-                                       **i);
+            std::pair<typename subgraph<G>::edge_descriptor, bool> found =
+              (*i)->find_edge(e_global);
+            if (!found.second) {
+              continue;
             }
-        }
-    }
-
-    template <typename Edge, typename Graph>
-    void remove_edge_recur_down(Edge e_global, subgraph<Graph>& g)
-    {
-        remove_edge(g.global_to_local(e_global), g.m_graph);
-        children_remove_edge(e_global, g.m_children);
-    }
-
-    template <typename Edge, typename Graph>
-    void remove_edge_recur_up(Edge e_global, subgraph<Graph>& g)
-    {
-        if (g.is_root()) {
-            remove_edge(e_global, g.m_graph);
-            children_remove_edge(e_global, g.m_children);
-        } else {
-            remove_edge_recur_up(e_global, *g.m_parent);
+            children_remove_edge<G>(e_global, (*i)->m_children);
+            remove_edge(found.first, (*i)->m_graph);
         }
     }
 
@@ -670,24 +678,45 @@ template <typename G>
 void
 remove_edge(typename subgraph<G>::edge_descriptor e, subgraph<G>& g)
 {
-    if(g.is_root()) {
-        detail::remove_edge_recur_up(e, g);
-    } else {
-        detail::remove_edge_recur_up(g.local_to_global(e), g);
-    }
+    typename subgraph<G>::edge_descriptor e_global = g.local_to_global(e);
+#ifndef NDEBUG
+    std::pair<typename subgraph<G>::edge_descriptor, bool> fe = g.find_edge(e_global);
+    BOOST_ASSERT(fe.second && fe.first == e);
+#endif //NDEBUG
+    subgraph<G> &root = g.root(); // chase to root
+    detail::children_remove_edge<G>(e_global, root.m_children);
+    remove_edge(e_global, root.m_graph); // kick edge from root
 }
 
-// TODO: This is wrong...
+// This is slow, but there may not be a good way to do it safely otherwise
 template <typename Predicate, typename G>
 void
-remove_edge_if(Predicate p, subgraph<G>& g)
-{ remove_edge_if(p, g.m_graph); }
+remove_edge_if(Predicate p, subgraph<G>& g) {
+  while (true) {
+    bool any_removed = false;
+    typedef typename subgraph<G>::edge_iterator ei_type;
+    for (std::pair<ei_type, ei_type> ep = edges(g);
+         ep.first != ep.second; ++ep.first) {
+      if (p(*ep.first)) {
+        any_removed = true;
+        remove_edge(*ep.first, g);
+        break; /* Since iterators may be invalidated */
+      }
+    }
+    if (!any_removed) break;
+  }
+}
 
-// TODO: Ths is wrong
 template <typename G>
 void
-clear_vertex(typename subgraph<G>::vertex_descriptor v, subgraph<G>& g)
-{ clear_vertex(v, g.m_graph); }
+clear_vertex(typename subgraph<G>::vertex_descriptor v, subgraph<G>& g) {
+  while (true) {
+    typedef typename subgraph<G>::out_edge_iterator oei_type;
+    std::pair<oei_type, oei_type> p = out_edges(v, g);
+    if (p.first == p.second) break;
+    remove_edge(*p.first, g);
+  }
+}
 
 namespace detail {
     template <typename G>
@@ -727,10 +756,12 @@ add_vertex(subgraph<G>& g)
 }
 
 
+#if 0
 // TODO: Under Construction
 template <typename G>
 void remove_vertex(typename subgraph<G>::vertex_descriptor u, subgraph<G>& g)
-{ assert(false); }
+{ BOOST_ASSERT(false); }
+#endif
 
 //===========================================================================
 // Functions required by the PropertyGraph concept
@@ -748,7 +779,10 @@ class subgraph_global_property_map
 {
     typedef property_traits<PropertyMap> Traits;
 public:
-    typedef typename Traits::category category;
+    typedef typename mpl::if_<is_const<typename remove_pointer<GraphPtr>::type>,
+                              readable_property_map_tag,
+                              typename Traits::category>::type
+      category;
     typedef typename Traits::value_type value_type;
     typedef typename Traits::key_type key_type;
     typedef typename Traits::reference reference;
@@ -756,18 +790,19 @@ class subgraph_global_property_map
     subgraph_global_property_map()
     { }
 
-    subgraph_global_property_map(GraphPtr g)
-        : m_g(g)
+    subgraph_global_property_map(GraphPtr g, Tag tag)
+        : m_g(g), m_tag(tag)
     { }
 
     reference operator[](key_type e) const {
-        PropertyMap pmap = get(Tag(), m_g->root().m_graph);
+        PropertyMap pmap = get(m_tag, m_g->root().m_graph);
         return m_g->is_root()
             ? pmap[e]
             : pmap[m_g->local_to_global(e)];
     }
 
     GraphPtr m_g;
+    Tag m_tag;
 };
 
 /**
@@ -783,7 +818,10 @@ class subgraph_local_property_map
 {
     typedef property_traits<PropertyMap> Traits;
 public:
-    typedef typename Traits::category category;
+    typedef typename mpl::if_<is_const<typename remove_pointer<GraphPtr>::type>,
+                              readable_property_map_tag,
+                              typename Traits::category>::type
+      category;
     typedef typename Traits::value_type value_type;
     typedef typename Traits::key_type key_type;
     typedef typename Traits::reference reference;
@@ -794,17 +832,18 @@ class subgraph_local_property_map
     subgraph_local_property_map()
     { }
 
-    subgraph_local_property_map(GraphPtr g)
-        : m_g(g)
+    subgraph_local_property_map(GraphPtr g, Tag tag)
+        : m_g(g), m_tag(tag)
     { }
 
     reference operator[](key_type e) const {
         // Get property map on the underlying graph.
-        PropertyMap pmap = get(Tag(), m_g->m_graph);
+        PropertyMap pmap = get(m_tag, m_g->m_graph);
         return pmap[e];
     }
 
     GraphPtr m_g;
+    Tag m_tag;
 };
 
 namespace detail {
@@ -919,139 +958,37 @@ struct edge_property_selector<subgraph_tag> {
     typedef detail::subgraph_property_generator type;
 };
 
-#ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES
-/** @internal
- * This property map implements local or global bundled property access on
- * an underlying graph. The LocalGlobal template template parameter must be
- * one of the local_property or global_property templates.
- */
-template <
-    typename Graph, typename Descriptor, typename Bundle, typename T,
-    template <typename> class LocalGlobal>
-struct subgraph_lg_bundle_property_map
-    : put_get_helper<
-        T&,
-        subgraph_lg_bundle_property_map<Graph, Descriptor, Bundle, T, LocalGlobal>
-    >
-{
-private:
-    typedef LocalGlobal<Descriptor> Wrap;
-public:
-    typedef Descriptor key_type;
-    typedef typename remove_const<T>::type value_type;
-    typedef T& reference;
-    typedef lvalue_property_map_tag category;
-
-    subgraph_lg_bundle_property_map()
-    { }
-
-    subgraph_lg_bundle_property_map(Graph* g, T Bundle::* p)
-        : m_g(g), m_prop(p)
-    { }
-
-    reference operator[](key_type k) const
-    { return (*m_g)[Wrap(k)].*m_prop; }
-
-private:
-    Graph* m_g;
-    T Bundle::* m_prop;
-};
-
-// Specialize the property map template to generate bundled property maps.
-// NOTE: I'm cheating (actually double-dipping) with the local/global subgraph
-// property templates. I'm not using them store descriptors, just specialize
-// the property map template for specific lookups.
-namespace graph_detail {
-    // Help decoding some of the types required for property map definitions.
-    template <typename Graph, typename T, typename Bundle>
-    struct bundled_subgraph_pmap_helper {
-        typedef subgraph<Graph> Subgraph;
-        typedef graph_traits<Subgraph> Traits;
-        typedef typename Subgraph::vertex_bundled VertBundled;
-        typedef typename Subgraph::edge_bundled EdgeBundled;
-
-        // Deduce the descriptor from the template params
-        typedef typename mpl::if_<
-            detail::is_vertex_bundle<VertBundled, EdgeBundled, Bundle>,
-            typename Traits::vertex_descriptor, typename Traits::edge_descriptor
-        >::type Desc;
-
-        // Deduce the bundled property type
-        typedef typename mpl::if_<
-            detail::is_vertex_bundle<VertBundled, EdgeBundled, Bundle>,
-            VertBundled, EdgeBundled
-        >::type Prop;
-    };
-} // namespace graph_detail
-
-template <typename Graph, typename T, typename Bundle>
-struct property_map<subgraph<Graph>, local_property<T Bundle::*> >
-    : graph_detail::bundled_subgraph_pmap_helper<Graph, T, Bundle>
-{
-private:
-    typedef graph_detail::bundled_subgraph_pmap_helper<Graph, T, Bundle> Base;
-    typedef typename Base::Subgraph Subgraph;
-    typedef typename Base::Desc Desc;
-    typedef typename Base::Prop Prop;
-public:
-    typedef subgraph_lg_bundle_property_map<
-        Subgraph, Desc, Prop, T, local_property
-    > type;
-    typedef subgraph_lg_bundle_property_map<
-        Subgraph const, Desc, Prop, T const, local_property
-    > const_type;
-};
-
-template <typename Graph, typename T, typename Bundle>
-struct property_map<subgraph<Graph>, global_property<T Bundle::*> >
-    : graph_detail::bundled_subgraph_pmap_helper<Graph, T, Bundle>
-{
-private:
-    typedef graph_detail::bundled_subgraph_pmap_helper<Graph, T, Bundle> Base;
-    typedef typename Base::Subgraph Subgraph;
-    typedef typename Base::Desc Desc;
-    typedef typename Base::Prop Prop;
-public:
-    typedef subgraph_lg_bundle_property_map<
-        Subgraph, Desc, Prop, T, global_property
-    > type;
-    typedef subgraph_lg_bundle_property_map<
-        Subgraph const, Desc, Prop, T const, global_property
-    > const_type;
-};
-#endif
-
 // ==================================================
 // get(p, g), get(p, g, k), and put(p, g, k, v)
 // ==================================================
 template <typename G, typename Property>
 typename property_map<subgraph<G>, Property>::type
-get(Property, subgraph<G>& g) {
+get(Property p, subgraph<G>& g) {
     typedef typename property_map< subgraph<G>, Property>::type PMap;
-    return PMap(&g);
+    return PMap(&g, p);
 }
 
 template <typename G, typename Property>
 typename property_map<subgraph<G>, Property>::const_type
-get(Property, const subgraph<G>& g) {
+get(Property p, const subgraph<G>& g) {
     typedef typename property_map< subgraph<G>, Property>::const_type PMap;
-    return PMap(&g);
+    return PMap(&g, p);
 }
 
 template <typename G, typename Property, typename Key>
 typename property_traits<
     typename property_map<subgraph<G>, Property>::const_type
 >::value_type
-get(Property, const subgraph<G>& g, const Key& k) {
+get(Property p, const subgraph<G>& g, const Key& k) {
     typedef typename property_map< subgraph<G>, Property>::const_type PMap;
-    PMap pmap(&g);
+    PMap pmap(&g, p);
     return pmap[k];
 }
 
 template <typename G, typename Property, typename Key, typename Value>
-void put(Property, subgraph<G>& g, const Key& k, const Value& val) {
+void put(Property p, subgraph<G>& g, const Key& k, const Value& val) {
     typedef typename property_map< subgraph<G>, Property>::type PMap;
-    PMap pmap(&g);
+    PMap pmap(&g, p);
     pmap[k] = val;
 }
 
@@ -1061,20 +998,20 @@ void put(Property, subgraph<G>& g, const Key& k, const Value& val) {
 // ==================================================
 template <typename G, typename Property>
 typename property_map<subgraph<G>, global_property<Property> >::type
-get(global_property<Property>, subgraph<G>& g) {
+get(global_property<Property> p, subgraph<G>& g) {
     typedef typename property_map<
         subgraph<G>, global_property<Property>
     >::type Map;
-    return Map(&g);
+    return Map(&g, p.value);
 }
 
 template <typename G, typename Property>
 typename property_map<subgraph<G>, global_property<Property> >::const_type
-get(global_property<Property>, const subgraph<G>& g) {
+get(global_property<Property> p, const subgraph<G>& g) {
     typedef typename property_map<
         subgraph<G>, global_property<Property>
     >::const_type Map;
-    return Map(&g);
+    return Map(&g, p.value);
 }
 
 // ==================================================
@@ -1083,112 +1020,22 @@ get(global_property<Property>, const subgraph<G>& g) {
 // ==================================================
 template <typename G, typename Property>
 typename property_map<subgraph<G>, local_property<Property> >::type
-get(local_property<Property>, subgraph<G>& g) {
+get(local_property<Property> p, subgraph<G>& g) {
     typedef typename property_map<
         subgraph<G>, local_property<Property>
     >::type Map;
-    return Map(&g);
+    return Map(&g, p.value);
 }
 
 template <typename G, typename Property>
 typename property_map<subgraph<G>, local_property<Property> >::const_type
-get(local_property<Property>, const subgraph<G>& g) {
+get(local_property<Property> p, const subgraph<G>& g) {
     typedef typename property_map<
         subgraph<G>, local_property<Property>
     >::const_type Map;
-    return Map(&g);
-}
-
-#ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES
-// ==================================================
-// get(bundle(p), g)
-// ==================================================
-
-template<typename G, typename T, typename Bundle>
-inline typename property_map<subgraph<G>, T Bundle::*>::type
-get(T Bundle::* p, subgraph<G>& g) {
-    typedef typename property_map<subgraph<G>, T Bundle::*>::type Map;
-    return Map(&g, p);
-}
-
-template<typename G, typename T, typename Bundle>
-inline typename property_map<subgraph<G>, T Bundle::*>::const_type
-get(T Bundle::* p, subgraph<G> const& g) {
-    typedef typename property_map<subgraph<G>, T Bundle::*>::const_type Map;
-    return Map(&g, p);
-}
-
-template <typename Graph, typename Type, typename Bundle, typename Key>
-inline Type get(Type Bundle::* p, subgraph<Graph> const& g, Key const& k)
-{ return get(get(p, g), k); }
-
-template <typename Graph, typename Type, typename Bundle, typename Key,
-          typename Value>
-inline void put(Type Bundle::* p, Graph& g, Key const& k, Value const& v)
-{ put(get(p, g), k, v); }
-
-// =========================================================
-// Local bundled, get
-
-template<typename G, typename T, typename Bundle>
-inline typename property_map<
-    subgraph<G>, local_property<T Bundle::*>
->::type
-get(local_property<T Bundle::*> p, subgraph<G>& g) {
-    typedef typename property_map<
-        subgraph<G>, local_property<T Bundle::*>
-    >::type Map;
-    return Map(&g, p.value);
-}
-
-template<typename G, typename T, typename Bundle>
-inline typename property_map<
-    subgraph<G>, local_property<T Bundle::*>
->::const_type
-get(local_property<T Bundle::*> p, subgraph<G> const& g) {
-    typedef typename property_map<
-        subgraph<G>, local_property<T Bundle::*>
-    >::const_type Map;
     return Map(&g, p.value);
 }
 
-template <typename Graph, typename Type, typename Bundle, typename Key>
-inline Type get(local_property<Type Bundle::*> p, subgraph<Graph> const& g,
-                Key const& k)
-{ return get(get(p, g), k); }
-
-// =========================================================
-// Global bundled, get
-
-template<typename G, typename T, typename Bundle>
-inline typename property_map<
-    subgraph<G>, global_property<T Bundle::*>
->::type
-get(global_property<T Bundle::*> p, subgraph<G>& g) {
-    typedef typename property_map<
-        subgraph<G>, global_property<T Bundle::*>
-    >::type Map;
-    return Map(&g, p.value);
-}
-
-template<typename G, typename T, typename Bundle>
-inline typename property_map<
-    subgraph<G>, global_property<T Bundle::*>
->::const_type
-get(global_property<T Bundle::*> p, subgraph<G> const& g) {
-    typedef typename property_map<
-        subgraph<G>, global_property<T Bundle::*>
-    >::const_type Map;
-    return Map(&g, p.value);
-}
-
-template <typename Graph, typename Type, typename Bundle, typename Key>
-inline Type get(global_property<Type Bundle::*> p, subgraph<Graph> const& g,
-                Key const& k)
-{ return get(get(p, g), k); }
-
-#endif
-
 template <typename G, typename Tag>
 inline typename graph_property<G, Tag>::type&
 get_property(subgraph<G>& g, Tag tag) {
diff --git a/include/boost/graph/successive_shortest_path_nonnegative_weights.hpp b/include/boost/graph/successive_shortest_path_nonnegative_weights.hpp
new file mode 100644
index 000000000..72b1512c1
--- /dev/null
+++ b/include/boost/graph/successive_shortest_path_nonnegative_weights.hpp
@@ -0,0 +1,261 @@
+//=======================================================================
+// Copyright 2013 University of Warsaw.
+// Authors: Piotr Wygocki 
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//=======================================================================
+//
+//This algorithm is described in "Network Flows: Theory, Algorithms, and Applications"
+// by Ahuja, Magnanti, Orlin.
+
+#ifndef BOOST_GRAPH_SUCCESSIVE_SHORTEST_PATH_HPP
+#define BOOST_GRAPH_SUCCESSIVE_SHORTEST_PATH_HPP 
+
+#include <numeric>
+
+#include <boost/property_map/property_map.hpp>
+#include <boost/graph/graph_traits.hpp>
+#include <boost/graph/graph_concepts.hpp>
+#include <boost/pending/indirect_cmp.hpp>
+#include <boost/pending/relaxed_heap.hpp>
+#include <boost/graph/dijkstra_shortest_paths.hpp>
+#include <boost/graph/properties.hpp>
+#include <boost/graph/iteration_macros.hpp>
+#include <boost/graph/detail/augment.hpp>
+
+namespace boost {
+
+
+namespace detail {
+    
+template <class Graph, class Weight, class Distance, class Reversed>
+class MapReducedWeight : 
+    public put_get_helper<typename property_traits<Weight>::value_type, MapReducedWeight<Graph, Weight, Distance, Reversed> > {
+    typedef graph_traits<Graph> gtraits;
+public:
+    typedef boost::readable_property_map_tag category;
+    typedef typename property_traits<Weight>::value_type value_type;
+    typedef value_type reference;
+    typedef typename gtraits::edge_descriptor key_type;
+    MapReducedWeight(const Graph & g, Weight w, Distance d, Reversed r) : 
+        g_(g), weight_(w), distance_(d), rev_(r) {}
+
+    reference operator[](key_type v) const {
+        return get(distance_, source(v, g_)) - get(distance_,target(v, g_)) + get(weight_, v); 
+    }
+private:
+    const Graph & g_;
+    Weight weight_;
+    Distance distance_;
+    Reversed rev_;
+};
+
+template <class Graph, class Weight, class Distance, class Reversed>
+MapReducedWeight<Graph, Weight, Distance, Reversed> 
+make_mapReducedWeight(const Graph & g, Weight w, Distance d, Reversed r)  {
+    return MapReducedWeight<Graph, Weight, Distance, Reversed>(g, w, d, r);
+}
+
+}//detail
+
+
+template <class Graph, class Capacity, class ResidualCapacity, class Reversed, class Pred, class Weight, class Distance, class Distance2, class VertexIndex>
+void successive_shortest_path_nonnegative_weights(
+        const Graph &g, 
+        typename graph_traits<Graph>::vertex_descriptor s, 
+        typename graph_traits<Graph>::vertex_descriptor t,
+        Capacity capacity,
+        ResidualCapacity residual_capacity,
+        Weight weight, 
+        Reversed rev,
+        VertexIndex index,
+        Pred pred, 
+        Distance distance,
+        Distance2 distance_prev) {
+    filtered_graph<const Graph, is_residual_edge<ResidualCapacity> >
+        gres = detail::residual_graph(g, residual_capacity);
+    typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor;
+    
+    BGL_FORALL_EDGES_T(e, g, Graph) {
+        put(residual_capacity, e, get(capacity, e));
+    }
+
+    BGL_FORALL_VERTICES_T(v, g, Graph) {
+        put(distance_prev, v, 0);
+    }
+
+    while(true) {
+        BGL_FORALL_VERTICES_T(v, g, Graph) {
+            put(pred, v, edge_descriptor());
+        }
+        dijkstra_shortest_paths(gres, s, 
+                weight_map(detail::make_mapReducedWeight(gres, weight, distance_prev, rev)).
+                distance_map(distance).
+                vertex_index_map(index).
+                visitor(make_dijkstra_visitor(record_edge_predecessors(pred, on_edge_relaxed()))));
+
+        if(get(pred, t) == edge_descriptor()) {
+            break;
+        }
+
+        BGL_FORALL_VERTICES_T(v, g, Graph) {
+            put(distance_prev, v, get(distance_prev, v) + get(distance, v));
+        }
+
+        detail::augment(g, s, t, pred, residual_capacity, rev);
+    }
+}
+
+//in this namespace argument dispatching tak place
+namespace detail {
+
+template <class Graph, class Capacity, class ResidualCapacity, class Weight, class Reversed, class Pred, class Distance, class Distance2, class VertexIndex>
+void successive_shortest_path_nonnegative_weights_dispatch3(
+        const Graph &g, 
+        typename graph_traits<Graph>::vertex_descriptor s, 
+        typename graph_traits<Graph>::vertex_descriptor t,
+        Capacity capacity,
+        ResidualCapacity residual_capacity,
+        Weight weight,
+        Reversed rev,
+        VertexIndex index,
+        Pred pred,
+        Distance dist,
+        Distance2 dist_pred) {
+    successive_shortest_path_nonnegative_weights(g, s, t, capacity, residual_capacity, weight, rev, index, pred, dist, dist_pred);
+}
+
+//setting default distance map
+template <class Graph, class Capacity, class ResidualCapacity, class Weight, class Reversed, class Pred, class Distance, class VertexIndex>
+void successive_shortest_path_nonnegative_weights_dispatch3(
+        Graph &g, 
+        typename graph_traits<Graph>::vertex_descriptor s, 
+        typename graph_traits<Graph>::vertex_descriptor t,
+        Capacity capacity,
+        ResidualCapacity residual_capacity,
+        Weight weight,
+        Reversed rev,
+        VertexIndex index,
+        Pred pred,
+        Distance dist,
+        param_not_found) {
+    typedef typename property_traits<Weight>::value_type D;
+
+    std::vector<D> d_map(num_vertices(g));
+
+    successive_shortest_path_nonnegative_weights(g, s, t, capacity, residual_capacity, weight, rev, index, pred, dist,
+                             make_iterator_property_map(d_map.begin(), index));
+}
+
+template <class Graph, class P, class T, class R, class Capacity, class ResidualCapacity, class Weight, class Reversed, class Pred, class Distance, class VertexIndex>
+void successive_shortest_path_nonnegative_weights_dispatch2(
+        Graph &g, 
+        typename graph_traits<Graph>::vertex_descriptor s, 
+        typename graph_traits<Graph>::vertex_descriptor t,
+        Capacity capacity,
+        ResidualCapacity residual_capacity,
+        Weight weight,
+        Reversed rev,
+        VertexIndex index,
+        Pred pred,
+        Distance dist,
+        const bgl_named_params<P, T, R>& params) {
+    successive_shortest_path_nonnegative_weights_dispatch3(g, s, t, capacity, residual_capacity, weight, rev, index, pred, dist, get_param(params, vertex_distance2));
+}
+
+//setting default distance map
+template <class Graph, class P, class T, class R, class Capacity, class ResidualCapacity, class Weight, class Reversed, class Pred, class VertexIndex>
+void successive_shortest_path_nonnegative_weights_dispatch2(
+        Graph &g, 
+        typename graph_traits<Graph>::vertex_descriptor s, 
+        typename graph_traits<Graph>::vertex_descriptor t,
+        Capacity capacity,
+        ResidualCapacity residual_capacity,
+        Weight weight,
+        Reversed rev,
+        VertexIndex index,
+        Pred pred,
+        param_not_found, 
+        const bgl_named_params<P, T, R>& params) {
+    typedef typename property_traits<Weight>::value_type D;
+
+    std::vector<D> d_map(num_vertices(g));
+
+    successive_shortest_path_nonnegative_weights_dispatch3(g, s, t, capacity, residual_capacity, weight, rev, index, pred,
+            make_iterator_property_map(d_map.begin(), index),
+            get_param(params, vertex_distance2));
+}
+
+template <class Graph, class P, class T, class R, class Capacity, class ResidualCapacity, class Weight, class Reversed, class Pred, class VertexIndex>
+void successive_shortest_path_nonnegative_weights_dispatch1(
+        Graph &g, 
+        typename graph_traits<Graph>::vertex_descriptor s, 
+        typename graph_traits<Graph>::vertex_descriptor t,
+        Capacity capacity,
+        ResidualCapacity residual_capacity,
+        Weight weight, 
+        Reversed rev,
+        VertexIndex index,
+        Pred pred,
+        const bgl_named_params<P, T, R>& params) {
+    successive_shortest_path_nonnegative_weights_dispatch2(g, s, t, capacity, residual_capacity, weight,  rev, index, pred,
+                                get_param(params, vertex_distance), params);
+}
+
+//setting default predecessors map
+template <class Graph, class P, class T, class R, class Capacity, class ResidualCapacity, class Weight, class Reversed, class VertexIndex>
+void successive_shortest_path_nonnegative_weights_dispatch1(
+        Graph &g, 
+        typename graph_traits<Graph>::vertex_descriptor s, 
+        typename graph_traits<Graph>::vertex_descriptor t,
+        Capacity capacity,
+        ResidualCapacity residual_capacity,
+        Weight weight, 
+        Reversed rev,
+        VertexIndex index,
+        param_not_found,
+        const bgl_named_params<P, T, R>& params) {
+    typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor;
+    std::vector<edge_descriptor> pred_vec(num_vertices(g));
+
+    successive_shortest_path_nonnegative_weights_dispatch2(g, s, t, capacity, residual_capacity, weight, rev, index, 
+            make_iterator_property_map(pred_vec.begin(), index),
+            get_param(params, vertex_distance), params); 
+}
+
+}//detail
+
+
+template <class Graph, class P, class T, class R>
+void successive_shortest_path_nonnegative_weights(
+        Graph &g, 
+        typename graph_traits<Graph>::vertex_descriptor s, 
+        typename graph_traits<Graph>::vertex_descriptor t,
+        const bgl_named_params<P, T, R>& params) {
+           
+    return detail::successive_shortest_path_nonnegative_weights_dispatch1(g, s, t, 
+           choose_const_pmap(get_param(params, edge_capacity), g, edge_capacity),
+           choose_pmap(get_param(params, edge_residual_capacity), 
+                       g, edge_residual_capacity),
+           choose_const_pmap(get_param(params, edge_weight), g, edge_weight),
+           choose_const_pmap(get_param(params, edge_reverse), g, edge_reverse),
+           choose_const_pmap(get_param(params, vertex_index), g, vertex_index),
+           get_param(params, vertex_predecessor), 
+           params);
+}
+
+template <class Graph>
+void successive_shortest_path_nonnegative_weights(
+        Graph &g,
+        typename graph_traits<Graph>::vertex_descriptor s, 
+        typename graph_traits<Graph>::vertex_descriptor t) {
+    bgl_named_params<int, buffer_param_t> params(0);
+    successive_shortest_path_nonnegative_weights(g, s, t, params);
+}
+
+
+}//boost
+#endif /* BOOST_GRAPH_SUCCESSIVE_SHORTEST_PATH_HPP */
+
diff --git a/include/boost/graph/tiernan_all_cycles.hpp b/include/boost/graph/tiernan_all_cycles.hpp
index f750eb177..d4527d552 100644
--- a/include/boost/graph/tiernan_all_cycles.hpp
+++ b/include/boost/graph/tiernan_all_cycles.hpp
@@ -13,6 +13,7 @@
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/graph_traits.hpp>
 #include <boost/graph/properties.hpp>
+#include <boost/concept/assert.hpp>
 
 #include <boost/concept/detail/concept_def.hpp>
 namespace boost {
@@ -63,7 +64,7 @@ namespace boost
 // basically modernized it to use real data structures (no more arrays and matrices).
 // Oh... and there's explicit control structures - not just gotos.
 //
-// The problem is definitely NP-complete, an an unbounded implementation of this
+// The problem is definitely NP-complete, an unbounded implementation of this
 // will probably run for quite a while on a large graph. The conclusions
 // of this paper also reference a Paton algorithm for undirected graphs as being
 // much more efficient (apparently based on spanning trees). Although not implemented,
@@ -84,7 +85,7 @@ namespace boost
 //         }
 
 /**
- * The default cycle visitor providse an empty visit function for cycle
+ * The default cycle visitor provides an empty visit function for cycle
  * visitors.
  */
 struct cycle_visitor
@@ -156,8 +157,8 @@ namespace detail
                     const Path& p,
                     const ClosedMatrix& m)
     {
-        function_requires< IncidenceGraphConcept<Graph> >();
-        function_requires< VertexIndexGraphConcept<Graph> >();
+        BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+        BOOST_CONCEPT_ASSERT(( VertexIndexGraphConcept<Graph> ));
         typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
 
         // get the vertices in question
@@ -167,7 +168,7 @@ namespace detail
 
         // conditions for allowing a traversal along this edge are:
         // 1. the index of v must be greater than that at which the
-        //    the path is rooted (p.front()).
+        //    path is rooted (p.front()).
         // 2. the vertex v cannot already be in the path
         // 3. the vertex v cannot be closed to the vertex u
 
@@ -181,7 +182,7 @@ namespace detail
     inline bool
     can_wrap_path(const Graph& g, const Path& p)
     {
-        function_requires< IncidenceGraphConcept<Graph> >();
+        BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
         typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
         typedef typename graph_traits<Graph>::out_edge_iterator OutIterator;
 
@@ -193,7 +194,7 @@ namespace detail
             u = p.back(),
             v = p.front();
         OutIterator i, end;
-        for(tie(i, end) = out_edges(u, g); i != end; ++i) {
+        for(boost::tie(i, end) = out_edges(u, g); i != end; ++i) {
             if((target(*i, g) == v)) {
                 return true;
             }
@@ -209,9 +210,8 @@ namespace detail
                 Path& p,
                 ClosedMatrix& closed)
     {
-        function_requires< IncidenceGraphConcept<Graph> >();
+        BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
         typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
-        typedef typename graph_traits<Graph>::edge_descriptor Edge;
         typedef typename graph_traits<Graph>::out_edge_iterator OutIterator;
 
         // get the current vertex
@@ -220,7 +220,7 @@ namespace detail
 
         // AdjacencyIterator i, end;
         OutIterator i, end;
-        for(tie(i, end) = out_edges(u, g); i != end; ++i) {
+        for(boost::tie(i, end) = out_edges(u, g); i != end; ++i) {
             Vertex v = target(*i, g);
 
             // if we can actually extend along this edge,
@@ -238,7 +238,7 @@ namespace detail
     inline bool
     exhaust_paths(const Graph& g, Path& p, ClosedMatrix& closed)
     {
-        function_requires< GraphConcept<Graph> >();
+        BOOST_CONCEPT_ASSERT(( GraphConcept<Graph> ));
         typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
 
         // if there's more than one vertex in the path, this closes
@@ -272,10 +272,10 @@ namespace detail
                             std::size_t minlen,
                             std::size_t maxlen)
     {
-        function_requires< VertexListGraphConcept<Graph> >();
+        BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
         typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
         typedef std::vector<Vertex> Path;
-        function_requires< CycleVisitorConcept<Visitor,Path,Graph> >();
+        BOOST_CONCEPT_ASSERT(( CycleVisitorConcept<Visitor,Path,Graph> ));
         typedef std::vector<Vertex> VertexList;
         typedef std::vector<VertexList> ClosedMatrix;
 
@@ -320,11 +320,11 @@ tiernan_all_cycles(const Graph& g,
                     std::size_t minlen,
                     std::size_t maxlen)
 {
-    function_requires< VertexListGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     typedef typename graph_traits<Graph>::vertex_iterator VertexIterator;
 
     VertexIterator i, end;
-    for(tie(i, end) = vertices(g); i != end; ++i) {
+    for(boost::tie(i, end) = vertices(g); i != end; ++i) {
         detail::all_cycles_from_vertex(g, *i, vis, minlen, maxlen);
     }
 }
diff --git a/include/boost/graph/transitive_closure.hpp b/include/boost/graph/transitive_closure.hpp
index 01bfb3d30..4f81349bf 100644
--- a/include/boost/graph/transitive_closure.hpp
+++ b/include/boost/graph/transitive_closure.hpp
@@ -14,11 +14,12 @@
 #include <functional>
 #include <boost/config.hpp>
 #include <boost/bind.hpp>
-#include <boost/graph/vector_as_graph.hpp>
 #include <boost/graph/strong_components.hpp>
 #include <boost/graph/topological_sort.hpp>
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/named_function_params.hpp>
+#include <boost/graph/adjacency_list.hpp>
+#include <boost/concept/assert.hpp>
 
 namespace boost
 {
@@ -70,18 +71,17 @@ namespace boost
     if (num_vertices(g) == 0)
       return;
     typedef typename graph_traits < Graph >::vertex_descriptor vertex;
-    typedef typename graph_traits < Graph >::edge_descriptor edge;
     typedef typename graph_traits < Graph >::vertex_iterator vertex_iterator;
     typedef typename property_traits < VertexIndexMap >::value_type size_type;
     typedef typename graph_traits <
       Graph >::adjacency_iterator adjacency_iterator;
 
-    function_requires < VertexListGraphConcept < Graph > >();
-    function_requires < AdjacencyGraphConcept < Graph > >();
-    function_requires < VertexMutableGraphConcept < GraphTC > >();
-    function_requires < EdgeMutableGraphConcept < GraphTC > >();
-    function_requires < ReadablePropertyMapConcept < VertexIndexMap,
-      vertex > >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept < Graph > ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept < Graph > ));
+    BOOST_CONCEPT_ASSERT(( VertexMutableGraphConcept < GraphTC > ));
+    BOOST_CONCEPT_ASSERT(( EdgeMutableGraphConcept < GraphTC > ));
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept < VertexIndexMap,
+      vertex > ));
 
     typedef size_type cg_vertex;
     std::vector < cg_vertex > component_number_vec(num_vertices(g));
@@ -94,7 +94,7 @@ namespace boost
     std::vector < std::vector < vertex > >components;
     build_component_lists(g, num_scc, component_number, components);
 
-    typedef std::vector<std::vector<cg_vertex> > CG_t;
+    typedef boost::adjacency_list<boost::vecS, boost::vecS, boost::directedS> CG_t;
     CG_t CG(num_scc);
     for (cg_vertex s = 0; s < components.size(); ++s) {
       std::vector < cg_vertex > adj;
@@ -112,7 +112,10 @@ namespace boost
         std::unique(adj.begin(), adj.end());
       if (di != adj.end())
         adj.erase(di, adj.end());
-      CG[s] = adj;
+      for (typename std::vector<cg_vertex>::const_iterator i = adj.begin();
+           i != adj.end(); ++i) {
+        add_edge(s, *i, CG);
+      }
     }
 
     std::vector<cg_vertex> topo_order;
@@ -125,15 +128,20 @@ namespace boost
          iter != topo_order.end(); ++iter)
       topo_number[*iter] = n++;
 
-    for (size_type i = 0; i < num_vertices(CG); ++i)
-      std::sort(CG[i].begin(), CG[i].end(),
+    std::vector<std::vector<cg_vertex> > CG_vec(num_vertices(CG));
+    for (size_type i = 0; i < num_vertices(CG); ++i) {
+      typedef typename boost::graph_traits<CG_t>::adjacency_iterator cg_adj_iter;
+      std::pair<cg_adj_iter, cg_adj_iter> pr = adjacent_vertices(i, CG);
+      CG_vec[i].assign(pr.first, pr.second);
+      std::sort(CG_vec[i].begin(), CG_vec[i].end(),
                 boost::bind(std::less<cg_vertex>(),
                             boost::bind(detail::subscript(topo_number), _1),
                             boost::bind(detail::subscript(topo_number), _2)));
+    }
 
     std::vector<std::vector<cg_vertex> > chains;
     {
-      std::vector<cg_vertex> in_a_chain(num_vertices(CG));
+      std::vector<cg_vertex> in_a_chain(CG_vec.size());
       for (typename std::vector<cg_vertex>::iterator i = topo_order.begin();
            i != topo_order.end(); ++i) {
         cg_vertex v = *i;
@@ -143,12 +151,10 @@ namespace boost
           for (;;) {
             chain.push_back(v);
             in_a_chain[v] = true;
-            typename graph_traits<CG_t>::adjacency_iterator adj_first, adj_last;
-            boost::tie(adj_first, adj_last) = adjacent_vertices(v, CG);
-            typename graph_traits<CG_t>::adjacency_iterator next
-              = std::find_if(adj_first, adj_last,
+            typename std::vector<cg_vertex>::const_iterator next
+              = std::find_if(CG_vec[v].begin(), CG_vec[v].end(),
                              std::not1(detail::subscript(in_a_chain)));
-            if (next != adj_last)
+            if (next != CG_vec[v].end())
               v = *next;
             else
               break;            // end of chain, dead-end
@@ -157,8 +163,8 @@ namespace boost
         }
       }
     }
-    std::vector<size_type> chain_number(num_vertices(CG));
-    std::vector<size_type> pos_in_chain(num_vertices(CG));
+    std::vector<size_type> chain_number(CG_vec.size());
+    std::vector<size_type> pos_in_chain(CG_vec.size());
     for (size_type i = 0; i < chains.size(); ++i)
       for (size_type j = 0; j < chains[i].size(); ++j) {
         cg_vertex v = chains[i][j];
@@ -167,14 +173,14 @@ namespace boost
       }
 
     cg_vertex inf = (std::numeric_limits< cg_vertex >::max)();
-    std::vector<std::vector<cg_vertex> > successors(num_vertices(CG),
+    std::vector<std::vector<cg_vertex> > successors(CG_vec.size(),
                                                     std::vector<cg_vertex>
                                                     (chains.size(), inf));
     for (typename std::vector<cg_vertex>::reverse_iterator
            i = topo_order.rbegin(); i != topo_order.rend(); ++i) {
       cg_vertex u = *i;
-      typename graph_traits<CG_t>::adjacency_iterator adj, adj_last;
-      for (boost::tie(adj, adj_last) = adjacent_vertices(u, CG);
+      typename std::vector<cg_vertex>::const_iterator adj, adj_last;
+      for (adj = CG_vec[u].begin(), adj_last = CG_vec[u].end();
            adj != adj_last; ++adj) {
         cg_vertex v = *adj;
         if (topo_number[v] < successors[u][chain_number[v]]) {
@@ -187,32 +193,31 @@ namespace boost
       }
     }
 
-    for (size_type i = 0; i < CG.size(); ++i)
-      CG[i].clear();
-    for (size_type i = 0; i < CG.size(); ++i)
+    for (size_type i = 0; i < CG_vec.size(); ++i)
+      CG_vec[i].clear();
+    for (size_type i = 0; i < CG_vec.size(); ++i)
       for (size_type j = 0; j < chains.size(); ++j) {
         size_type topo_num = successors[i][j];
         if (topo_num < inf) {
           cg_vertex v = topo_order[topo_num];
           for (size_type k = pos_in_chain[v]; k < chains[j].size(); ++k)
-            CG[i].push_back(chains[j][k]);
+            CG_vec[i].push_back(chains[j][k]);
         }
       }
 
 
     // Add vertices to the transitive closure graph
-    typedef typename graph_traits < GraphTC >::vertex_descriptor tc_vertex;
     {
       vertex_iterator i, i_end;
       for (boost::tie(i, i_end) = vertices(g); i != i_end; ++i)
         g_to_tc_map[*i] = add_vertex(tc);
     }
     // Add edges between all the vertices in two adjacent SCCs
-    typename graph_traits<CG_t>::vertex_iterator si, si_end;
-    for (boost::tie(si, si_end) = vertices(CG); si != si_end; ++si) {
-      cg_vertex s = *si;
-      typename graph_traits<CG_t>::adjacency_iterator i, i_end;
-      for (boost::tie(i, i_end) = adjacent_vertices(s, CG); i != i_end; ++i) {
+    typename std::vector<std::vector<cg_vertex> >::const_iterator si, si_end;
+    for (si = CG_vec.begin(), si_end = CG_vec.end(); si != si_end; ++si) {
+      cg_vertex s = si - CG_vec.begin();
+      typename std::vector<cg_vertex>::const_iterator i, i_end;
+      for (i = CG_vec[s].begin(), i_end = CG_vec[s].end(); i != i_end; ++i) {
         cg_vertex t = *i;
         for (size_type k = 0; k < components[s].size(); ++k)
           for (size_type l = 0; l < components[t].size(); ++l)
@@ -299,11 +304,10 @@ namespace boost
 
   template < typename G > void warshall_transitive_closure(G & g)
   {
-    typedef typename graph_traits < G >::vertex_descriptor vertex;
     typedef typename graph_traits < G >::vertex_iterator vertex_iterator;
 
-    function_requires < AdjacencyMatrixConcept < G > >();
-    function_requires < EdgeMutableGraphConcept < G > >();
+    BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept < G > ));
+    BOOST_CONCEPT_ASSERT(( EdgeMutableGraphConcept < G > ));
 
     // Matrix form:
     // for k
@@ -325,11 +329,10 @@ namespace boost
   template < typename G > void warren_transitive_closure(G & g)
   {
     using namespace boost;
-    typedef typename graph_traits < G >::vertex_descriptor vertex;
     typedef typename graph_traits < G >::vertex_iterator vertex_iterator;
 
-    function_requires < AdjacencyMatrixConcept < G > >();
-    function_requires < EdgeMutableGraphConcept < G > >();
+    BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept < G > ));
+    BOOST_CONCEPT_ASSERT(( EdgeMutableGraphConcept < G > ));
 
     // Make sure second loop will work
     if (num_vertices(g) == 0)
diff --git a/include/boost/graph/transitive_reduction.hpp b/include/boost/graph/transitive_reduction.hpp
index 44dfee989..f7cb34b8c 100644
--- a/include/boost/graph/transitive_reduction.hpp
+++ b/include/boost/graph/transitive_reduction.hpp
@@ -99,7 +99,7 @@ transitive_reduction(const Graph& g, GraphTR& tr,
         {
             //and run through all vertices in topological order
             typename std::vector<Vertex>::reverse_iterator
-                rit = topo_order.rbegin();
+                rit = topo_order.rbegin(),
                 rend = topo_order.rend();
             for(; rit != rend; ++rit ) {
                 //looking if they are successors of *it
diff --git a/include/boost/graph/two_bit_color_map.hpp b/include/boost/graph/two_bit_color_map.hpp
index 9a3872fd0..3d55eabc7 100644
--- a/include/boost/graph/two_bit_color_map.hpp
+++ b/include/boost/graph/two_bit_color_map.hpp
@@ -17,6 +17,7 @@
 #include <boost/graph/properties.hpp>
 #include <boost/shared_array.hpp>
 #include <boost/config.hpp>
+#include <boost/assert.hpp>
 #include <algorithm>
 #include <limits>
 
@@ -68,7 +69,7 @@ get(const two_bit_color_map<IndexMap>& pm,
 {
   BOOST_STATIC_CONSTANT(int, elements_per_char = two_bit_color_map<IndexMap>::elements_per_char);
   typename property_traits<IndexMap>::value_type i = get(pm.index, key);
-  assert ((std::size_t)i < pm.n);
+  BOOST_ASSERT ((std::size_t)i < pm.n);
   std::size_t byte_num = i / elements_per_char;
   std::size_t bit_position = ((i % elements_per_char) * 2);
   return two_bit_color_type((pm.data.get()[byte_num] >> bit_position) & 3);
@@ -82,8 +83,8 @@ put(const two_bit_color_map<IndexMap>& pm,
 {
   BOOST_STATIC_CONSTANT(int, elements_per_char = two_bit_color_map<IndexMap>::elements_per_char);
   typename property_traits<IndexMap>::value_type i = get(pm.index, key);
-  assert ((std::size_t)i < pm.n);
-  assert (value >= 0 && value < 4);
+  BOOST_ASSERT ((std::size_t)i < pm.n);
+  BOOST_ASSERT (value >= 0 && value < 4);
   std::size_t byte_num = i / elements_per_char;
   std::size_t bit_position = ((i % elements_per_char) * 2);
     pm.data.get()[byte_num] =
diff --git a/include/boost/graph/two_graphs_common_spanning_trees.hpp b/include/boost/graph/two_graphs_common_spanning_trees.hpp
new file mode 100644
index 000000000..48f80df17
--- /dev/null
+++ b/include/boost/graph/two_graphs_common_spanning_trees.hpp
@@ -0,0 +1,863 @@
+//          Copyright (C) 2012, Michele Caini.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+//          Two Graphs Common Spanning Trees Algorithm
+//      Based on academic article of Mint, Read and Tarjan
+//     Efficient Algorithm for Common Spanning Tree Problem
+// Electron. Lett., 28 April 1983, Volume 19, Issue 9, p.346-347
+
+
+#ifndef BOOST_GRAPH_TWO_GRAPHS_COMMON_SPANNING_TREES_HPP
+#define BOOST_GRAPH_TWO_GRAPHS_COMMON_SPANNING_TREES_HPP
+
+
+#include <boost/config.hpp>
+
+#include <boost/bimap.hpp>
+#include <boost/type_traits.hpp>
+#include <boost/concept/requires.hpp>
+#include <boost/graph/graph_traits.hpp>
+#include <boost/graph/undirected_dfs.hpp>
+#include <boost/graph/connected_components.hpp>
+#include <boost/graph/filtered_graph.hpp>
+#include <vector>
+#include <stack>
+#include <map>
+
+
+namespace boost
+{
+
+
+namespace detail {
+
+
+  template
+    <
+      typename TreeMap,
+      typename PredMap,
+      typename DistMap,
+      typename LowMap,
+      typename Buffer
+    >
+  struct bridges_visitor: public default_dfs_visitor
+  {
+    bridges_visitor(
+        TreeMap tree,
+        PredMap pred,
+        DistMap dist,
+        LowMap low,
+        Buffer& buffer
+      ): mTree(tree), mPred(pred), mDist(dist), mLow(low), mBuffer(buffer)
+    { mNum = -1; }
+
+    template <typename Vertex, typename Graph>
+    void initialize_vertex(const Vertex& u, const Graph& g)
+    {
+      put(mPred, u, u);
+      put(mDist, u, -1);
+    }
+
+    template <typename Vertex, typename Graph>
+    void discover_vertex(const Vertex& u, const Graph& g)
+    {
+      put(mDist, u, ++mNum);
+      put(mLow, u, get(mDist, u));
+    }
+
+    template <typename Edge, typename Graph>
+    void tree_edge(const Edge& e, const Graph& g)
+    {
+      put(mPred, target(e, g), source(e, g));
+      put(mTree, target(e, g), e);
+    }
+
+    template <typename Edge, typename Graph>
+    void back_edge(const Edge& e, const Graph& g)
+    {
+      put(mLow, source(e, g),
+        (std::min)(get(mLow, source(e, g)), get(mDist, target(e, g))));
+    }
+
+    template <typename Vertex, typename Graph>
+    void finish_vertex(const Vertex& u, const Graph& g)
+    {
+      Vertex parent = get(mPred, u);
+      if(get(mLow, u) > get(mDist, parent))
+        mBuffer.push(get(mTree, u));
+      put(mLow, parent,
+        (std::min)(get(mLow, parent), get(mLow, u)));
+    }
+
+    TreeMap mTree;
+    PredMap mPred;
+    DistMap mDist;
+    LowMap mLow;
+    Buffer& mBuffer;
+    int mNum;
+  };
+
+
+  template <typename Buffer>
+  struct cycle_finder: public base_visitor< cycle_finder<Buffer> >
+  {
+    typedef on_back_edge event_filter;
+    cycle_finder(): mBuffer(0) { }
+    cycle_finder(Buffer* buffer)
+      : mBuffer(buffer) { }
+    template <typename Edge, typename Graph>
+    void operator()(const Edge& e, const Graph& g)
+      {
+        if(mBuffer)
+          mBuffer->push(e);
+      }
+    Buffer* mBuffer;
+  };
+
+
+  template <typename DeletedMap>
+  struct deleted_edge_status
+  {
+    deleted_edge_status() { }
+    deleted_edge_status(DeletedMap map): mMap(map) { }
+    template <typename Edge>
+    bool operator()(const Edge& e) const
+      { return (!get(mMap, e)); }
+    DeletedMap mMap;
+  };
+
+
+  template <typename InLMap>
+  struct inL_edge_status
+  {
+    inL_edge_status() { }
+    inL_edge_status(InLMap map): mMap(map) { }
+    template <typename Edge>
+    bool operator()(const Edge& e) const
+      { return get(mMap, e); }
+    InLMap mMap;
+  };
+
+
+  template <
+    typename Graph,
+    typename Func,
+    typename Seq,
+    typename Map
+  >
+  void rec_two_graphs_common_spanning_trees
+    (
+      const Graph& iG,
+      bimap<
+          bimaps::set_of<int>,
+          bimaps::set_of< typename graph_traits<Graph>::edge_descriptor >
+        > iG_bimap,
+      Map aiG_inL,
+      Map diG,
+      const Graph& vG,
+      bimap<
+          bimaps::set_of<int>,
+          bimaps::set_of< typename graph_traits<Graph>::edge_descriptor >
+        > vG_bimap,
+      Map avG_inL,
+      Map dvG,
+      Func func,
+      Seq inL
+    )
+  {
+    typedef graph_traits<Graph> GraphTraits;
+
+    typedef typename GraphTraits::vertex_descriptor vertex_descriptor;
+    typedef typename GraphTraits::edge_descriptor edge_descriptor;
+
+    typedef typename Seq::size_type seq_size_type;
+
+    int edges = num_vertices(iG) - 1;
+//
+//  [ Michele Caini ]
+//
+//  Using the condition (edges != 0) leads to the accidental submission of
+//    sub-graphs ((V-1+1)-fake-tree, named here fat-tree).
+//  Remove this condition is a workaround for the problem of fat-trees.
+//  Please do not add that condition, even if it improves performance.
+//
+//  Here is proposed the previous guard (that was wrong):
+//     for(seq_size_type i = 0; (i < inL.size()) && (edges != 0); ++i)
+//
+    {
+      for(seq_size_type i = 0; i < inL.size(); ++i)
+        if(inL[i])
+          --edges;
+
+      if(edges < 0)
+        return;
+    }
+
+    bool is_tree = (edges == 0);
+    if(is_tree) {
+      func(inL);
+    } else {
+      std::map<vertex_descriptor, default_color_type> vertex_color;
+      std::map<edge_descriptor, default_color_type> edge_color;
+
+      std::stack<edge_descriptor> iG_buf, vG_buf;
+      bool found = false;
+
+      seq_size_type m;
+      for(seq_size_type j = 0; j < inL.size() && !found; ++j) {
+        if(!inL[j]
+            && !get(diG, iG_bimap.left.at(j))
+            && !get(dvG, vG_bimap.left.at(j)))
+        {
+          put(aiG_inL, iG_bimap.left.at(j), true);
+          put(avG_inL, vG_bimap.left.at(j), true);
+
+          undirected_dfs(
+              make_filtered_graph(iG,
+                detail::inL_edge_status< associative_property_map<
+                  std::map<edge_descriptor, bool> > >(aiG_inL)),
+              make_dfs_visitor(
+                detail::cycle_finder< std::stack<edge_descriptor> > (&iG_buf)),
+              associative_property_map<
+                std::map<vertex_descriptor, default_color_type> >(vertex_color),
+              associative_property_map<
+                std::map<edge_descriptor, default_color_type> >(edge_color)
+            );
+          undirected_dfs(
+              make_filtered_graph(vG,
+                detail::inL_edge_status< associative_property_map<
+                  std::map<edge_descriptor, bool> > >(avG_inL)),
+              make_dfs_visitor(
+                detail::cycle_finder< std::stack<edge_descriptor> > (&vG_buf)),
+              associative_property_map<
+                std::map<vertex_descriptor, default_color_type> >(vertex_color),
+              associative_property_map<
+                std::map<edge_descriptor, default_color_type> >(edge_color)
+            );
+
+          if(iG_buf.empty() && vG_buf.empty()) {
+            inL[j] = true;
+            found = true;
+            m = j;
+          } else {
+            while(!iG_buf.empty()) iG_buf.pop();
+            while(!vG_buf.empty()) vG_buf.pop();
+            put(aiG_inL, iG_bimap.left.at(j), false);
+            put(avG_inL, vG_bimap.left.at(j), false);
+          }
+        }
+      }
+
+      if(found) {
+
+        std::stack<edge_descriptor> iG_buf_copy, vG_buf_copy;
+        for(seq_size_type j = 0; j < inL.size(); ++j) {
+          if(!inL[j]
+              && !get(diG, iG_bimap.left.at(j))
+              && !get(dvG, vG_bimap.left.at(j)))
+          {
+
+            put(aiG_inL, iG_bimap.left.at(j), true);
+            put(avG_inL, vG_bimap.left.at(j), true);
+
+            undirected_dfs(
+                make_filtered_graph(iG,
+                  detail::inL_edge_status< associative_property_map<
+                    std::map<edge_descriptor, bool> > >(aiG_inL)),
+                make_dfs_visitor(
+                  detail::cycle_finder<
+                    std::stack<edge_descriptor> > (&iG_buf)),
+               associative_property_map< std::map<
+                  vertex_descriptor, default_color_type> >(vertex_color),
+                associative_property_map<
+                  std::map<edge_descriptor, default_color_type> >(edge_color)
+              );
+            undirected_dfs(
+                make_filtered_graph(vG,
+                  detail::inL_edge_status< associative_property_map<
+                    std::map<edge_descriptor, bool> > >(avG_inL)),
+                make_dfs_visitor(
+                  detail::cycle_finder<
+                    std::stack<edge_descriptor> > (&vG_buf)),
+                associative_property_map< std::map<
+                  vertex_descriptor, default_color_type> >(vertex_color),
+                associative_property_map<
+                  std::map<edge_descriptor, default_color_type> >(edge_color)
+              );
+
+            if(!iG_buf.empty() || !vG_buf.empty()) {
+              while(!iG_buf.empty()) iG_buf.pop();
+              while(!vG_buf.empty()) vG_buf.pop();
+              put(diG, iG_bimap.left.at(j), true);
+              put(dvG, vG_bimap.left.at(j), true);
+              iG_buf_copy.push(iG_bimap.left.at(j));
+              vG_buf_copy.push(vG_bimap.left.at(j));
+            }
+
+            put(aiG_inL, iG_bimap.left.at(j), false);
+            put(avG_inL, vG_bimap.left.at(j), false);
+          }
+        }
+
+        // REC
+        detail::rec_two_graphs_common_spanning_trees<Graph, Func, Seq, Map>
+          (iG, iG_bimap, aiG_inL, diG, vG, vG_bimap, aiG_inL, dvG, func, inL);
+
+        while(!iG_buf_copy.empty()) {
+          put(diG, iG_buf_copy.top(), false);
+          put(dvG, vG_bimap.left.at(
+            iG_bimap.right.at(iG_buf_copy.top())), false);
+          iG_buf_copy.pop();
+        }
+        while(!vG_buf_copy.empty()) {
+          put(dvG, vG_buf_copy.top(), false);
+          put(diG, iG_bimap.left.at(
+            vG_bimap.right.at(vG_buf_copy.top())), false);
+          vG_buf_copy.pop();
+        }
+
+        inL[m] = false;
+        put(aiG_inL, iG_bimap.left.at(m), false);
+        put(avG_inL, vG_bimap.left.at(m), false);
+
+        put(diG, iG_bimap.left.at(m), true);
+        put(dvG, vG_bimap.left.at(m), true);
+
+        std::map<vertex_descriptor, edge_descriptor> tree_map;
+        std::map<vertex_descriptor, vertex_descriptor> pred_map;
+        std::map<vertex_descriptor, int> dist_map, low_map;
+
+        detail::bridges_visitor<
+            associative_property_map<
+                std::map<vertex_descriptor, edge_descriptor>
+              >,
+            associative_property_map<
+                std::map<vertex_descriptor, vertex_descriptor>
+              >,
+            associative_property_map< std::map<vertex_descriptor, int> >,
+            associative_property_map< std::map<vertex_descriptor, int> >,
+            std::stack<edge_descriptor>
+          >
+        iG_vis(
+            associative_property_map<
+              std::map< vertex_descriptor, edge_descriptor> >(tree_map),
+            associative_property_map<
+              std::map< vertex_descriptor, vertex_descriptor> >(pred_map),
+            associative_property_map<
+              std::map< vertex_descriptor, int> >(dist_map),
+            associative_property_map<
+              std::map< vertex_descriptor, int> >(low_map),
+            iG_buf
+          ),
+        vG_vis(
+            associative_property_map<
+              std::map< vertex_descriptor, edge_descriptor> >(tree_map),
+            associative_property_map<
+              std::map< vertex_descriptor, vertex_descriptor> >(pred_map),
+            associative_property_map<
+              std::map< vertex_descriptor, int> >(dist_map),
+            associative_property_map<
+              std::map< vertex_descriptor, int> >(low_map),
+            vG_buf
+          );
+
+        undirected_dfs(make_filtered_graph(iG,
+              detail::deleted_edge_status< associative_property_map<
+              std::map<edge_descriptor, bool> > >(diG)),
+            iG_vis,
+            associative_property_map<
+              std::map<vertex_descriptor, default_color_type> >(vertex_color),
+            associative_property_map<
+              std::map<edge_descriptor, default_color_type> >(edge_color)
+          );
+        undirected_dfs(make_filtered_graph(vG,
+              detail::deleted_edge_status< associative_property_map<
+              std::map<edge_descriptor, bool> > >(dvG)),
+            vG_vis,
+            associative_property_map<
+              std::map<vertex_descriptor, default_color_type> >(vertex_color),
+            associative_property_map<
+              std::map<edge_descriptor, default_color_type> >(edge_color)
+          );
+
+        found = false;
+        std::stack<edge_descriptor> iG_buf_tmp, vG_buf_tmp;
+        while(!iG_buf.empty() && !found) {
+          if(!inL[iG_bimap.right.at(iG_buf.top())]) {
+            put(aiG_inL, iG_buf.top(), true);
+            put(avG_inL, vG_bimap.left.at(
+              iG_bimap.right.at(iG_buf.top())), true);
+
+            undirected_dfs(
+                make_filtered_graph(iG,
+                  detail::inL_edge_status< associative_property_map<
+                    std::map<edge_descriptor, bool> > >(aiG_inL)),
+                make_dfs_visitor(
+                  detail::cycle_finder<
+                    std::stack<edge_descriptor> > (&iG_buf_tmp)),
+                associative_property_map<
+                  std::map<
+                    vertex_descriptor, default_color_type> >(vertex_color),
+                associative_property_map<
+                  std::map<edge_descriptor, default_color_type> >(edge_color)
+              );
+            undirected_dfs(
+                make_filtered_graph(vG,
+                  detail::inL_edge_status< associative_property_map<
+                    std::map<edge_descriptor, bool> > >(avG_inL)),
+                make_dfs_visitor(
+                  detail::cycle_finder<
+                    std::stack<edge_descriptor> > (&vG_buf_tmp)),
+                associative_property_map<
+                  std::map<
+                    vertex_descriptor, default_color_type> >(vertex_color),
+                associative_property_map<
+                  std::map<edge_descriptor, default_color_type> >(edge_color)
+              );
+
+            if(!iG_buf_tmp.empty() || !vG_buf_tmp.empty()) {
+              found = true;
+            } else {
+              while(!iG_buf_tmp.empty()) iG_buf_tmp.pop();
+              while(!vG_buf_tmp.empty()) vG_buf_tmp.pop();
+              iG_buf_copy.push(iG_buf.top());
+            }
+
+            put(aiG_inL, iG_buf.top(), false);
+            put(avG_inL, vG_bimap.left.at(
+              iG_bimap.right.at(iG_buf.top())), false);
+          }
+          iG_buf.pop();
+        }
+        while(!vG_buf.empty() && !found) {
+          if(!inL[vG_bimap.right.at(vG_buf.top())]) {
+            put(avG_inL, vG_buf.top(), true);
+            put(aiG_inL, iG_bimap.left.at(
+              vG_bimap.right.at(vG_buf.top())), true);
+
+            undirected_dfs(
+                make_filtered_graph(iG,
+                  detail::inL_edge_status< associative_property_map<
+                    std::map<edge_descriptor, bool> > >(aiG_inL)),
+                make_dfs_visitor(
+                  detail::cycle_finder<
+                    std::stack<edge_descriptor> > (&iG_buf_tmp)),
+                associative_property_map<
+                  std::map<
+                    vertex_descriptor, default_color_type> >(vertex_color),
+                associative_property_map<
+                  std::map<edge_descriptor, default_color_type> >(edge_color)
+              );
+            undirected_dfs(
+                make_filtered_graph(vG,
+                  detail::inL_edge_status< associative_property_map<
+                    std::map<edge_descriptor, bool> > >(avG_inL)),
+                make_dfs_visitor(
+                  detail::cycle_finder<
+                    std::stack<edge_descriptor> > (&vG_buf_tmp)),
+                associative_property_map<
+                  std::map<
+                    vertex_descriptor, default_color_type> >(vertex_color),
+                associative_property_map<
+                  std::map<edge_descriptor, default_color_type> >(edge_color)
+              );
+
+            if(!iG_buf_tmp.empty() || !vG_buf_tmp.empty()) {
+              found = true;
+            } else {
+              while(!iG_buf_tmp.empty()) iG_buf_tmp.pop();
+              while(!vG_buf_tmp.empty()) vG_buf_tmp.pop();
+              vG_buf_copy.push(vG_buf.top());
+            }
+
+            put(avG_inL, vG_buf.top(), false);
+            put(aiG_inL, iG_bimap.left.at(
+              vG_bimap.right.at(vG_buf.top())), false);
+          }
+          vG_buf.pop();
+        }
+
+        if(!found) {
+
+          while(!iG_buf_copy.empty()) {
+            inL[iG_bimap.right.at(iG_buf_copy.top())] = true;
+            put(aiG_inL, iG_buf_copy.top(), true);
+            put(avG_inL, vG_bimap.left.at(
+              iG_bimap.right.at(iG_buf_copy.top())), true);
+            iG_buf.push(iG_buf_copy.top());
+            iG_buf_copy.pop();
+          }
+          while(!vG_buf_copy.empty()) {
+            inL[vG_bimap.right.at(vG_buf_copy.top())] = true;
+            put(avG_inL, vG_buf_copy.top(), true);
+            put(aiG_inL, iG_bimap.left.at(
+              vG_bimap.right.at(vG_buf_copy.top())), true);
+            vG_buf.push(vG_buf_copy.top());
+            vG_buf_copy.pop();
+          }
+
+          // REC
+          detail::rec_two_graphs_common_spanning_trees<
+              Graph, Func, Seq, Map>
+            (iG, iG_bimap, aiG_inL, diG, vG, vG_bimap, aiG_inL, dvG, func, inL);
+
+          while(!iG_buf.empty()) {
+            inL[iG_bimap.right.at(iG_buf.top())] = false;
+            put(aiG_inL, iG_buf.top(), false);
+            put(avG_inL, vG_bimap.left.at(
+              iG_bimap.right.at(iG_buf.top())), false);
+            iG_buf.pop();
+          }
+          while(!vG_buf.empty()) {
+            inL[vG_bimap.right.at(vG_buf.top())] = false;
+            put(avG_inL, vG_buf.top(), false);
+            put(aiG_inL, iG_bimap.left.at(
+              vG_bimap.right.at(vG_buf.top())), false);
+            vG_buf.pop();
+          }
+
+        }
+
+        put(diG, iG_bimap.left.at(m), false);
+        put(dvG, vG_bimap.left.at(m), false);
+
+      }
+    }
+  }
+
+} // namespace detail
+
+
+
+template <typename Coll, typename Seq>
+struct tree_collector
+{
+
+public:
+  BOOST_CONCEPT_ASSERT((BackInsertionSequence<Coll>));
+  BOOST_CONCEPT_ASSERT((RandomAccessContainer<Seq>));
+  BOOST_CONCEPT_ASSERT((CopyConstructible<Seq>));
+
+  typedef typename Coll::value_type coll_value_type;
+  typedef typename Seq::value_type seq_value_type;
+
+  BOOST_STATIC_ASSERT((is_same<coll_value_type, Seq>::value));
+  BOOST_STATIC_ASSERT((is_same<seq_value_type, bool>::value));
+
+  tree_collector(Coll& seqs): mSeqs(seqs) { }
+
+  inline void operator()(Seq seq)
+    { mSeqs.push_back(seq); }
+
+private:
+  Coll& mSeqs;
+
+};
+
+
+
+template <
+  typename Graph,
+  typename Order,
+  typename Func,
+  typename Seq
+>
+BOOST_CONCEPT_REQUIRES(
+  ((RandomAccessContainer<Order>))
+  ((IncidenceGraphConcept<Graph>))
+  ((UnaryFunction<Func, void, Seq>))
+  ((Mutable_RandomAccessContainer<Seq>))
+  ((VertexAndEdgeListGraphConcept<Graph>)),
+  (void)
+)
+two_graphs_common_spanning_trees
+  (
+    const Graph& iG,
+    Order iG_map,
+    const Graph& vG,
+    Order vG_map,
+    Func func,
+    Seq inL
+  )
+{
+  typedef graph_traits<Graph> GraphTraits;
+
+  typedef typename GraphTraits::directed_category directed_category;
+  typedef typename GraphTraits::vertex_descriptor vertex_descriptor;
+  typedef typename GraphTraits::edge_descriptor edge_descriptor;
+
+  typedef typename GraphTraits::edges_size_type edges_size_type;
+  typedef typename GraphTraits::edge_iterator edge_iterator;
+
+  typedef typename Seq::value_type seq_value_type;
+  typedef typename Seq::size_type seq_size_type;
+
+  typedef typename Order::value_type order_value_type;
+  typedef typename Order::size_type order_size_type;
+
+  BOOST_STATIC_ASSERT((is_same<order_value_type, edge_descriptor>::value));
+  BOOST_CONCEPT_ASSERT((Convertible<order_size_type, edges_size_type>));
+
+  BOOST_CONCEPT_ASSERT((Convertible<seq_size_type, edges_size_type>));
+  BOOST_STATIC_ASSERT((is_same<seq_value_type, bool>::value));
+
+  BOOST_STATIC_ASSERT((is_same<directed_category, undirected_tag>::value));
+
+  if(num_vertices(iG) != num_vertices(vG))
+    return;
+
+  if(inL.size() != num_edges(iG)
+      || inL.size() != num_edges(vG))
+    return;
+
+  if(iG_map.size() != num_edges(iG)
+      || vG_map.size() != num_edges(vG))
+    return;
+
+  typedef bimaps::bimap<
+      bimaps::set_of< int >,
+      bimaps::set_of< order_value_type >
+    > bimap_type;
+  typedef typename bimap_type::value_type bimap_value;
+
+  bimap_type iG_bimap, vG_bimap;
+  for(order_size_type i = 0; i < iG_map.size(); ++i)
+    iG_bimap.insert(bimap_value(i, iG_map[i]));
+  for(order_size_type i = 0; i < vG_map.size(); ++i)
+    vG_bimap.insert(bimap_value(i, vG_map[i]));
+
+  edge_iterator current, last;
+  boost::tuples::tie(current, last) = edges(iG);
+  for(; current != last; ++current)
+    if(iG_bimap.right.find(*current) == iG_bimap.right.end())
+      return;
+  boost::tuples::tie(current, last) = edges(vG);
+  for(; current != last; ++current)
+    if(vG_bimap.right.find(*current) == vG_bimap.right.end())
+      return;
+
+  std::stack<edge_descriptor> iG_buf, vG_buf;
+
+  std::map<vertex_descriptor, edge_descriptor> tree_map;
+  std::map<vertex_descriptor, vertex_descriptor> pred_map;
+  std::map<vertex_descriptor, int> dist_map, low_map;
+
+  detail::bridges_visitor<
+      associative_property_map<
+          std::map<vertex_descriptor, edge_descriptor>
+        >,
+      associative_property_map<
+          std::map<vertex_descriptor, vertex_descriptor>
+        >,
+      associative_property_map< std::map<vertex_descriptor, int> >,
+      associative_property_map< std::map<vertex_descriptor, int> >,
+      std::stack<edge_descriptor>
+    >
+  iG_vis(
+      associative_property_map<
+        std::map< vertex_descriptor, edge_descriptor> >(tree_map),
+      associative_property_map<
+        std::map< vertex_descriptor, vertex_descriptor> >(pred_map),
+      associative_property_map<std::map< vertex_descriptor, int> >(dist_map),
+      associative_property_map<std::map< vertex_descriptor, int> >(low_map),
+      iG_buf
+    ),
+  vG_vis(
+      associative_property_map<
+        std::map< vertex_descriptor, edge_descriptor> >(tree_map),
+      associative_property_map<
+        std::map< vertex_descriptor, vertex_descriptor> >(pred_map),
+      associative_property_map<std::map< vertex_descriptor, int> >(dist_map),
+      associative_property_map<std::map< vertex_descriptor, int> >(low_map),
+      vG_buf
+    );
+
+  std::map<vertex_descriptor, default_color_type> vertex_color;
+  std::map<edge_descriptor, default_color_type> edge_color;
+
+  undirected_dfs(iG, iG_vis,
+      associative_property_map<
+        std::map<vertex_descriptor, default_color_type> >(vertex_color),
+      associative_property_map<
+        std::map<edge_descriptor, default_color_type> >(edge_color)
+    );
+  undirected_dfs(vG, vG_vis,
+      associative_property_map<
+        std::map<vertex_descriptor, default_color_type> >(vertex_color),
+      associative_property_map<
+        std::map<edge_descriptor, default_color_type> >(edge_color)
+    );
+
+  while(!iG_buf.empty()) {
+    inL[iG_bimap.right.at(iG_buf.top())] = true;
+    iG_buf.pop();
+  }
+  while(!vG_buf.empty()) {
+    inL[vG_bimap.right.at(vG_buf.top())] = true;
+    vG_buf.pop();
+  }
+
+  std::map<edge_descriptor, bool> iG_inL, vG_inL;
+  associative_property_map< std::map<edge_descriptor, bool> >
+    aiG_inL(iG_inL), avG_inL(vG_inL);
+
+  for(seq_size_type i = 0; i < inL.size(); ++i)
+  {
+    if(inL[i]) {
+      put(aiG_inL, iG_bimap.left.at(i), true);
+      put(avG_inL, vG_bimap.left.at(i), true);
+    } else {
+      put(aiG_inL, iG_bimap.left.at(i), false);
+      put(avG_inL, vG_bimap.left.at(i), false);
+    }
+  }
+
+  undirected_dfs(
+      make_filtered_graph(iG,
+        detail::inL_edge_status< associative_property_map<
+          std::map<edge_descriptor, bool> > >(aiG_inL)),
+      make_dfs_visitor(
+        detail::cycle_finder< std::stack<edge_descriptor> > (&iG_buf)),
+      associative_property_map<
+        std::map<vertex_descriptor, default_color_type> >(vertex_color),
+      associative_property_map<
+        std::map<edge_descriptor, default_color_type> >(edge_color)
+    );
+  undirected_dfs(
+      make_filtered_graph(vG,
+        detail::inL_edge_status< associative_property_map<
+          std::map<edge_descriptor, bool> > >(avG_inL)),
+      make_dfs_visitor(
+        detail::cycle_finder< std::stack<edge_descriptor> > (&vG_buf)),
+      associative_property_map<
+        std::map<vertex_descriptor, default_color_type> >(vertex_color),
+      associative_property_map<
+        std::map<edge_descriptor, default_color_type> >(edge_color)
+    );
+
+  if(iG_buf.empty() && vG_buf.empty()) {
+
+    std::map<edge_descriptor, bool> iG_deleted, vG_deleted;
+    associative_property_map< std::map<edge_descriptor, bool> > diG(iG_deleted);
+    associative_property_map< std::map<edge_descriptor, bool> > dvG(vG_deleted);
+
+    boost::tuples::tie(current, last) = edges(iG);
+    for(; current != last; ++current)
+      put(diG, *current, false);
+    boost::tuples::tie(current, last) = edges(vG);
+    for(; current != last; ++current)
+      put(dvG, *current, false);
+
+    for(seq_size_type j = 0; j < inL.size(); ++j) {
+      if(!inL[j]) {
+        put(aiG_inL, iG_bimap.left.at(j), true);
+        put(avG_inL, vG_bimap.left.at(j), true);
+
+        undirected_dfs(
+            make_filtered_graph(iG,
+              detail::inL_edge_status< associative_property_map<
+                std::map<edge_descriptor, bool> > >(aiG_inL)),
+            make_dfs_visitor(
+              detail::cycle_finder< std::stack<edge_descriptor> > (&iG_buf)),
+            associative_property_map<
+              std::map<vertex_descriptor, default_color_type> >(vertex_color),
+            associative_property_map<
+              std::map<edge_descriptor, default_color_type> >(edge_color)
+          );
+        undirected_dfs(
+            make_filtered_graph(vG,
+              detail::inL_edge_status< associative_property_map<
+                std::map<edge_descriptor, bool> > >(avG_inL)),
+            make_dfs_visitor(
+              detail::cycle_finder< std::stack<edge_descriptor> > (&vG_buf)),
+            associative_property_map<
+              std::map<vertex_descriptor, default_color_type> >(vertex_color),
+            associative_property_map<
+              std::map<edge_descriptor, default_color_type> >(edge_color)
+          );
+
+        if(!iG_buf.empty() || !vG_buf.empty()) {
+          while(!iG_buf.empty()) iG_buf.pop();
+          while(!vG_buf.empty()) vG_buf.pop();
+          put(diG, iG_bimap.left.at(j), true);
+          put(dvG, vG_bimap.left.at(j), true);
+        }
+
+        put(aiG_inL, iG_bimap.left.at(j), false);
+        put(avG_inL, vG_bimap.left.at(j), false);
+      }
+    }
+
+    int cc = 0;
+
+    std::map<vertex_descriptor, int> com_map;
+    cc += connected_components(
+        make_filtered_graph(iG,
+          detail::deleted_edge_status<associative_property_map<
+            std::map<edge_descriptor, bool> > >(diG)),
+        associative_property_map<std::map<vertex_descriptor, int> >(com_map)
+      );
+    cc += connected_components(
+        make_filtered_graph(vG,
+          detail::deleted_edge_status<associative_property_map<
+            std::map<edge_descriptor, bool> > >(dvG)),
+        associative_property_map< std::map<vertex_descriptor, int> >(com_map)
+      );
+
+    if(cc != 2)
+      return;
+
+    // REC
+    detail::rec_two_graphs_common_spanning_trees<Graph, Func, Seq,
+        associative_property_map< std::map<edge_descriptor, bool> > >
+      (iG, iG_bimap, aiG_inL, diG, vG, vG_bimap, aiG_inL, dvG, func, inL);
+
+  }
+
+}
+
+
+template <
+  typename Graph,
+  typename Func,
+  typename Seq
+>
+BOOST_CONCEPT_REQUIRES(
+  ((IncidenceGraphConcept<Graph>))
+  ((EdgeListGraphConcept<Graph>)),
+  (void)
+)
+two_graphs_common_spanning_trees
+  (
+    const Graph& iG,
+    const Graph& vG,
+    Func func,
+    Seq inL
+  )
+{
+  typedef graph_traits<Graph> GraphTraits;
+
+  typedef typename GraphTraits::edge_descriptor edge_descriptor;
+  typedef typename GraphTraits::edge_iterator edge_iterator;
+
+  std::vector<edge_descriptor> iGO, vGO;
+  edge_iterator curr, last;
+
+  boost::tuples::tie(curr, last) = edges(iG);
+  for(; curr != last; ++curr)
+    iGO.push_back(*curr);
+
+  boost::tuples::tie(curr, last) = edges(vG);
+  for(; curr != last; ++curr)
+    vGO.push_back(*curr);
+
+  two_graphs_common_spanning_trees(iG, iGO, vG, vGO, func, inL);
+}
+
+
+} // namespace boost
+
+
+#endif // BOOST_GRAPH_TWO_GRAPHS_COMMON_SPANNING_TREES_HPP
diff --git a/include/boost/graph/undirected_dfs.hpp b/include/boost/graph/undirected_dfs.hpp
index 9cad25ad7..89cb10f28 100644
--- a/include/boost/graph/undirected_dfs.hpp
+++ b/include/boost/graph/undirected_dfs.hpp
@@ -13,6 +13,7 @@
 
 #include <boost/graph/depth_first_search.hpp>
 #include <vector>
+#include <boost/concept/assert.hpp>
 
 namespace boost {
 
@@ -32,31 +33,31 @@ namespace boost {
        VertexColorMap vertex_color,
        EdgeColorMap edge_color)
     {
-      function_requires<IncidenceGraphConcept<IncidenceGraph> >();
-      function_requires<DFSVisitorConcept<DFSVisitor, IncidenceGraph> >();
+      BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<IncidenceGraph> ));
+      BOOST_CONCEPT_ASSERT(( DFSVisitorConcept<DFSVisitor, IncidenceGraph> ));
       typedef typename graph_traits<IncidenceGraph>::vertex_descriptor Vertex;
       typedef typename graph_traits<IncidenceGraph>::edge_descriptor Edge;
-      function_requires<ReadWritePropertyMapConcept<VertexColorMap,Vertex> >();
-      function_requires<ReadWritePropertyMapConcept<EdgeColorMap,Edge> >();
+      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<VertexColorMap,Vertex> ));
+      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<EdgeColorMap,Edge> ));
       typedef typename property_traits<VertexColorMap>::value_type ColorValue;
       typedef typename property_traits<EdgeColorMap>::value_type EColorValue;
-      function_requires< ColorValueConcept<ColorValue> >();
-      function_requires< ColorValueConcept<EColorValue> >();
+      BOOST_CONCEPT_ASSERT(( ColorValueConcept<ColorValue> ));
+      BOOST_CONCEPT_ASSERT(( ColorValueConcept<EColorValue> ));
       typedef color_traits<ColorValue> Color;
       typedef color_traits<EColorValue> EColor;
       typedef typename graph_traits<IncidenceGraph>::out_edge_iterator Iter;
-      typedef std::pair<Vertex, std::pair<Iter, Iter> > VertexInfo;
+      typedef std::pair<Vertex, std::pair<boost::optional<Edge>, std::pair<Iter, Iter> > > VertexInfo;
 
       std::vector<VertexInfo> stack;
 
       put(vertex_color, u, Color::gray());
       vis.discover_vertex(u, g);
-      stack.push_back(std::make_pair(u, out_edges(u, g)));
+      stack.push_back(std::make_pair(u, std::make_pair(boost::optional<Edge>(), out_edges(u, g))));
       while (!stack.empty()) {
         VertexInfo& back = stack.back();
         u = back.first;
-        Iter ei, ei_end;
-        boost::tie(ei, ei_end) = back.second;
+        boost::optional<Edge> src_e = back.second.first;
+        Iter ei = back.second.second.first, ei_end = back.second.second.second;
         stack.pop_back();
         while (ei != ei_end) {
           Vertex v = target(*ei, g);
@@ -66,20 +67,24 @@ namespace boost {
           put(edge_color, *ei, EColor::black());
           if (v_color == Color::white()) {
             vis.tree_edge(*ei, g);
-            stack.push_back(std::make_pair(u, std::make_pair(++ei, ei_end)));
+            src_e = *ei;
+            stack.push_back(std::make_pair(u, std::make_pair(src_e, std::make_pair(++ei, ei_end))));
             u = v;
             put(vertex_color, u, Color::gray());
             vis.discover_vertex(u, g);
             boost::tie(ei, ei_end) = out_edges(u, g);
           } else if (v_color == Color::gray()) {
             if (uv_color == EColor::white()) vis.back_edge(*ei, g);
+            call_finish_edge(vis, *ei, g);
             ++ei;
           } else { // if (v_color == Color::black())
+            call_finish_edge(vis, *ei, g);
             ++ei;
           }
         }
         put(vertex_color, u, Color::black());
         vis.finish_vertex(u, g);
+        if (src_e) call_finish_edge(vis, src_e.get(), g);
       }
     }
 
@@ -94,16 +99,16 @@ namespace boost {
        VertexColorMap vertex_color,
        EdgeColorMap edge_color)
     {
-      function_requires<IncidenceGraphConcept<IncidenceGraph> >();
-      function_requires<DFSVisitorConcept<DFSVisitor, IncidenceGraph> >();
+      BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<IncidenceGraph> ));
+      BOOST_CONCEPT_ASSERT(( DFSVisitorConcept<DFSVisitor, IncidenceGraph> ));
       typedef typename graph_traits<IncidenceGraph>::vertex_descriptor Vertex;
       typedef typename graph_traits<IncidenceGraph>::edge_descriptor Edge;
-      function_requires<ReadWritePropertyMapConcept<VertexColorMap,Vertex> >();
-      function_requires<ReadWritePropertyMapConcept<EdgeColorMap,Edge> >();
+      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<VertexColorMap,Vertex> ));
+      BOOST_CONCEPT_ASSERT(( ReadWritePropertyMapConcept<EdgeColorMap,Edge> ));
       typedef typename property_traits<VertexColorMap>::value_type ColorValue;
       typedef typename property_traits<EdgeColorMap>::value_type EColorValue;
-      function_requires< ColorValueConcept<ColorValue> >();
-      function_requires< ColorValueConcept<EColorValue> >();
+      BOOST_CONCEPT_ASSERT(( ColorValueConcept<ColorValue> ));
+      BOOST_CONCEPT_ASSERT(( ColorValueConcept<EColorValue> ));
       typedef color_traits<ColorValue> Color;
       typedef color_traits<EColorValue> EColor;
       typename graph_traits<IncidenceGraph>::out_edge_iterator ei, ei_end;
@@ -118,6 +123,7 @@ namespace boost {
           undir_dfv_impl(g, v, vis, vertex_color, edge_color);
         } else if (v_color == Color::gray() && uv_color == EColor::white())
                                              vis.back_edge(*ei, g);
+                                             call_finish_edge(vis, *ei, g);
       }
       put(vertex_color, u, Color::black());  vis.finish_vertex(u, g);
     }
@@ -134,8 +140,8 @@ namespace boost {
                  VertexColorMap vertex_color, EdgeColorMap edge_color,
                  Vertex start_vertex)
   {
-    function_requires<DFSVisitorConcept<DFSVisitor, Graph> >();
-      function_requires<EdgeListGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( DFSVisitorConcept<DFSVisitor, Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
 
     typedef typename property_traits<VertexColorMap>::value_type ColorValue;
     typedef color_traits<ColorValue> Color;
@@ -187,7 +193,7 @@ namespace boost {
     };
 
     template <>
-    struct udfs_dispatch<detail::error_property_not_found> {
+    struct udfs_dispatch<param_not_found> {
       template <typename Graph, typename Vertex, typename DFSVisitor,
                 typename EdgeColorMap,
                 typename P, typename T, typename R>
@@ -195,7 +201,7 @@ namespace boost {
       apply(const Graph& g, DFSVisitor vis, Vertex start_vertex,
             const bgl_named_params<P, T, R>& params,
             EdgeColorMap edge_color,
-            detail::error_property_not_found)
+            param_not_found)
       {
         std::vector<default_color_type> color_vec(num_vertices(g));
         default_color_type c = white_color; // avoid warning about un-init
@@ -218,8 +224,7 @@ namespace boost {
   undirected_dfs(const Graph& g, 
                  const bgl_named_params<P, T, R>& params)
   {
-    typedef typename property_value< bgl_named_params<P, T, R>, 
-      vertex_color_t>::type C;
+    typedef typename get_param_type< vertex_color_t, bgl_named_params<P, T, R> >::type C;
     detail::udfs_dispatch<C>::apply
       (g,
        choose_param(get_param(params, graph_visitor),
diff --git a/include/boost/graph/undirected_graph.hpp b/include/boost/graph/undirected_graph.hpp
index d5374101e..5c000dc2a 100644
--- a/include/boost/graph/undirected_graph.hpp
+++ b/include/boost/graph/undirected_graph.hpp
@@ -7,14 +7,12 @@
 #ifndef BOOST_GRAPH_UNDIRECTED_GRAPH_HPP
 #define BOOST_GRAPH_UNDIRECTED_GRAPH_HPP
 
-#include <boost/utility.hpp>
 #include <boost/graph/adjacency_list.hpp>
 #include <boost/graph/properties.hpp>
-
-// NOTE: The retag_property_list is used to "normalize" a proeprty such that
-// any non-property conforming parameter is wrapped in a vertex_bundle
-// property. For example (with bad syntax) retag<property<X>> -> property<X>,
-// but retag<foo> -> property<vertex_bundle_t, foo>.
+#include <boost/pending/property.hpp>
+#include <boost/property_map/transform_value_property_map.hpp>
+#include <boost/type_traits.hpp>
+#include <boost/mpl/if.hpp>
 
 namespace boost
 {
@@ -38,25 +36,23 @@ template <
 class undirected_graph
 {
 public:
-    typedef typename graph_detail::graph_prop<GraphProp>::property graph_property_type;
-    typedef typename graph_detail::graph_prop<GraphProp>::bundle graph_bundled;
-
-    typedef typename graph_detail::vertex_prop<VertexProp>::property vertex_property_type;
-    typedef typename graph_detail::vertex_prop<VertexProp>::bundle vertex_bundled;
-
-    typedef typename graph_detail::edge_prop<EdgeProp>::property edge_property_type;
-    typedef typename graph_detail::edge_prop<EdgeProp>::bundle edge_bundled;
+    typedef GraphProp graph_property_type;
+    typedef VertexProp vertex_property_type;
+    typedef EdgeProp edge_property_type;
+    typedef typename lookup_one_property<GraphProp, graph_bundle_t>::type graph_bundled;
+    typedef typename lookup_one_property<VertexProp, vertex_bundle_t>::type vertex_bundled;
+    typedef typename lookup_one_property<EdgeProp, edge_bundle_t>::type edge_bundled;
 
-private:
+public:
     // Embed indices into the vertex type.
-    typedef property<vertex_index_t, unsigned, vertex_property_type> vertex_property;
-    typedef property<edge_index_t, unsigned, edge_property_type> edge_property;
+    typedef property<vertex_index_t, unsigned, vertex_property_type> internal_vertex_property;
+    typedef property<edge_index_t, unsigned, edge_property_type> internal_edge_property;
 public:
     typedef adjacency_list<listS,
                 listS,
                 undirectedS,
-                vertex_property,
-                edge_property,
+                internal_vertex_property,
+                internal_edge_property,
                 GraphProp,
                 listS> graph_type;
 private:
@@ -159,7 +155,7 @@ class undirected_graph
     { return make_index(boost::add_vertex(m_graph)); }
 
     vertex_descriptor add_vertex(vertex_property_type const& p)
-    { return make_index(boost::add_vertex(vertex_property(0u, p), m_graph)); }
+    { return make_index(boost::add_vertex(internal_vertex_property(0u, p), m_graph)); }
 
     void clear_vertex(vertex_descriptor v) {
         std::pair<out_edge_iterator, out_edge_iterator>
@@ -196,7 +192,7 @@ class undirected_graph
     std::pair<edge_descriptor, bool>
     add_edge(vertex_descriptor u, vertex_descriptor v,
              edge_property_type const& p)
-    { return make_index(boost::add_edge(u, v, edge_property(0u, p), m_graph)); }
+    { return make_index(boost::add_edge(u, v, internal_edge_property(0u, p), m_graph)); }
 
     void remove_edge(vertex_descriptor u, vertex_descriptor v) {
         // find all edges, (u, v)
@@ -413,7 +409,7 @@ template <UNDIRECTED_GRAPH_PARAMS>
 typename UNDIRECTED_GRAPH::vertex_descriptor
 vertex(typename UNDIRECTED_GRAPH::vertices_size_type n,
        UNDIRECTED_GRAPH const& g)
-{ return vertex(g.impl()); }
+{ return vertex(n, g.impl()); }
 
 template <UNDIRECTED_GRAPH_PARAMS>
 std::pair<typename UNDIRECTED_GRAPH::edge_descriptor, bool>
@@ -530,36 +526,32 @@ remove_in_edge_if(typename UNDIRECTED_GRAPH::vertex_descriptor v,
                   UNDIRECTED_GRAPH& g)
 { return remove_in_edge_if(v, pred, g.impl()); }
 
-// Helper code for working with property maps
-namespace detail {
-    struct undirected_graph_vertex_property_selector {
-        template <class UndirectedGraph, class Property, class Tag>
-        struct bind_ {
-            typedef typename UndirectedGraph::graph_type Graph;
-            typedef property_map<Graph, Tag> PropertyMap;
-            typedef typename PropertyMap::type type;
-            typedef typename PropertyMap::const_type const_type;
-        };
-    };
-
-    struct undirected_graph_edge_property_selector {
-        template <class UndirectedGraph, class Property, class Tag>
-        struct bind_ {
-            typedef typename UndirectedGraph::graph_type Graph;
-            typedef property_map<Graph, Tag> PropertyMap;
-            typedef typename PropertyMap::type type;
-            typedef typename PropertyMap::const_type const_type;
-        };
-    };
-} // namespace detail
-
-template <>
-struct vertex_property_selector<undirected_graph_tag>
-{ typedef detail::undirected_graph_vertex_property_selector type; };
-
-template <>
-struct edge_property_selector<undirected_graph_tag>
-{ typedef detail::undirected_graph_edge_property_selector type; };
+template <UNDIRECTED_GRAPH_PARAMS, typename Property>
+struct property_map<UNDIRECTED_GRAPH, Property>: property_map<typename UNDIRECTED_GRAPH::graph_type, Property> {};
+
+template <UNDIRECTED_GRAPH_PARAMS>
+struct property_map<UNDIRECTED_GRAPH, vertex_all_t> {
+  typedef transform_value_property_map<
+            detail::remove_first_property,
+            typename property_map<typename UNDIRECTED_GRAPH::graph_type, vertex_all_t>::const_type>
+    const_type;
+  typedef transform_value_property_map<
+            detail::remove_first_property,
+            typename property_map<typename UNDIRECTED_GRAPH::graph_type, vertex_all_t>::type>
+    type;
+};
+
+template <UNDIRECTED_GRAPH_PARAMS>
+struct property_map<UNDIRECTED_GRAPH, edge_all_t> {
+  typedef transform_value_property_map<
+            detail::remove_first_property,
+            typename property_map<typename UNDIRECTED_GRAPH::graph_type, edge_all_t>::const_type>
+    const_type;
+  typedef transform_value_property_map<
+            detail::remove_first_property,
+            typename property_map<typename UNDIRECTED_GRAPH::graph_type, edge_all_t>::type>
+    type;
+};
 
 // PropertyGraph concepts
 template <UNDIRECTED_GRAPH_PARAMS, typename Property>
@@ -572,6 +564,26 @@ inline typename property_map<UNDIRECTED_GRAPH, Property>::const_type
 get(Property p, UNDIRECTED_GRAPH const& g)
 { return get(p, g.impl()); }
 
+template <UNDIRECTED_GRAPH_PARAMS>
+inline typename property_map<UNDIRECTED_GRAPH, vertex_all_t>::type
+get(vertex_all_t, UNDIRECTED_GRAPH& g)
+{ return typename property_map<UNDIRECTED_GRAPH, vertex_all_t>::type(detail::remove_first_property(), get(vertex_all, g.impl())); }
+
+template <UNDIRECTED_GRAPH_PARAMS>
+inline typename property_map<UNDIRECTED_GRAPH, vertex_all_t>::const_type
+get(vertex_all_t, UNDIRECTED_GRAPH const& g)
+{ return typename property_map<UNDIRECTED_GRAPH, vertex_all_t>::const_type(detail::remove_first_property(), get(vertex_all, g.impl())); }
+
+template <UNDIRECTED_GRAPH_PARAMS>
+inline typename property_map<UNDIRECTED_GRAPH, edge_all_t>::type
+get(edge_all_t, UNDIRECTED_GRAPH& g)
+{ return typename property_map<UNDIRECTED_GRAPH, edge_all_t>::type(detail::remove_first_property(), get(edge_all, g.impl())); }
+
+template <UNDIRECTED_GRAPH_PARAMS>
+inline typename property_map<UNDIRECTED_GRAPH, edge_all_t>::const_type
+get(edge_all_t, UNDIRECTED_GRAPH const& g)
+{ return typename property_map<UNDIRECTED_GRAPH, edge_all_t>::const_type(detail::remove_first_property(), get(edge_all, g.impl())); }
+
 template <UNDIRECTED_GRAPH_PARAMS, typename Property, typename Key>
 inline typename property_traits<
     typename property_map<
@@ -581,10 +593,40 @@ inline typename property_traits<
 get(Property p, UNDIRECTED_GRAPH const& g, Key const& k)
 { return get(p, g.impl(), k); }
 
+template <UNDIRECTED_GRAPH_PARAMS, typename Key>
+inline typename property_traits<
+    typename property_map<
+        typename UNDIRECTED_GRAPH::graph_type, vertex_all_t
+    >::const_type
+>::value_type
+get(vertex_all_t, UNDIRECTED_GRAPH const& g, Key const& k)
+{ return get(vertex_all, g.impl(), k).m_base; }
+
+template <UNDIRECTED_GRAPH_PARAMS, typename Key>
+inline typename property_traits<
+    typename property_map<
+        typename UNDIRECTED_GRAPH::graph_type, edge_all_t
+    >::const_type
+>::value_type
+get(edge_all_t, UNDIRECTED_GRAPH const& g, Key const& k)
+{ return get(edge_all, g.impl(), k).m_base; }
+
 template <UNDIRECTED_GRAPH_PARAMS, typename Property, typename Key, typename Value>
 inline void put(Property p, UNDIRECTED_GRAPH& g, Key const& k, Value const& v)
 { put(p, g.impl(), k, v); }
 
+template <UNDIRECTED_GRAPH_PARAMS, typename Key, typename Value>
+inline void put(vertex_all_t, UNDIRECTED_GRAPH& g, Key const& k, Value const& v)
+{ put(vertex_all, g.impl(), k,
+      typename UNDIRECTED_GRAPH::internal_vertex_property(get(vertex_index, g.impl(), k), v));
+}
+
+template <UNDIRECTED_GRAPH_PARAMS, typename Key, typename Value>
+inline void put(edge_all_t, UNDIRECTED_GRAPH& g, Key const& k, Value const& v)
+{ put(edge_all, g.impl(), k,
+      typename UNDIRECTED_GRAPH::internal_vertex_property(get(edge_index, g.impl(), k), v));
+}
+
 template <UNDIRECTED_GRAPH_PARAMS, class Property>
 inline typename graph_property<UNDIRECTED_GRAPH, Property>::type&
 get_property(UNDIRECTED_GRAPH& g, Property p)
@@ -599,36 +641,6 @@ template <UNDIRECTED_GRAPH_PARAMS, class Property, class Value>
 inline void set_property(UNDIRECTED_GRAPH& g, Property p, Value v)
 { return set_property(g.impl(), p, v); }
 
-#ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES
-template <UNDIRECTED_GRAPH_PARAMS, typename Type, typename Bundle>
-inline typename property_map<UNDIRECTED_GRAPH, Type Bundle::*>::type
-get(Type Bundle::* p, UNDIRECTED_GRAPH& g) {
-    typedef typename property_map<
-        UNDIRECTED_GRAPH, Type Bundle::*
-    >::type return_type;
-    return return_type(&g, p);
-}
-
-template <UNDIRECTED_GRAPH_PARAMS, typename Type, typename Bundle>
-inline typename property_map<UNDIRECTED_GRAPH, Type Bundle::*>::const_type
-get(Type Bundle::* p, UNDIRECTED_GRAPH const& g) {
-    typedef typename property_map<
-        UNDIRECTED_GRAPH, Type Bundle::*
-    >::const_type return_type;
-    return return_type(&g, p);
-}
-
-template <UNDIRECTED_GRAPH_PARAMS, typename Type, typename Bundle, typename Key>
-inline Type
-get(Type Bundle::* p, UNDIRECTED_GRAPH const& g, Key const& k)
-{ return get(p, g.impl(), k); }
-
-template <UNDIRECTED_GRAPH_PARAMS, typename Type, typename Bundle, typename Key, typename Value>
-inline void
-put(Type Bundle::* p, UNDIRECTED_GRAPH& g, Key const& k, Value const& v)
-{ put(p, g.impl(), k, v); }
-#endif
-
 // Indexed Vertex graph
 
 template <UNDIRECTED_GRAPH_PARAMS>
diff --git a/include/boost/graph/vector_as_graph.hpp b/include/boost/graph/vector_as_graph.hpp
index ee0df4bc9..b771eaf7f 100644
--- a/include/boost/graph/vector_as_graph.hpp
+++ b/include/boost/graph/vector_as_graph.hpp
@@ -19,6 +19,7 @@
 #include <vector>
 #include <cstddef>
 #include <boost/iterator.hpp>
+#include <boost/iterator/counting_iterator.hpp>
 #include <boost/range/irange.hpp>
 #include <boost/graph/graph_traits.hpp>
 #include <boost/property_map/property_map.hpp>
@@ -39,9 +40,6 @@
 
 */
 
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-#error The vector-as-graph module requires a compiler that supports partial specialization
-#endif
 
 
 namespace boost {
@@ -52,7 +50,6 @@ namespace boost {
   }
 }
 
-#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 namespace boost {
 
   struct vector_as_graph_traversal_tag
@@ -71,13 +68,14 @@ namespace boost {
       out_edge_iterator;
     typedef void in_edge_iterator;
     typedef void edge_iterator;
-    typedef typename integer_range<V>::iterator vertex_iterator;
+    typedef counting_iterator<V> vertex_iterator;
     typedef directed_tag directed_category;
     typedef allow_parallel_edge_tag edge_parallel_category;
     typedef vector_as_graph_traversal_tag traversal_category;
     typedef typename std::vector<EdgeList>::size_type vertices_size_type;
     typedef void edges_size_type;
     typedef typename EdgeList::size_type degree_size_type;
+    static V null_vertex() {return V(-1);}
   };
   template <class EdgeList>
   struct edge_property_type< std::vector<EdgeList> >
@@ -95,7 +93,6 @@ namespace boost {
     typedef void type;
   };
 }
-#endif
 
 namespace boost {
 
@@ -178,14 +175,11 @@ namespace boost {
   // source() and target() already provided for pairs in graph_traits.hpp
 
   template <class EdgeList, class Alloc>
-  std::pair<typename boost::integer_range<typename EdgeList::value_type>
-              ::iterator,
-            typename boost::integer_range<typename EdgeList::value_type>
-              ::iterator >
+  std::pair<boost::counting_iterator<typename EdgeList::value_type>,
+            boost::counting_iterator<typename EdgeList::value_type> >
   vertices(const std::vector<EdgeList, Alloc>& v)
   {
-    typedef typename boost::integer_range<typename EdgeList::value_type>
-      ::iterator Iter;
+    typedef boost::counting_iterator<typename EdgeList::value_type> Iter;
     return std::make_pair(Iter(0), Iter(v.size()));
   }
 
diff --git a/include/boost/graph/vf2_sub_graph_iso.hpp b/include/boost/graph/vf2_sub_graph_iso.hpp
new file mode 100644
index 000000000..f86b6ee2a
--- /dev/null
+++ b/include/boost/graph/vf2_sub_graph_iso.hpp
@@ -0,0 +1,1233 @@
+//=======================================================================
+// Copyright (C) 2012 Flavio De Lorenzi (fdlorenzi@gmail.com)
+// Copyright (C) 2013 Jakob Lykke Andersen, University of Southern Denmark (jlandersen@imada.sdu.dk)
+//
+// The algorithm implemented here is derived from original ideas by 
+// Pasquale Foggia and colaborators. For further information see 
+// e.g. Cordella et al. 2001, 2004.
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//=======================================================================
+
+// Revision History:
+//   8 April 2013: Fixed a typo in vf2_print_callback. (Flavio De Lorenzi) 
+
+#ifndef BOOST_VF2_SUB_GRAPH_ISO_HPP
+#define BOOST_VF2_SUB_GRAPH_ISO_HPP
+
+#include <iostream>
+#include <iomanip>
+#include <iterator>
+#include <vector>
+#include <utility>
+
+#include <boost/assert.hpp>
+#include <boost/concept/assert.hpp>
+#include <boost/concept_check.hpp>
+#include <boost/graph/graph_utility.hpp>
+#include <boost/graph/graph_traits.hpp>
+#include <boost/graph/mcgregor_common_subgraphs.hpp> // for always_equivalent
+#include <boost/graph/named_function_params.hpp>
+#include <boost/type_traits/has_less.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/range/algorithm/sort.hpp>
+#include <boost/tuple/tuple.hpp>
+#include <boost/utility/enable_if.hpp>
+
+#ifndef BOOST_GRAPH_ITERATION_MACROS_HPP
+#define BOOST_ISO_INCLUDED_ITER_MACROS // local macro, see bottom of file
+#include <boost/graph/iteration_macros.hpp>
+#endif
+
+namespace boost {
+  
+  // Default print_callback
+  template <typename Graph1,
+            typename Graph2>
+  struct vf2_print_callback {
+    
+    vf2_print_callback(const Graph1& graph1, const Graph2& graph2) 
+      : graph1_(graph1), graph2_(graph2) {}
+    
+    template <typename CorrespondenceMap1To2,
+              typename CorrespondenceMap2To1>
+    bool operator()(CorrespondenceMap1To2 f, CorrespondenceMap2To1) const {
+      
+      // Print (sub)graph isomorphism map
+      BGL_FORALL_VERTICES_T(v, graph1_, Graph1) 
+        std::cout << '(' << get(vertex_index_t(), graph1_, v) << ", " 
+                  << get(vertex_index_t(), graph2_, get(f, v)) << ") ";
+      
+      std::cout << std::endl;
+      
+      return true;
+    }
+    
+  private:
+    const Graph1& graph1_;
+    const Graph2& graph2_;
+  };
+  
+  namespace detail {
+    
+    // State associated with a single graph (graph_this)
+    template<typename GraphThis,
+             typename GraphOther,
+             typename IndexMapThis,
+             typename IndexMapOther>
+    class base_state {
+      
+      typedef typename graph_traits<GraphThis>::vertex_descriptor vertex_this_type;
+      typedef typename graph_traits<GraphOther>::vertex_descriptor vertex_other_type;
+      
+      typedef typename graph_traits<GraphThis>::vertices_size_type size_type;
+      
+      const GraphThis& graph_this_;
+      const GraphOther& graph_other_;
+      
+      IndexMapThis index_map_this_;
+      IndexMapOther index_map_other_;
+      
+      std::vector<vertex_other_type> core_vec_;
+      typedef iterator_property_map<typename std::vector<vertex_other_type>::iterator,
+                                    IndexMapThis, vertex_other_type, 
+                                    vertex_other_type&> core_map_type;
+      core_map_type core_;
+    
+      std::vector<size_type> in_vec_, out_vec_;
+      typedef iterator_property_map<typename std::vector<size_type>::iterator,
+                                    IndexMapThis, size_type, size_type&> in_out_map_type;
+      in_out_map_type in_, out_;
+
+      size_type term_in_count_, term_out_count_, term_both_count_, core_count_;
+
+      // Forbidden 
+      base_state(const base_state&);
+      base_state& operator=(const base_state&);
+
+    public:
+
+      base_state(const GraphThis& graph_this, const GraphOther& graph_other,
+                 IndexMapThis index_map_this, IndexMapOther index_map_other)
+        : graph_this_(graph_this), graph_other_(graph_other), 
+          index_map_this_(index_map_this), index_map_other_(index_map_other), 
+          term_in_count_(0), term_out_count_(0), term_both_count_(0), core_count_(0) {
+
+        core_vec_.resize(num_vertices(graph_this_), graph_traits<GraphOther>::null_vertex());
+        core_ = make_iterator_property_map(core_vec_.begin(), index_map_this_);
+
+        in_vec_.resize(num_vertices(graph_this_), 0);
+        in_ = make_iterator_property_map(in_vec_.begin(), index_map_this_);
+
+        out_vec_.resize(num_vertices(graph_this_), 0);
+        out_ = make_iterator_property_map(out_vec_.begin(), index_map_this_);
+      }
+
+      // Adds a vertex pair to the state of graph graph_this
+      void push(const vertex_this_type& v_this, const vertex_other_type& v_other) {
+
+        ++core_count_;
+
+        put(core_, v_this, v_other);
+
+        if (!get(in_, v_this)) {   
+          put(in_, v_this, core_count_);
+          ++term_in_count_;
+          if (get(out_, v_this))
+            ++term_both_count_;
+        }
+
+        if (!get(out_, v_this)) {   
+          put(out_, v_this, core_count_);
+          ++term_out_count_;
+          if (get(in_, v_this))
+            ++term_both_count_;
+        }
+
+        BGL_FORALL_INEDGES_T(v_this, e, graph_this_, GraphThis) {
+          vertex_this_type w = source(e, graph_this_);
+          if (!get(in_, w)) {
+            put(in_, w, core_count_);
+            ++term_in_count_;
+            if (get(out_, w))
+              ++term_both_count_;
+          }
+        }
+        
+        BGL_FORALL_OUTEDGES_T(v_this, e, graph_this_, GraphThis) {
+          vertex_this_type w = target(e, graph_this_);
+          if (!get(out_, w)) {
+            put(out_, w, core_count_);
+            ++term_out_count_;
+            if (get(in_, w))
+              ++term_both_count_;                        
+          }
+        }
+        
+      }
+
+      // Removes vertex pair from state of graph_this
+      void pop(const vertex_this_type& v_this, const vertex_other_type&) {
+        
+        if (!core_count_) return;
+        
+        if (get(in_, v_this) == core_count_) {
+          put(in_, v_this, 0);
+          --term_in_count_;
+          if (get(out_, v_this))
+            --term_both_count_;
+        }
+
+        BGL_FORALL_INEDGES_T(v_this, e, graph_this_, GraphThis) {
+          vertex_this_type w = source(e, graph_this_);
+          if (get(in_, w) == core_count_) {
+            put(in_, w, 0);
+            --term_in_count_;
+            if (get(out_, w))
+              --term_both_count_;
+          }
+        }
+
+        if (get(out_, v_this) == core_count_) {
+          put(out_, v_this, 0);
+          --term_out_count_;
+          if (get(in_, v_this))
+            --term_both_count_;
+        }
+
+        BGL_FORALL_OUTEDGES_T(v_this, e, graph_this_, GraphThis) {
+          vertex_this_type w = target(e, graph_this_);
+          if (get(out_, w) == core_count_) {
+            put(out_, w, 0);
+            --term_out_count_;
+            if (get(in_, w))
+              --term_both_count_;
+          }
+        }
+        put(core_, v_this, graph_traits<GraphOther>::null_vertex());
+
+        --core_count_;
+        
+      }
+            
+      // Returns true if the in-terminal set is not empty  
+      bool term_in() const {
+        return core_count_ < term_in_count_ ;
+      }
+
+      // Returns true if vertex belongs to the in-terminal set
+      bool term_in(const vertex_this_type& v) const {
+        return (get(in_, v) > 0) &&
+               (get(core_, v) == graph_traits<GraphOther>::null_vertex());
+      }
+            
+      // Returns true if the out-terminal set is not empty  
+      bool term_out() const {
+        return core_count_ < term_out_count_;
+      }
+
+      // Returns true if vertex belongs to the out-terminal set
+      bool term_out(const vertex_this_type& v) const {
+        return (get(out_, v) > 0) && 
+               (get(core_, v) == graph_traits<GraphOther>::null_vertex());
+      }
+
+      // Returns true of both (in- and out-terminal) sets are not empty
+      bool term_both() const {
+        return core_count_ < term_both_count_;
+      }
+
+      // Returns true if vertex belongs to both (in- and out-terminal) sets
+      bool term_both(const vertex_this_type& v) const {
+        return (get(in_, v) > 0) && (get(out_, v) > 0) && 
+               (get(core_, v) == graph_traits<GraphOther>::null_vertex());
+      }
+
+      // Returns true if vertex belongs to the core map, i.e. it is in the 
+      // present mapping
+      bool in_core(const vertex_this_type& v) const {
+        return get(core_, v) != graph_traits<GraphOther>::null_vertex();
+      }
+
+      // Returns the number of vertices in the mapping
+      size_type count() const {
+        return core_count_;
+      }            
+
+      // Returns the image (in graph_other) of vertex v (in graph_this)
+      vertex_other_type core(const vertex_this_type& v) const {
+        return get(core_, v);
+      }
+
+      // Returns the mapping
+      core_map_type get_map() const {
+        return core_;
+      }
+
+      // Returns the "time" (or depth) when vertex was added to the in-terminal set
+      size_type in_depth(const vertex_this_type& v) const {
+        return get(in_, v);
+      }
+
+      // Returns the "time" (or depth) when vertex was added to the out-terminal set
+      size_type out_depth(const vertex_this_type& v) const {
+        return get(out_, v);
+      }            
+
+      // Returns the terminal set counts
+      boost::tuple<size_type, size_type, size_type>
+      term_set() const {
+        return boost::make_tuple(term_in_count_, term_out_count_, 
+                                 term_both_count_);
+      }
+      
+    };
+
+
+    // Function object that checks whether a valid edge
+    // exists. For multi-graphs matched edges are excluded  
+    template <typename Graph, typename Enable = void>
+    struct equivalent_edge_exists {
+      typedef typename boost::graph_traits<Graph>::edge_descriptor edge_type;
+
+      BOOST_CONCEPT_ASSERT(( LessThanComparable<edge_type> ));
+
+      template<typename EdgePredicate>
+      bool operator()(typename graph_traits<Graph>::vertex_descriptor s,
+                      typename graph_traits<Graph>::vertex_descriptor t, 
+                      EdgePredicate is_valid_edge, const Graph& g) {
+        
+        BGL_FORALL_OUTEDGES_T(s, e, g, Graph) {
+          if ((target(e, g) == t) && is_valid_edge(e) && 
+              (matched_edges_.find(e) == matched_edges_.end())) {
+            matched_edges_.insert(e);
+            return true;
+          }
+        }
+
+        return false;
+      }
+
+    private:
+      
+      std::set<edge_type> matched_edges_;
+    };
+    
+    template <typename Graph>
+    struct equivalent_edge_exists<Graph, typename boost::disable_if<is_multigraph<Graph> >::type> {
+      template<typename EdgePredicate>
+      bool operator()(typename graph_traits<Graph>::vertex_descriptor s,
+                      typename graph_traits<Graph>::vertex_descriptor t, 
+                      EdgePredicate is_valid_edge, const Graph& g) {
+        
+        typename graph_traits<Graph>::edge_descriptor e;
+        bool found;
+        boost::tie(e, found) = edge(s, t, g);
+        if (!found)
+          return false;
+        else if (is_valid_edge(e))
+          return true;
+        
+        return false;
+      }
+      
+    };
+
+
+    // Generates a predicate for edge e1 given  a binary predicate and a 
+    // fixed edge e2
+    template <typename Graph1,
+              typename Graph2,
+              typename EdgeEquivalencePredicate>
+    struct edge1_predicate {
+      
+      edge1_predicate(EdgeEquivalencePredicate edge_comp, 
+                      typename graph_traits<Graph2>::edge_descriptor e2)
+        : edge_comp_(edge_comp), e2_(e2) {}
+      
+      bool operator()(typename graph_traits<Graph1>::edge_descriptor e1) {
+        return edge_comp_(e1, e2_);
+      }
+
+      EdgeEquivalencePredicate edge_comp_;
+      typename graph_traits<Graph2>::edge_descriptor e2_;
+    };
+
+
+    // Generates a predicate for edge e2 given given a binary predicate and a
+    // fixed edge e1
+    template <typename Graph1,
+              typename Graph2,
+              typename EdgeEquivalencePredicate>
+    struct edge2_predicate {
+      
+      edge2_predicate(EdgeEquivalencePredicate edge_comp, 
+                      typename graph_traits<Graph1>::edge_descriptor e1)
+        : edge_comp_(edge_comp), e1_(e1) {}
+
+      bool operator()(typename graph_traits<Graph2>::edge_descriptor e2) {
+        return edge_comp_(e1_, e2);
+      }
+
+      EdgeEquivalencePredicate edge_comp_;
+      typename graph_traits<Graph1>::edge_descriptor e1_;
+    };
+
+
+    enum problem_selector {subgraph_mono, subgraph_iso, isomorphism };
+    
+    // The actual state associated with both graphs
+    template<typename Graph1,
+             typename Graph2,
+             typename IndexMap1,
+             typename IndexMap2,
+             typename EdgeEquivalencePredicate,
+             typename VertexEquivalencePredicate,
+             typename SubGraphIsoMapCallback,
+             problem_selector problem_selection>
+    class state {
+
+      typedef typename graph_traits<Graph1>::vertex_descriptor vertex1_type;
+      typedef typename graph_traits<Graph2>::vertex_descriptor vertex2_type;
+
+      typedef typename graph_traits<Graph1>::edge_descriptor edge1_type;
+      typedef typename graph_traits<Graph2>::edge_descriptor edge2_type;
+
+      typedef typename graph_traits<Graph1>::vertices_size_type graph1_size_type;
+      typedef typename graph_traits<Graph2>::vertices_size_type graph2_size_type;
+
+      const Graph1& graph1_;
+      const Graph2& graph2_;
+      
+      IndexMap1 index_map1_;
+      
+      EdgeEquivalencePredicate edge_comp_;
+      VertexEquivalencePredicate vertex_comp_;
+                
+      base_state<Graph1, Graph2, IndexMap1, IndexMap2> state1_;
+      base_state<Graph2, Graph1, IndexMap2, IndexMap1> state2_;
+
+      // Three helper functions used in Feasibility and Valid functions to test
+      // terminal set counts when testing for:
+      // - graph sub-graph monomorphism, or
+      inline bool comp_term_sets(graph1_size_type a, 
+                                 graph2_size_type b,
+                                 boost::mpl::int_<subgraph_mono>) const {
+        return a <= b;
+      }
+
+      // - graph sub-graph isomorphism, or
+      inline bool comp_term_sets(graph1_size_type a, 
+                                 graph2_size_type b,
+                                 boost::mpl::int_<subgraph_iso>) const {
+        return a <= b;
+      }
+
+      // - graph isomorphism
+      inline bool comp_term_sets(graph1_size_type a, 
+                                 graph2_size_type b,
+                                 boost::mpl::int_<isomorphism>) const {
+        return a == b;
+      }
+      
+      // Forbidden 
+      state(const state&);
+      state& operator=(const state&);
+
+    public:
+
+      state(const Graph1& graph1, const Graph2& graph2, 
+            IndexMap1 index_map1, IndexMap2 index_map2, 
+            EdgeEquivalencePredicate edge_comp,
+            VertexEquivalencePredicate vertex_comp)
+        : graph1_(graph1), graph2_(graph2), 
+          index_map1_(index_map1), 
+          edge_comp_(edge_comp), vertex_comp_(vertex_comp),
+          state1_(graph1, graph2, index_map1, index_map2), 
+          state2_(graph2, graph1, index_map2, index_map1) {}
+      
+            // Add vertex pair to the state
+      void push(const vertex1_type& v, const vertex2_type& w) {
+        state1_.push(v, w);
+        state2_.push(w, v);
+      }
+      
+      // Remove vertex pair from state
+      void pop(const vertex1_type& v, const vertex2_type&) {
+        vertex2_type w = state1_.core(v);
+        state1_.pop(v, w);
+        state2_.pop(w, v);
+      }
+           
+      // Checks the feasibility of a new vertex pair
+      bool feasible(const vertex1_type& v_new, const vertex2_type& w_new) {
+        
+        if (!vertex_comp_(v_new, w_new)) return false;
+        
+        // graph1
+        graph1_size_type term_in1_count = 0, term_out1_count = 0, rest1_count = 0;
+        
+        {
+          equivalent_edge_exists<Graph2> edge2_exists;
+          
+          BGL_FORALL_INEDGES_T(v_new, e1, graph1_, Graph1) {
+            vertex1_type v = source(e1, graph1_);
+            
+            if (state1_.in_core(v) || (v == v_new)) {
+              vertex2_type w = w_new;
+              if (v != v_new)
+                w = state1_.core(v);
+              if (!edge2_exists(w, w_new,
+                                edge2_predicate<Graph1, Graph2, EdgeEquivalencePredicate>(edge_comp_, e1), 
+                                graph2_))
+                return false;
+              
+            } else {
+              if (0 < state1_.in_depth(v))
+                ++term_in1_count;
+              if (0 < state1_.out_depth(v))
+                ++term_out1_count;
+              if ((state1_.in_depth(v) == 0) && (state1_.out_depth(v) == 0))
+                ++rest1_count;
+            }
+          }
+        }
+        
+        {
+          equivalent_edge_exists<Graph2> edge2_exists;
+          
+          BGL_FORALL_OUTEDGES_T(v_new, e1, graph1_, Graph1) {
+            vertex1_type v = target(e1, graph1_);
+            if (state1_.in_core(v) || (v == v_new)) {
+              vertex2_type w = w_new;
+              if (v != v_new)
+                w = state1_.core(v);
+              
+              if (!edge2_exists(w_new, w,
+                                edge2_predicate<Graph1, Graph2, EdgeEquivalencePredicate>(edge_comp_, e1), 
+                                graph2_))
+                return false;
+              
+            } else {
+              if (0 < state1_.in_depth(v))
+                ++term_in1_count;
+              if (0 < state1_.out_depth(v))
+                ++term_out1_count;
+              if ((state1_.in_depth(v) == 0) && (state1_.out_depth(v) == 0))
+                ++rest1_count;
+            }
+          }
+        }
+        
+        // graph2
+        graph2_size_type term_out2_count = 0, term_in2_count = 0, rest2_count = 0;
+        
+        {
+          equivalent_edge_exists<Graph1> edge1_exists;
+          
+          BGL_FORALL_INEDGES_T(w_new, e2, graph2_, Graph2) {
+            vertex2_type w = source(e2, graph2_);
+            if (state2_.in_core(w) || (w == w_new)) {
+              if (problem_selection != subgraph_mono) {
+                vertex1_type v = v_new;
+                if (w != w_new)
+                  v = state2_.core(w);
+              
+                if (!edge1_exists(v, v_new,
+                                  edge1_predicate<Graph1, Graph2, EdgeEquivalencePredicate>(edge_comp_, e2), 
+                                  graph1_))
+                  return false;
+              }
+            } else {
+              if (0 < state2_.in_depth(w))
+                ++term_in2_count;
+              if (0 < state2_.out_depth(w))
+                ++term_out2_count;
+              if ((state2_.in_depth(w) == 0) && (state2_.out_depth(w) == 0))
+                ++rest2_count;
+            }
+          }
+        }
+
+        {
+          equivalent_edge_exists<Graph1> edge1_exists;
+          
+          BGL_FORALL_OUTEDGES_T(w_new, e2, graph2_, Graph2) {
+            vertex2_type w = target(e2, graph2_);
+            if (state2_.in_core(w) || (w == w_new)) {
+              if (problem_selection != subgraph_mono) {
+                vertex1_type v = v_new;
+                if (w != w_new)
+                  v = state2_.core(w);
+              
+                if (!edge1_exists(v_new, v,
+                                  edge1_predicate<Graph1, Graph2, EdgeEquivalencePredicate>(edge_comp_, e2), 
+                                  graph1_))
+                  return false;
+              }
+            } else {
+              if (0 < state2_.in_depth(w))
+                ++term_in2_count;
+              if (0 < state2_.out_depth(w))
+                ++term_out2_count;
+              if ((state2_.in_depth(w) == 0) && (state2_.out_depth(w) == 0))
+                ++rest2_count;
+            }
+          }
+        }
+
+        if (problem_selection != subgraph_mono) { // subgraph_iso and isomorphism
+          return comp_term_sets(term_in1_count, term_in2_count,
+                                boost::mpl::int_<problem_selection>()) &&
+                 comp_term_sets(term_out1_count, term_out2_count, 
+                                boost::mpl::int_<problem_selection>()) &&
+                 comp_term_sets(rest1_count, rest2_count, 
+                                boost::mpl::int_<problem_selection>());
+        } else { // subgraph_mono
+          return comp_term_sets(term_in1_count, term_in2_count,
+                                boost::mpl::int_<problem_selection>()) &&
+                 comp_term_sets(term_out1_count, term_out2_count, 
+                                boost::mpl::int_<problem_selection>()) &&
+                 comp_term_sets(term_in1_count + term_out1_count + rest1_count,
+                                term_in2_count + term_out2_count + rest2_count, 
+                                boost::mpl::int_<problem_selection>());
+        }
+      }
+      
+      // Returns true if vertex v in graph1 is a possible candidate to
+      // be added to the current state
+      bool possible_candidate1(const vertex1_type& v) const {
+        if (state1_.term_both() && state2_.term_both()) 
+          return state1_.term_both(v);
+        else if (state1_.term_out() && state2_.term_out())
+          return state1_.term_out(v);
+        else if (state1_.term_in() && state2_.term_in())
+          return state1_.term_in(v);
+        else
+          return !state1_.in_core(v);
+      }
+
+      // Returns true if vertex w in graph2 is a possible candidate to
+      // be added to the current state
+      bool possible_candidate2(const vertex2_type& w) const {
+        if (state1_.term_both() && state2_.term_both()) 
+          return state2_.term_both(w);
+        else if (state1_.term_out() && state2_.term_out())
+          return state2_.term_out(w);
+        else if (state1_.term_in() && state2_.term_in())
+          return state2_.term_in(w);
+        else
+          return !state2_.in_core(w);
+      }
+
+      // Returns true if a mapping was found
+      bool success() const {
+        return state1_.count() == num_vertices(graph1_);
+      }
+ 
+      // Returns true if a state is valid
+      bool valid() const {
+        boost::tuple<graph1_size_type, graph1_size_type, graph1_size_type> term1;
+        boost::tuple<graph2_size_type, graph2_size_type, graph2_size_type> term2;
+        
+        term1 = state1_.term_set();
+        term2 = state2_.term_set();
+        
+        return comp_term_sets(boost::get<0>(term1), boost::get<0>(term2),
+                              boost::mpl::int_<problem_selection>()) &&
+               comp_term_sets(boost::get<1>(term1), boost::get<1>(term2),
+                              boost::mpl::int_<problem_selection>()) &&
+               comp_term_sets(boost::get<2>(term1), boost::get<2>(term2),
+                              boost::mpl::int_<problem_selection>()); 
+      }
+      
+      // Calls the user_callback with a graph (sub)graph mapping 
+      bool call_back(SubGraphIsoMapCallback user_callback) const {
+        return user_callback(state1_.get_map(), state2_.get_map());
+      }
+      
+    };
+
+    
+    // Data structure to keep info used for back tracking during
+    // matching process
+    template<typename Graph1,
+             typename Graph2,
+             typename VertexOrder1>
+    struct vf2_match_continuation {
+      typename VertexOrder1::const_iterator graph1_verts_iter;
+      typename graph_traits<Graph2>::vertex_iterator graph2_verts_iter;
+    };
+
+    // Non-recursive method that explores state space using a depth-first
+    // search strategy.  At each depth possible pairs candidate are compute
+    // and tested for feasibility to extend the mapping. If a complete
+    // mapping is found, the mapping is output to user_callback in the form
+    // of a correspondence map (graph1 to graph2). Returning false from the
+    // user_callback will terminate the search. Function match will return
+    // true if the entire search space was explored.
+    template<typename Graph1,
+             typename Graph2,
+             typename IndexMap1,
+             typename IndexMap2,
+             typename VertexOrder1,
+             typename EdgeEquivalencePredicate,
+             typename VertexEquivalencePredicate, 
+             typename SubGraphIsoMapCallback,
+             problem_selector problem_selection>
+    bool match(const Graph1& graph1, const Graph2& graph2, 
+               SubGraphIsoMapCallback user_callback, const VertexOrder1& vertex_order1, 
+               state<Graph1, Graph2, IndexMap1, IndexMap2,
+               EdgeEquivalencePredicate, VertexEquivalencePredicate,
+               SubGraphIsoMapCallback, problem_selection>& s) {
+      
+      typename VertexOrder1::const_iterator graph1_verts_iter;
+
+      typedef typename graph_traits<Graph2>::vertex_iterator vertex2_iterator_type;
+      vertex2_iterator_type graph2_verts_iter, graph2_verts_iter_end;
+    
+      typedef vf2_match_continuation<Graph1, Graph2, VertexOrder1> match_continuation_type;
+      std::vector<match_continuation_type> k;
+      bool found_match = false;
+  
+      recur:
+      if (s.success()) {
+        if (!s.call_back(user_callback)) 
+          return true;
+        found_match = true;
+
+        goto back_track;
+      }
+ 
+      if (!s.valid())
+        goto back_track;
+
+      graph1_verts_iter = vertex_order1.begin();
+      while (graph1_verts_iter != vertex_order1.end() && 
+             !s.possible_candidate1(*graph1_verts_iter)) {
+        ++graph1_verts_iter;
+      }
+
+      boost::tie(graph2_verts_iter, graph2_verts_iter_end) = vertices(graph2);
+      while (graph2_verts_iter != graph2_verts_iter_end) {
+        if (s.possible_candidate2(*graph2_verts_iter)) {
+          if (s.feasible(*graph1_verts_iter, *graph2_verts_iter)) {
+            match_continuation_type kk;
+            kk.graph1_verts_iter = graph1_verts_iter;
+            kk.graph2_verts_iter = graph2_verts_iter;
+            k.push_back(kk);
+            
+            s.push(*graph1_verts_iter, *graph2_verts_iter);
+            goto recur;
+          }
+        }
+        graph2_loop: ++graph2_verts_iter;
+      }
+
+      back_track:
+      if (k.empty()) 
+        return found_match;    
+      
+      const match_continuation_type kk = k.back();
+      graph1_verts_iter = kk.graph1_verts_iter;
+      graph2_verts_iter = kk.graph2_verts_iter;
+      k.pop_back();
+      
+      s.pop(*graph1_verts_iter, *graph2_verts_iter);
+      
+      goto graph2_loop;
+    }
+
+
+    // Used to sort nodes by in/out degrees
+    template<typename Graph>
+    struct vertex_in_out_degree_cmp {
+      typedef typename graph_traits<Graph>::vertex_descriptor vertex_type;
+
+      vertex_in_out_degree_cmp(const Graph& graph)
+        : graph_(graph) {}
+
+      bool operator()(const vertex_type& v, const vertex_type& w) const {
+        // lexicographical comparison
+        return std::make_pair(in_degree(v, graph_), out_degree(v, graph_)) <
+               std::make_pair(in_degree(w, graph_), out_degree(w, graph_));
+      }
+
+      const Graph& graph_;
+    };
+
+
+    // Used to sort nodes by multiplicity of in/out degrees
+    template<typename Graph,
+             typename FrequencyMap>
+    struct vertex_frequency_degree_cmp {
+      typedef typename graph_traits<Graph>::vertex_descriptor vertex_type;
+      
+      vertex_frequency_degree_cmp(const Graph& graph, FrequencyMap freq)
+        : graph_(graph), freq_(freq) {}
+      
+      bool operator()(const vertex_type& v, const vertex_type& w) const {
+        // lexicographical comparison
+        return std::make_pair(freq_[v], in_degree(v, graph_)+out_degree(v, graph_)) <
+               std::make_pair(freq_[w], in_degree(w, graph_)+out_degree(w, graph_));
+      }
+
+      const Graph& graph_;
+      FrequencyMap freq_;
+    };
+
+    
+    // Sorts vertices of a graph by multiplicity of in/out degrees 
+    template<typename Graph,
+             typename IndexMap,
+             typename VertexOrder>
+    void sort_vertices(const Graph& graph, IndexMap index_map, VertexOrder& order) {
+      typedef typename graph_traits<Graph>::vertices_size_type size_type;
+
+      boost::range::sort(order, vertex_in_out_degree_cmp<Graph>(graph));
+
+      std::vector<size_type> freq_vec(num_vertices(graph), 0);
+      typedef iterator_property_map<typename std::vector<size_type>::iterator,
+                                    IndexMap, size_type, size_type&> frequency_map_type;
+                
+      frequency_map_type freq = make_iterator_property_map(freq_vec.begin(), index_map);
+
+      typedef typename VertexOrder::iterator order_iterator;
+
+      for (order_iterator order_iter = order.begin(); order_iter != order.end(); ) {
+        size_type count = 0;
+        for (order_iterator count_iter = order_iter;
+             (count_iter != order.end()) &&
+             (in_degree(*order_iter, graph) == in_degree(*count_iter, graph)) &&
+             (out_degree(*order_iter, graph) == out_degree(*count_iter, graph)); 
+             ++count_iter)
+          ++count;
+      
+        for (size_type i = 0; i < count; ++i) {
+          freq[*order_iter] = count;
+          ++order_iter;
+        }
+      }
+
+      boost::range::sort(order, vertex_frequency_degree_cmp<Graph, frequency_map_type>(graph, freq));
+
+    }
+
+    // Enumerates all graph sub-graph mono-/iso-morphism mappings between graphs
+    // graph_small and graph_large. Continues until user_callback returns true or the
+    // search space has been fully explored.
+    template <problem_selector problem_selection,
+              typename GraphSmall,
+              typename GraphLarge,
+              typename IndexMapSmall,
+              typename IndexMapLarge,
+              typename VertexOrderSmall,
+              typename EdgeEquivalencePredicate,
+              typename VertexEquivalencePredicate,
+              typename SubGraphIsoMapCallback>
+    bool vf2_subgraph_morphism(const GraphSmall& graph_small, const GraphLarge& graph_large,
+                          SubGraphIsoMapCallback user_callback,
+                          IndexMapSmall index_map_small, IndexMapLarge index_map_large, 
+                          const VertexOrderSmall& vertex_order_small,
+                          EdgeEquivalencePredicate edge_comp,
+                          VertexEquivalencePredicate vertex_comp) {
+
+      // Graph requirements
+      BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<GraphSmall> ));
+      BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<GraphSmall> ));
+      BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<GraphSmall> ));
+      BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept<GraphSmall> ));
+
+      BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<GraphLarge> ));
+      BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<GraphLarge> ));
+      BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<GraphLarge> ));
+      BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept<GraphLarge> ));
+
+      typedef typename graph_traits<GraphSmall>::vertex_descriptor vertex_small_type;
+      typedef typename graph_traits<GraphLarge>::vertex_descriptor vertex_large_type;
+
+      typedef typename graph_traits<GraphSmall>::vertices_size_type size_type_small;
+      typedef typename graph_traits<GraphLarge>::vertices_size_type size_type_large;
+        
+      // Property map requirements
+      BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<IndexMapSmall, vertex_small_type> ));
+      typedef typename property_traits<IndexMapSmall>::value_type IndexMapSmallValue;
+      BOOST_STATIC_ASSERT(( is_convertible<IndexMapSmallValue, size_type_small>::value ));
+        
+      BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<IndexMapLarge, vertex_large_type> ));
+      typedef typename property_traits<IndexMapLarge>::value_type IndexMapLargeValue;
+      BOOST_STATIC_ASSERT(( is_convertible<IndexMapLargeValue, size_type_large>::value ));
+
+      // Edge & vertex requirements
+      typedef typename graph_traits<GraphSmall>::edge_descriptor edge_small_type;
+      typedef typename graph_traits<GraphLarge>::edge_descriptor edge_large_type;
+
+      BOOST_CONCEPT_ASSERT(( BinaryPredicateConcept<EdgeEquivalencePredicate, 
+                             edge_small_type, edge_large_type> ));
+
+      BOOST_CONCEPT_ASSERT(( BinaryPredicateConcept<VertexEquivalencePredicate, 
+                             vertex_small_type, vertex_large_type> ));
+
+      // Vertex order requirements
+      BOOST_CONCEPT_ASSERT(( ContainerConcept<VertexOrderSmall> )); 
+      typedef typename VertexOrderSmall::value_type order_value_type;
+      BOOST_STATIC_ASSERT(( is_same<vertex_small_type, order_value_type>::value ));
+      BOOST_ASSERT( num_vertices(graph_small) == vertex_order_small.size() );
+
+      if (num_vertices(graph_small) > num_vertices(graph_large))
+        return false;
+
+      typename graph_traits<GraphSmall>::edges_size_type num_edges_small = num_edges(graph_small);
+      typename graph_traits<GraphLarge>::edges_size_type num_edges_large = num_edges(graph_large);
+
+      // Double the number of edges for undirected graphs: each edge counts as
+      // in-edge and out-edge
+      if (is_undirected(graph_small)) num_edges_small *= 2;
+      if (is_undirected(graph_large)) num_edges_large *= 2;
+      if (num_edges_small > num_edges_large)
+        return false;
+    
+      detail::state<GraphSmall, GraphLarge, IndexMapSmall, IndexMapLarge,
+                    EdgeEquivalencePredicate, VertexEquivalencePredicate,
+                    SubGraphIsoMapCallback, problem_selection> 
+        s(graph_small, graph_large, index_map_small, index_map_large, edge_comp, vertex_comp);
+
+      return detail::match(graph_small, graph_large, user_callback, vertex_order_small, s);
+    }
+
+  } // namespace detail
+
+
+  // Returns vertex order (vertices sorted by multiplicity of in/out degrees)
+  template<typename Graph>
+  std::vector<typename graph_traits<Graph>::vertex_descriptor> 
+    vertex_order_by_mult(const Graph& graph) {
+
+    std::vector<typename graph_traits<Graph>::vertex_descriptor> vertex_order;
+    std::copy(vertices(graph).first, vertices(graph).second, std::back_inserter(vertex_order));
+
+    detail::sort_vertices(graph, get(vertex_index, graph), vertex_order);
+    return vertex_order;
+  }
+
+
+  // Enumerates all graph sub-graph monomorphism mappings between graphs
+  // graph_small and graph_large. Continues until user_callback returns true or the
+  // search space has been fully explored.
+  template <typename GraphSmall,
+            typename GraphLarge,
+            typename IndexMapSmall,
+            typename IndexMapLarge,
+            typename VertexOrderSmall,
+            typename EdgeEquivalencePredicate,
+            typename VertexEquivalencePredicate,
+            typename SubGraphIsoMapCallback>
+  bool vf2_subgraph_mono(const GraphSmall& graph_small, const GraphLarge& graph_large,
+                         SubGraphIsoMapCallback user_callback,
+                         IndexMapSmall index_map_small, IndexMapLarge index_map_large, 
+                         const VertexOrderSmall& vertex_order_small,
+                         EdgeEquivalencePredicate edge_comp,
+                         VertexEquivalencePredicate vertex_comp) {
+    return detail::vf2_subgraph_morphism<detail::subgraph_mono>
+                                        (graph_small, graph_large,
+                                         user_callback,
+                                         index_map_small, index_map_large,
+                                         vertex_order_small,
+                                         edge_comp,
+                                         vertex_comp);
+  }
+
+
+  // All default interface for vf2_subgraph_iso
+  template <typename GraphSmall,
+            typename GraphLarge,
+            typename SubGraphIsoMapCallback>
+  bool vf2_subgraph_mono(const GraphSmall& graph_small, const GraphLarge& graph_large, 
+                         SubGraphIsoMapCallback user_callback) {
+    return vf2_subgraph_mono(graph_small, graph_large, user_callback, 
+                             get(vertex_index, graph_small), get(vertex_index, graph_large),
+                             vertex_order_by_mult(graph_small),
+                             always_equivalent(), always_equivalent());
+  }
+
+
+  // Named parameter interface of vf2_subgraph_iso
+  template <typename GraphSmall,
+            typename GraphLarge,
+            typename VertexOrderSmall,
+            typename SubGraphIsoMapCallback,
+            typename Param,
+            typename Tag,
+            typename Rest>
+  bool vf2_subgraph_mono(const GraphSmall& graph_small, const GraphLarge& graph_large,
+                         SubGraphIsoMapCallback user_callback,
+                         const VertexOrderSmall& vertex_order_small,
+                         const bgl_named_params<Param, Tag, Rest>& params) {
+    return vf2_subgraph_mono(graph_small, graph_large, user_callback,
+                             choose_const_pmap(get_param(params, vertex_index1),
+                                               graph_small, vertex_index),
+                             choose_const_pmap(get_param(params, vertex_index2),
+                                               graph_large, vertex_index),
+                             vertex_order_small,
+                             choose_param(get_param(params, edges_equivalent_t()),
+                                          always_equivalent()),
+                             choose_param(get_param(params, vertices_equivalent_t()),
+                                          always_equivalent())
+                             );
+  }
+  
+  
+  // Enumerates all graph sub-graph isomorphism mappings between graphs
+  // graph_small and graph_large. Continues until user_callback returns true or the
+  // search space has been fully explored.
+  template <typename GraphSmall,
+            typename GraphLarge,
+            typename IndexMapSmall,
+            typename IndexMapLarge,
+            typename VertexOrderSmall,
+            typename EdgeEquivalencePredicate,
+            typename VertexEquivalencePredicate,
+            typename SubGraphIsoMapCallback>
+  bool vf2_subgraph_iso(const GraphSmall& graph_small, const GraphLarge& graph_large,
+                        SubGraphIsoMapCallback user_callback,
+                        IndexMapSmall index_map_small, IndexMapLarge index_map_large, 
+                        const VertexOrderSmall& vertex_order_small,
+                        EdgeEquivalencePredicate edge_comp,
+                        VertexEquivalencePredicate vertex_comp) {
+    return detail::vf2_subgraph_morphism<detail::subgraph_iso>
+                                        (graph_small, graph_large,
+                                         user_callback,
+                                         index_map_small, index_map_large,
+                                         vertex_order_small,
+                                         edge_comp,
+                                         vertex_comp);
+  }
+
+
+  // All default interface for vf2_subgraph_iso
+  template <typename GraphSmall,
+            typename GraphLarge,
+            typename SubGraphIsoMapCallback>
+  bool vf2_subgraph_iso(const GraphSmall& graph_small, const GraphLarge& graph_large, 
+                        SubGraphIsoMapCallback user_callback) {
+
+    return vf2_subgraph_iso(graph_small, graph_large, user_callback, 
+                            get(vertex_index, graph_small), get(vertex_index, graph_large),
+                            vertex_order_by_mult(graph_small),
+                            always_equivalent(), always_equivalent());
+  }
+
+
+  // Named parameter interface of vf2_subgraph_iso
+  template <typename GraphSmall,
+            typename GraphLarge,
+            typename VertexOrderSmall,
+            typename SubGraphIsoMapCallback,
+            typename Param,
+            typename Tag,
+            typename Rest>
+  bool vf2_subgraph_iso(const GraphSmall& graph_small, const GraphLarge& graph_large,
+                        SubGraphIsoMapCallback user_callback,
+                        const VertexOrderSmall& vertex_order_small,
+                        const bgl_named_params<Param, Tag, Rest>& params) {
+    
+    return vf2_subgraph_iso(graph_small, graph_large, user_callback,
+                            choose_const_pmap(get_param(params, vertex_index1),
+                                              graph_small, vertex_index),
+                            choose_const_pmap(get_param(params, vertex_index2),
+                                              graph_large, vertex_index),
+                            vertex_order_small,
+                            choose_param(get_param(params, edges_equivalent_t()),
+                                         always_equivalent()),
+                            choose_param(get_param(params, vertices_equivalent_t()),
+                                         always_equivalent())
+                            );
+
+  }
+
+
+  // Enumerates all isomorphism mappings between graphs graph1_ and graph2_.
+  // Continues until user_callback returns true or the search space has been
+  // fully explored.
+  template <typename Graph1,
+            typename Graph2,
+            typename IndexMap1,
+            typename IndexMap2,
+            typename VertexOrder1,
+            typename EdgeEquivalencePredicate,
+            typename VertexEquivalencePredicate,
+            typename GraphIsoMapCallback>
+  bool vf2_graph_iso(const Graph1& graph1, const Graph2& graph2,
+                     GraphIsoMapCallback user_callback,
+                     IndexMap1 index_map1, IndexMap2 index_map2, 
+                     const VertexOrder1& vertex_order1,
+                     EdgeEquivalencePredicate edge_comp,
+                     VertexEquivalencePredicate vertex_comp) {
+
+    // Graph requirements
+    BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph1> ));
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph1> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph1> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept<Graph1> ));
+
+    BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph2> ));
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph2> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph2> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept<Graph2> ));
+ 
+        
+    typedef typename graph_traits<Graph1>::vertex_descriptor vertex1_type;
+    typedef typename graph_traits<Graph2>::vertex_descriptor vertex2_type;
+    
+    typedef typename graph_traits<Graph1>::vertices_size_type size_type1;
+    typedef typename graph_traits<Graph2>::vertices_size_type size_type2;
+        
+    // Property map requirements
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<IndexMap1, vertex1_type> ));
+    typedef typename property_traits<IndexMap1>::value_type IndexMap1Value;
+    BOOST_STATIC_ASSERT(( is_convertible<IndexMap1Value, size_type1>::value ));
+        
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyMapConcept<IndexMap2, vertex2_type> ));
+    typedef typename property_traits<IndexMap2>::value_type IndexMap2Value;
+    BOOST_STATIC_ASSERT(( is_convertible<IndexMap2Value, size_type2>::value ));
+
+    // Edge & vertex requirements
+    typedef typename graph_traits<Graph1>::edge_descriptor edge1_type;
+    typedef typename graph_traits<Graph2>::edge_descriptor edge2_type;
+
+    BOOST_CONCEPT_ASSERT(( BinaryPredicateConcept<EdgeEquivalencePredicate, 
+                           edge1_type, edge2_type> ));
+
+    BOOST_CONCEPT_ASSERT(( BinaryPredicateConcept<VertexEquivalencePredicate, 
+                           vertex1_type, vertex2_type> ));
+    
+    // Vertex order requirements
+    BOOST_CONCEPT_ASSERT(( ContainerConcept<VertexOrder1> )); 
+    typedef typename VertexOrder1::value_type order_value_type;
+    BOOST_STATIC_ASSERT(( is_same<vertex1_type, order_value_type>::value ));
+    BOOST_ASSERT( num_vertices(graph1) == vertex_order1.size() );
+
+    if (num_vertices(graph1) != num_vertices(graph2))
+      return false;
+
+    typename graph_traits<Graph1>::edges_size_type num_edges1 = num_edges(graph1);
+    typename graph_traits<Graph2>::edges_size_type num_edges2 = num_edges(graph2);
+
+    // Double the number of edges for undirected graphs: each edge counts as
+    // in-edge and out-edge
+    if (is_undirected(graph1)) num_edges1 *= 2;
+    if (is_undirected(graph2)) num_edges2 *= 2;
+    if (num_edges1 != num_edges2)
+      return false;
+
+    detail::state<Graph1, Graph2, IndexMap1, IndexMap2,
+                  EdgeEquivalencePredicate, VertexEquivalencePredicate,
+                  GraphIsoMapCallback, detail::isomorphism> 
+      s(graph1, graph2, index_map1, index_map2, edge_comp, vertex_comp);
+
+    return detail::match(graph1, graph2, user_callback, vertex_order1, s);
+  }
+
+
+  // All default interface for vf2_graph_iso
+  template <typename Graph1,
+            typename Graph2,
+            typename GraphIsoMapCallback>
+  bool vf2_graph_iso(const Graph1& graph1, const Graph2& graph2, 
+                     GraphIsoMapCallback user_callback) {
+    
+    return vf2_graph_iso(graph1, graph2, user_callback, 
+                         get(vertex_index, graph1), get(vertex_index, graph2),
+                         vertex_order_by_mult(graph1),
+                         always_equivalent(), always_equivalent());
+  }
+
+
+  // Named parameter interface of vf2_graph_iso
+  template <typename Graph1,
+            typename Graph2,
+            typename VertexOrder1,
+            typename GraphIsoMapCallback,
+            typename Param,
+            typename Tag,
+            typename Rest>
+  bool vf2_graph_iso(const Graph1& graph1, const Graph2& graph2,
+                     GraphIsoMapCallback user_callback,
+                     const VertexOrder1& vertex_order1,
+                     const bgl_named_params<Param, Tag, Rest>& params) {
+    
+    return vf2_graph_iso(graph1, graph2, user_callback,
+                         choose_const_pmap(get_param(params, vertex_index1),
+                                           graph1, vertex_index),
+                         choose_const_pmap(get_param(params, vertex_index2),
+                                           graph2, vertex_index),
+                         vertex_order1,
+                         choose_param(get_param(params, edges_equivalent_t()),
+                                always_equivalent()),
+                         choose_param(get_param(params, vertices_equivalent_t()),
+                                      always_equivalent())
+                         );
+
+  }
+
+
+  // Verifies a graph (sub)graph isomorphism map 
+  template<typename Graph1,
+           typename Graph2,
+           typename CorresponenceMap1To2,
+           typename EdgeEquivalencePredicate,
+           typename VertexEquivalencePredicate>
+  inline bool verify_vf2_subgraph_iso(const Graph1& graph1, const Graph2& graph2, 
+                                      const CorresponenceMap1To2 f,
+                                      EdgeEquivalencePredicate edge_comp, 
+                                      VertexEquivalencePredicate vertex_comp) {
+        
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph1> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept<Graph2> ));
+
+    detail::equivalent_edge_exists<Graph2> edge2_exists;
+
+    BGL_FORALL_EDGES_T(e1, graph1, Graph1) {
+      typename graph_traits<Graph1>::vertex_descriptor s1, t1;
+      typename graph_traits<Graph2>::vertex_descriptor s2, t2;
+      
+      s1 = source(e1, graph1); t1 = target(e1, graph1);
+      s2 = get(f, s1); t2 = get(f, t1);
+      
+      if (!vertex_comp(s1, s2) || !vertex_comp(t1, t2))
+        return false;
+
+      typename graph_traits<Graph2>::edge_descriptor e2;
+      
+      if (!edge2_exists(s2, t2,
+                        detail::edge2_predicate<Graph1, Graph2, EdgeEquivalencePredicate>(edge_comp, e1), 
+                        graph2))
+        return false;
+      
+    }
+  
+    return true;
+  }
+
+  // Variant of verify_subgraph_iso with all default parameters
+  template<typename Graph1,
+           typename Graph2,
+           typename CorresponenceMap1To2>
+  inline bool verify_vf2_subgraph_iso(const Graph1& graph1, const Graph2& graph2, 
+                                      const CorresponenceMap1To2 f) {
+    return verify_vf2_subgraph_iso(graph1, graph2, f, 
+                                   always_equivalent(), always_equivalent());
+  }
+
+
+
+} // namespace boost
+
+#ifdef BOOST_ISO_INCLUDED_ITER_MACROS
+#undef BOOST_ISO_INCLUDED_ITER_MACROS
+#include <boost/graph/iteration_macros_undef.hpp>
+#endif
+
+#endif // BOOST_VF2_SUB_GRAPH_ISO_HPP
diff --git a/include/boost/graph/visitors.hpp b/include/boost/graph/visitors.hpp
index f986c96ce..120314f90 100644
--- a/include/boost/graph/visitors.hpp
+++ b/include/boost/graph/visitors.hpp
@@ -21,11 +21,6 @@
 #include <boost/graph/graph_traits.hpp>
 #include <boost/limits.hpp>
 
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-// Stay out of the way of the concept checking class
-# define Graph Graph_
-#endif
-
 namespace boost {
 
   // This is a bit more convenient than std::numeric_limits because
@@ -44,7 +39,7 @@ namespace boost {
       on_discover_vertex_num, on_finish_vertex_num, on_examine_vertex_num,
       on_examine_edge_num, on_tree_edge_num, on_non_tree_edge_num,
       on_gray_target_num, on_black_target_num,
-      on_forward_or_cross_edge_num, on_back_edge_num,
+      on_forward_or_cross_edge_num, on_back_edge_num, on_finish_edge_num,
       on_edge_relaxed_num, on_edge_not_relaxed_num,
       on_edge_minimized_num, on_edge_not_minimized_num
     };
@@ -75,6 +70,7 @@ namespace boost {
   struct on_forward_or_cross_edge {
     enum { num = detail::on_forward_or_cross_edge_num }; };
   struct on_back_edge { enum { num = detail::on_back_edge_num }; };
+  struct on_finish_edge { enum { num = detail::on_finish_edge_num }; };
 
   struct on_edge_relaxed { enum { num = detail::on_edge_relaxed_num }; };
   struct on_edge_not_relaxed {
@@ -122,16 +118,6 @@ namespace boost {
     detail::invoke_dispatch(vlist.first, x, g, IsSameTag());
     invoke_visitors(vlist.second, x, g, tag);
   }
-#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
-  template <class Visitor, class T, class Graph, class Tag>
-  inline void
-  invoke_visitors(base_visitor<Visitor>& vis, T x, Graph& g, Tag) {
-    typedef typename Visitor::event_filter Category;
-    typedef typename is_same<Category, Tag>::type IsSameTag;
-    Visitor& v = static_cast<Visitor&>(vis);
-    detail::invoke_dispatch(v, x, g, IsSameTag());
-  }
-#else
   template <class Visitor, class T, class Graph, class Tag>
   inline void
   invoke_visitors(Visitor& v, T x, Graph& g, Tag) {
@@ -139,7 +125,6 @@ namespace boost {
     typedef typename is_same<Category, Tag>::type IsSameTag;
     detail::invoke_dispatch(v, x, g, IsSameTag());
   }
-#endif
 
   //========================================================================
   // predecessor_recorder
@@ -269,7 +254,7 @@ namespace boost {
     {}
 
     template <typename VertexOrEdge, typename Graph>
-    void operator() (VertexOrEdge v, const Graph& g)
+    void operator() (VertexOrEdge v, const Graph&)
     {
       put (property_map_, v, value_);
     }
@@ -292,7 +277,7 @@ namespace boost {
     inline property_put <PropertyMap, EventTag>
     put_property (PropertyMap property_map,
                   typename property_traits <PropertyMap>::value_type value,
-                  EventTag tag)
+                  EventTag)
     {
       return property_put <PropertyMap, EventTag> (property_map, value);
     }
@@ -312,9 +297,4 @@ namespace boost {
 
 } /* namespace boost */
 
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-// Stay out of the way of the concept checking class
-# undef Graph
-#endif
-
 #endif
diff --git a/include/boost/graph/write_dimacs.hpp b/include/boost/graph/write_dimacs.hpp
index 0b8af17df..a4a577736 100644
--- a/include/boost/graph/write_dimacs.hpp
+++ b/include/boost/graph/write_dimacs.hpp
@@ -51,10 +51,6 @@ void write_dimacs_max_flow(const Graph& g,
                          typename graph_traits<Graph>::vertex_descriptor sink,
                          std::ostream& out)
 {
-  typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor;
-  typedef typename graph_traits<Graph>::vertices_size_type vertices_size_type;
-  typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor;
-  typedef typename graph_traits<Graph>::edges_size_type edges_size_type;
   typedef typename graph_traits<Graph>::edge_iterator edge_iterator;
    
   out << "c DIMACS max-flow file generated from boost::write_dimacs_max_flow" << std::endl;
@@ -64,7 +60,7 @@ void write_dimacs_max_flow(const Graph& g,
   
   //output the edges
   edge_iterator ei, e_end;
-  for(tie(ei,e_end) = edges(g); ei!=e_end; ++ei){
+  for(boost::tie(ei,e_end) = edges(g); ei!=e_end; ++ei){
     out << "a " << idx[ source(*ei, g) ] + 1 << " " << idx[ target(*ei, g) ] + 1 << " " << get(capacity,*ei) << std::endl;
   }
 }
diff --git a/include/boost/pending/container_traits.hpp b/include/boost/pending/container_traits.hpp
index 7cdf38c7d..a58b52450 100644
--- a/include/boost/pending/container_traits.hpp
+++ b/include/boost/pending/container_traits.hpp
@@ -15,6 +15,7 @@
 #include <boost/next_prior.hpp>
 
 #include <algorithm>   // for std::remove
+#include <utility>
 #include <vector>
 #include <list>
 #include <map>
@@ -30,10 +31,20 @@
 #  endif
 #endif
 
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-// Stay out of the way of concept checking class templates
-# define Container Container_
-# define AssociativeContainer AssociativeContainer_
+#ifndef BOOST_NO_CXX11_HDR_UNORDERED_SET
+#include <unordered_set>
+#endif
+
+#ifndef BOOST_NO_CXX11_HDR_UNORDERED_MAP
+#include <unordered_map>
+#endif
+
+#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
+#define BOOST_PENDING_FWD_TYPE(type) const type&
+#define BOOST_PENDING_FWD_VALUE(type, var) (var)
+#else
+#define BOOST_PENDING_FWD_TYPE(type) type&&
+#define BOOST_PENDING_FWD_VALUE(type, var) (std::forward<type>((var)))
 #endif
 
 // The content of this file is in 'graph_detail' because otherwise
@@ -87,14 +98,12 @@ namespace boost { namespace graph_detail {
   //======================================================================
   // Container Traits Class and container_category() function
 
-#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
   // don't use this unless there is partial specialization 
   template <class Container>
   struct container_traits {
     typedef typename Container::category category;
     typedef typename Container::iterator_stability iterator_stability;
   };
-#endif
 
   // Use this as a compile-time assertion that X is stable
   inline void require_stable(stable_tag) { }
@@ -112,13 +121,11 @@ namespace boost { namespace graph_detail {
   unstable_tag iterator_stability(const std::vector<T,Alloc>&)
     { return unstable_tag(); }
 
-#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
   template <class T, class Alloc>
   struct container_traits< std::vector<T,Alloc> > {
     typedef vector_tag category;
     typedef unstable_tag iterator_stability;
   };
-#endif
 
   // std::list
   struct list_tag :
@@ -136,24 +143,20 @@ namespace boost { namespace graph_detail {
   stable_tag iterator_stability(const std::list<T,Alloc>&)
     { return stable_tag(); }
 
-#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
   template <class T, class Alloc>
   struct container_traits< std::list<T,Alloc> > {
     typedef list_tag category;
     typedef stable_tag iterator_stability;
   };
-#endif
 
 
   // std::slist
 #ifndef BOOST_NO_SLIST
-# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
   template <class T, class Alloc>
   struct container_traits<BOOST_STD_EXTENSION_NAMESPACE::slist<T,Alloc> > {
     typedef front_insertion_sequence_tag category;
     typedef stable_tag iterator_stability;
   };
-#endif
   template <class T, class Alloc>
   front_insertion_sequence_tag container_category(
   const BOOST_STD_EXTENSION_NAMESPACE::slist<T,Alloc>&
@@ -182,13 +185,11 @@ namespace boost { namespace graph_detail {
   stable_tag iterator_stability(const std::set<Key,Cmp,Alloc>&)
   { return stable_tag(); }
 
-#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
   template <class Key, class Cmp, class Alloc> 
   struct container_traits< std::set<Key,Cmp,Alloc> > {
     typedef set_tag category;
     typedef stable_tag iterator_stability;
   };
-#endif
 
   // std::multiset
   struct multiset_tag :
@@ -205,13 +206,11 @@ namespace boost { namespace graph_detail {
   stable_tag iterator_stability(const std::multiset<Key,Cmp,Alloc>&)
   { return stable_tag(); }
 
-#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
   template <class Key, class Cmp, class Alloc> 
   struct container_traits< std::multiset<Key,Cmp,Alloc> > {
     typedef multiset_tag category;
     typedef stable_tag iterator_stability;
   };
-#endif
 
   // deque
 
@@ -222,13 +221,11 @@ namespace boost { namespace graph_detail {
     virtual public unique_associative_container_tag 
     { };
 
-#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
   template <class Key, class T, class Cmp, class Alloc> 
   struct container_traits< std::map<Key,T,Cmp,Alloc> > {
     typedef map_tag category;
     typedef stable_tag iterator_stability;
   };
-#endif
 
   template <class Key, class T, class Cmp, class Alloc> 
   map_tag container_category(const std::map<Key,T,Cmp,Alloc>&)
@@ -245,13 +242,11 @@ namespace boost { namespace graph_detail {
     virtual public multiple_associative_container_tag 
     { };
 
-#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
   template <class Key, class T, class Cmp, class Alloc> 
   struct container_traits< std::multimap<Key,T,Cmp,Alloc> > {
     typedef multimap_tag category;
     typedef stable_tag iterator_stability;
   };
-#endif
 
   template <class Key, class T, class Cmp, class Alloc> 
   multimap_tag container_category(const std::multimap<Key,T,Cmp,Alloc>&)
@@ -286,8 +281,6 @@ namespace boost { namespace graph_detail {
     { };
 
 
-#ifndef BOOST_NO_HASH
-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
   template <class Key, class Eq, class Hash, class Alloc> 
   struct container_traits< boost::unordered_set<Key,Eq,Hash,Alloc> > {
     typedef unordered_set_tag category;
@@ -308,7 +301,7 @@ namespace boost { namespace graph_detail {
     typedef unordered_multimap_tag category;
     typedef unstable_tag iterator_stability;
   };
-#endif
+
   template <class Key, class Eq, class Hash, class Alloc>
   unordered_set_tag
   container_category(const boost::unordered_set<Key,Eq,Hash,Alloc>&)
@@ -345,8 +338,87 @@ namespace boost { namespace graph_detail {
   unstable_tag
   iterator_stability(const boost::unordered_multimap<Key,T,Eq,Hash,Alloc>&)
   { return unstable_tag(); }
+
+#ifndef BOOST_NO_CXX11_HDR_UNORDERED_SET
+  template <class Key, class Eq, class Hash, class Alloc> 
+  struct container_traits< std::unordered_set<Key,Eq,Hash,Alloc> > {
+    typedef unordered_set_tag category;
+    typedef unstable_tag iterator_stability;
+  };
+#endif
+#ifndef BOOST_NO_CXX11_HDR_UNORDERED_MAP
+  template <class Key, class T, class Eq, class Hash, class Alloc>
+  struct container_traits< std::unordered_map<Key,T,Eq,Hash,Alloc> > {
+    typedef unordered_map_tag category;
+    typedef unstable_tag iterator_stability;
+  };
+#endif
+#ifndef BOOST_NO_CXX11_HDR_UNORDERED_SET
+  template <class Key, class Eq, class Hash, class Alloc>
+  struct container_traits< std::unordered_multiset<Key,Eq,Hash,Alloc> > {
+    typedef unordered_multiset_tag category;
+    typedef unstable_tag iterator_stability;
+  };
+#endif
+#ifndef BOOST_NO_CXX11_HDR_UNORDERED_MAP
+  template <class Key, class T, class Eq, class Hash, class Alloc>
+  struct container_traits< std::unordered_multimap<Key,T,Eq,Hash,Alloc> > {
+    typedef unordered_multimap_tag category;
+    typedef unstable_tag iterator_stability;
+  };
+#endif
+#ifndef BOOST_NO_CXX11_HDR_UNORDERED_SET
+  template <class Key, class Eq, class Hash, class Alloc>
+  unordered_set_tag
+  container_category(const std::unordered_set<Key,Eq,Hash,Alloc>&)
+  { return unordered_set_tag(); }
 #endif
 
+#ifndef BOOST_NO_CXX11_HDR_UNORDERED_MAP
+  template <class Key, class T, class Eq, class Hash, class Alloc>
+  unordered_map_tag
+  container_category(const std::unordered_map<Key,T,Eq,Hash,Alloc>&)
+  { return unordered_map_tag(); }
+#endif
+
+#ifndef BOOST_NO_CXX11_HDR_UNORDERED_SET
+  template <class Key, class Eq, class Hash, class Alloc>
+  unstable_tag iterator_stability(const std::unordered_set<Key,Eq,Hash,Alloc>&)
+  { return unstable_tag(); }
+#endif
+
+#ifndef BOOST_NO_CXX11_HDR_UNORDERED_MAP
+  template <class Key, class T, class Eq, class Hash, class Alloc>
+  unstable_tag iterator_stability(const std::unordered_map<Key,T,Eq,Hash,Alloc>&)
+  { return unstable_tag(); }
+#endif
+#ifndef BOOST_NO_CXX11_HDR_UNORDERED_SET
+  template <class Key, class Eq, class Hash, class Alloc>
+  unordered_multiset_tag
+  container_category(const std::unordered_multiset<Key,Eq,Hash,Alloc>&)
+  { return unordered_multiset_tag(); }
+#endif
+
+#ifndef BOOST_NO_CXX11_HDR_UNORDERED_MAP
+  template <class Key, class T, class Eq, class Hash, class Alloc>
+  unordered_multimap_tag
+  container_category(const std::unordered_multimap<Key,T,Eq,Hash,Alloc>&)
+  { return unordered_multimap_tag(); }
+#endif
+
+#ifndef BOOST_NO_CXX11_HDR_UNORDERED_SET
+  template <class Key, class Eq, class Hash, class Alloc>
+  unstable_tag
+  iterator_stability(const std::unordered_multiset<Key,Eq,Hash,Alloc>&)
+  { return unstable_tag(); }
+#endif
+
+#ifndef BOOST_NO_CXX11_HDR_UNORDERED_MAP
+  template <class Key, class T, class Eq, class Hash, class Alloc>
+  unstable_tag
+  iterator_stability(const std::unordered_multimap<Key,T,Eq,Hash,Alloc>&)
+  { return unstable_tag(); }
+#endif
 
 
   //===========================================================================
@@ -421,41 +493,41 @@ namespace boost { namespace graph_detail {
   // Push
   template <class Container, class T>
   std::pair<typename Container::iterator, bool>
-  push_dispatch(Container& c, const T& v, back_insertion_sequence_tag)
+  push_dispatch(Container& c, BOOST_PENDING_FWD_TYPE(T) v, back_insertion_sequence_tag)
   {
-    c.push_back(v);
+    c.push_back(BOOST_PENDING_FWD_VALUE(T, v));
     return std::make_pair(boost::prior(c.end()), true);
   }
 
   template <class Container, class T>
   std::pair<typename Container::iterator, bool>
-  push_dispatch(Container& c, const T& v, front_insertion_sequence_tag)
+  push_dispatch(Container& c, BOOST_PENDING_FWD_TYPE(T) v, front_insertion_sequence_tag)
   {
-    c.push_front(v);
+    c.push_front(BOOST_PENDING_FWD_VALUE(T, v));
     return std::make_pair(c.begin(), true);
   }
 
   template <class AssociativeContainer, class T>
   std::pair<typename AssociativeContainer::iterator, bool>
-  push_dispatch(AssociativeContainer& c, const T& v, 
+  push_dispatch(AssociativeContainer& c, BOOST_PENDING_FWD_TYPE(T) v, 
                 unique_associative_container_tag)
   {
-    return c.insert(v);
+    return c.insert(BOOST_PENDING_FWD_VALUE(T, v));
   }
 
   template <class AssociativeContainer, class T>
   std::pair<typename AssociativeContainer::iterator, bool>
-  push_dispatch(AssociativeContainer& c, const T& v,
+  push_dispatch(AssociativeContainer& c, BOOST_PENDING_FWD_TYPE(T) v,
                 multiple_associative_container_tag)
   {
-    return std::make_pair(c.insert(v), true);
+    return std::make_pair(c.insert(BOOST_PENDING_FWD_VALUE(T, v)), true);
   }
 
   template <class Container, class T>
   std::pair<typename Container::iterator,bool>
-  push(Container& c, const T& v)
+  push(Container& c, BOOST_PENDING_FWD_TYPE(T) v)
   {
-    return push_dispatch(c, v, container_category(c));
+    return push_dispatch(c, BOOST_PENDING_FWD_VALUE(T, v), container_category(c));
   }
 
   // Find
@@ -552,10 +624,7 @@ namespace boost { namespace graph_detail {
 
 }} // namespace boost::graph_detail
 
-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-// Stay out of the way of concept checking class templates
-# undef Container
-# undef AssociativeContainer
-#endif
+#undef BOOST_PENDING_FWD_TYPE
+#undef BOOST_PENDING_FWD_VALUE
 
 #endif // BOOST_GRAPH_DETAIL_CONTAINER_TRAITS_H
diff --git a/include/boost/pending/detail/property.hpp b/include/boost/pending/detail/property.hpp
index 09e8866cf..42c7ce07d 100644
--- a/include/boost/pending/detail/property.hpp
+++ b/include/boost/pending/detail/property.hpp
@@ -13,147 +13,8 @@ namespace boost {
 
   namespace detail {
 
-    template <class PropertyTag1, class PropertyTag2>
-    struct same_property {
-      enum { value = is_same<PropertyTag1,PropertyTag2>::value };
-    };
-
     struct error_property_not_found { };
 
-    template <int TagMatched>
-    struct property_value_dispatch {
-      template <class PropertyTag, class T, class Tag>
-      inline static T& get_value(PropertyTag& p, T*, Tag) {
-        return p.m_value; 
-      }
-      template <class PropertyTag, class T, class Tag>
-      inline static const T& const_get_value(const PropertyTag& p, T*, Tag) {
-        return p.m_value; 
-      }
-    };
-
-    template <class PropertyList>
-    struct property_value_end {
-      template <class T> struct result { typedef T type; };
-
-      template <class T, class Tag>
-      inline static T& get_value(PropertyList& p, T* t, Tag tag) {
-        typedef typename PropertyList::next_type Next;
-        typedef typename Next::tag_type Next_tag;
-        enum { match = same_property<Next_tag,Tag>::value };
-        return property_value_dispatch<match>
-          ::get_value(static_cast<Next&>(p), t, tag);
-      }
-      template <class T, class Tag>
-      inline static const T& const_get_value(const PropertyList& p, T* t, Tag tag) {
-        typedef typename PropertyList::next_type Next;
-        typedef typename Next::tag_type Next_tag;
-        enum { match = same_property<Next_tag,Tag>::value };
-        return property_value_dispatch<match>
-          ::const_get_value(static_cast<const Next&>(p), t, tag);
-      }
-    };
-    template <>
-    struct property_value_end<no_property> {
-      template <class T> struct result { 
-        typedef detail::error_property_not_found type; 
-      };
-
-      // Stop the recursion and return error
-      template <class T, class Tag>
-      inline static detail::error_property_not_found&
-      get_value(no_property&, T*, Tag) {
-        static error_property_not_found s_prop_not_found;
-        return s_prop_not_found;
-      }
-      template <class T, class Tag>
-      inline static const detail::error_property_not_found&
-      const_get_value(const no_property&, T*, Tag) {
-        static error_property_not_found s_prop_not_found;
-        return s_prop_not_found;
-      }
-    };
-
-    template <>
-    struct property_value_dispatch<0> {
-      template <class PropertyList, class T, class Tag>
-      inline static typename property_value_end<PropertyList>::template result<T>::type&
-      get_value(PropertyList& p, T* t, Tag tag) {
-        return property_value_end<PropertyList>::get_value(p, t, tag);
-      }
-      template <class PropertyList, class T, class Tag>
-      inline static const typename property_value_end<PropertyList>::template result<T>::type&
-      const_get_value(const PropertyList& p, T* t, Tag tag) {
-        return property_value_end<PropertyList>::const_get_value(p, t, tag);
-      }
-    };
-
-    template <class PropertyList>
-    struct build_property_tag_value_alist
-    {
-      typedef typename PropertyList::next_type NextProperty;
-      typedef typename PropertyList::value_type Value;
-      typedef typename PropertyList::tag_type Tag;
-      typedef typename build_property_tag_value_alist<NextProperty>::type Next;
-      typedef std::pair< std::pair<Tag,Value>, Next> type;
-    };
-    template <>
-    struct build_property_tag_value_alist<no_property>
-    {
-      typedef no_property type;
-    };
-
-#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-    template <class TagValueAList, class Tag>
-    struct extract_value {
-      typedef error_property_not_found type;
-    };
-    template <class Value, class Tag1, class Tag2, class Rest>
-    struct extract_value< std::pair<std::pair<Tag1,Value>,Rest>, Tag2> {
-      typedef typename extract_value<Rest,Tag2>::type type;
-    };
-    template <class Value, class Tag, class Rest>
-    struct extract_value< std::pair<std::pair<Tag,Value>,Rest>, Tag> {
-      typedef Value type;
-    };
-#else
-    // VC++ workaround:
-    // The main idea here is to replace partial specialization with
-    // nested template member classes. Of course there is the
-    // further complication that the outer class of the nested
-    // template class cannot itself be a template class.
-    // Hence the need for the ev_selector. -JGS
-
-    struct recursive_extract;
-    struct end_extract;
-
-    template <class TagValueAList>
-    struct ev_selector { typedef recursive_extract type; };
-    template <>
-    struct ev_selector<no_property> { typedef end_extract type; };
-
-    struct recursive_extract {
-      template <class TagValueAList, class Tag1>
-      struct bind_ {
-        typedef typename TagValueAList::first_type AListFirst;
-        typedef typename AListFirst::first_type Tag2;
-        typedef typename AListFirst::second_type Value;
-        enum { match = same_property<Tag1,Tag2>::value };
-        typedef typename TagValueAList::second_type Next;
-        typedef typename ev_selector<Next>::type Extractor;
-        typedef typename boost::ct_if< match, Value, 
-          typename Extractor::template bind_<Next,Tag1>::type
-        >::type type;
-      };
-    };
-    struct end_extract {
-      template <class AList, class Tag1>
-      struct bind_ {
-        typedef error_property_not_found type;
-      };
-    };
-#endif //!defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
   } // namespace detail 
 } // namespace boost
 
diff --git a/include/boost/pending/indirect_cmp.hpp b/include/boost/pending/indirect_cmp.hpp
index 638625cec..14ee5314a 100644
--- a/include/boost/pending/indirect_cmp.hpp
+++ b/include/boost/pending/indirect_cmp.hpp
@@ -33,14 +33,15 @@ namespace boost {
     typedef typename boost::property_traits<ReadablePropertyMap>::key_type K;
     typedef K first_argument_type;
     typedef K second_argument_type;
-    typedef T result_type;
+    typedef bool result_type;
     inline indirect_cmp(const ReadablePropertyMap& df, const Compare& c = Compare())
       : d(df), cmp(c) { }
 
     template <class A, class B>
     inline bool 
     operator()(const A& u, const B& v) const {
-      T du = get(d, u), dv = get(d, v);
+      const T& du = get(d, u);
+      const T& dv = get(d, v);
       return cmp(du, dv);
     }
   protected:
diff --git a/include/boost/pending/property.hpp b/include/boost/pending/property.hpp
index c9880458c..e63a2d203 100644
--- a/include/boost/pending/property.hpp
+++ b/include/boost/pending/property.hpp
@@ -7,32 +7,166 @@
 #define BOOST_PROPERTY_HPP
 
 #include <boost/mpl/bool.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/has_xxx.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits.hpp>
+#include <boost/static_assert.hpp>
 
 namespace boost {
 
-  struct no_property {
-    typedef no_property tag_type;
-    typedef no_property next_type;
-    typedef no_property value_type;
-    enum { num = 0 };
-    typedef void kind;
-  };
+  struct no_property {};
 
   template <class Tag, class T, class Base = no_property>
-  struct property : public Base {
+  struct property {
     typedef Base next_type;
     typedef Tag tag_type;
     typedef T value_type;
-#if BOOST_WORKAROUND (__GNUC__, < 3)
-    property() { }
-#else
-    property() : m_value() { }
-#endif
-    property(const T& v) : m_value(v) { }
-    property(const T& v, const Base& b) : Base(b), m_value(v) { }
+    property(const T& v = T()) : m_value(v) { }
+    property(const T& v, const Base& b) : m_value(v), m_base(b) { }
     // copy constructor and assignment operator will be generated by compiler
 
     T m_value;
+    Base m_base;
+  };
+
+  // Kinds of properties
+  namespace graph_introspect_detail {
+    BOOST_MPL_HAS_XXX_TRAIT_DEF(kind)
+    template <typename T, bool Cond> struct get_kind {typedef void type;};
+    template <typename T> struct get_kind<T, true> {typedef typename T::kind type;};
+  }
+
+  // Having a default is to make this trait work for any type, not just valid
+  // properties, to work around VC++ <= 10 bugs related to SFINAE in
+  // compressed_sparse_row_graph's get functions and similar
+  template <class PropertyTag>
+  struct property_kind:
+    graph_introspect_detail::get_kind<PropertyTag, graph_introspect_detail::has_kind<PropertyTag>::value>
+  {};
+
+  // Some standard properties defined independently of Boost.Graph:
+  enum vertex_all_t {vertex_all};
+  enum edge_all_t {edge_all};
+  enum graph_all_t {graph_all};
+  enum vertex_bundle_t {vertex_bundle};
+  enum edge_bundle_t {edge_bundle};
+  enum graph_bundle_t {graph_bundle};
+
+  // Code to look up one property in a property list:
+  template <typename PList, typename PropName, typename Enable = void>
+  struct lookup_one_property_internal {BOOST_STATIC_CONSTANT(bool, found = false); typedef void type;};
+
+  // Special-case properties (vertex_all, edge_all, graph_all)
+#define BGL_ALL_PROP(tag) \
+  template <typename T> \
+  struct lookup_one_property_internal<T, tag> { \
+    BOOST_STATIC_CONSTANT(bool, found = true); \
+    typedef T type; \
+    static T& lookup(T& x, tag) {return x;} \
+    static const T& lookup(const T& x, tag) {return x;} \
+  }; \
+  template <typename Tag, typename T, typename Base> \
+  struct lookup_one_property_internal<property<Tag, T, Base>, tag> { /* Avoid ambiguity */ \
+    BOOST_STATIC_CONSTANT(bool, found = true); \
+    typedef property<Tag, T, Base> type; \
+    static type& lookup(type& x, tag) {return x;} \
+    static const type& lookup(const type& x, tag) {return x;} \
+  };
+
+  BGL_ALL_PROP(vertex_all_t)
+  BGL_ALL_PROP(edge_all_t)
+  BGL_ALL_PROP(graph_all_t)
+#undef BGL_ALL_PROP
+
+  // *_bundled; these need to be macros rather than inheritance to resolve ambiguities
+  #define BGL_DO_ONE_BUNDLE_TYPE(kind) \
+  template <typename T> \
+  struct lookup_one_property_internal<T, BOOST_JOIN(kind, _bundle_t)> { \
+    BOOST_STATIC_CONSTANT(bool, found = true); \
+    typedef T type; \
+    static T& lookup(T& x, BOOST_JOIN(kind, _bundle_t)) {return x;} \
+    static const T& lookup(const T& x, BOOST_JOIN(kind, _bundle_t)) {return x;} \
+  }; \
+ \
+  template <typename Tag, typename T, typename Base> \
+  struct lookup_one_property_internal<property<Tag, T, Base>, BOOST_JOIN(kind, _bundle_t)>: lookup_one_property_internal<Base, BOOST_JOIN(kind, _bundle_t)> { \
+    private: \
+    typedef lookup_one_property_internal<Base, BOOST_JOIN(kind, _bundle_t)> base_type; \
+    public: \
+    template <typename BundleTag> \
+    static typename lazy_enable_if_c<(base_type::found && (is_same<BundleTag, BOOST_JOIN(kind, _bundle_t)>::value)), \
+                                     add_reference<typename base_type::type> >::type \
+    lookup(property<Tag, T, Base>& p, BundleTag) {return base_type::lookup(p.m_base, BOOST_JOIN(kind, _bundle_t)());} \
+    template <typename BundleTag> \
+    static typename lazy_enable_if_c<(base_type::found && (is_same<BundleTag, BOOST_JOIN(kind, _bundle_t)>::value)), \
+                                     add_reference<const typename base_type::type> >::type \
+    lookup(const property<Tag, T, Base>& p, BundleTag) {return base_type::lookup(p.m_base, BOOST_JOIN(kind, _bundle_t)());} \
+  }; \
+
+  BGL_DO_ONE_BUNDLE_TYPE(vertex)
+  BGL_DO_ONE_BUNDLE_TYPE(edge)
+  BGL_DO_ONE_BUNDLE_TYPE(graph)
+#undef BGL_DO_ONE_BUNDLE_TYPE
+
+  // Normal old-style properties; second case also handles chaining of bundled property accesses
+  template <typename Tag, typename T, typename Base>
+  struct lookup_one_property_internal<boost::property<Tag, T, Base>, Tag> {
+    BOOST_STATIC_CONSTANT(bool, found = true);
+    typedef property<Tag, T, Base> prop;
+    typedef T type;
+    template <typename U>
+    static typename enable_if<is_same<prop, U>, T&>::type
+    lookup(U& prop, const Tag&) {return prop.m_value;}
+    template <typename U>
+    static typename enable_if<is_same<prop, U>, const T&>::type
+    lookup(const U& prop, const Tag&) {return prop.m_value;}
+  };
+
+  template <typename Tag, typename T, typename Base, typename PropName>
+  struct lookup_one_property_internal<boost::property<Tag, T, Base>, PropName>: lookup_one_property_internal<Base, PropName> {
+    private:
+    typedef lookup_one_property_internal<Base, PropName> base_type;
+    public:
+    template <typename PL>
+    static typename lazy_enable_if<is_same<PL, boost::property<Tag, T, Base> >,
+                                   add_reference<typename base_type::type> >::type
+    lookup(PL& prop, const PropName& tag) {
+      return base_type::lookup(prop.m_base, tag);
+    }
+    template <typename PL>
+    static typename lazy_enable_if<is_same<PL, boost::property<Tag, T, Base> >,
+                                   add_reference<const typename base_type::type> >::type
+    lookup(const PL& prop, const PropName& tag) {
+      return base_type::lookup(prop.m_base, tag);
+    }
+  };
+
+  // Pointer-to-member access to bundled properties
+#ifndef BOOST_GRAPH_NO_BUNDLED_PROPERTIES
+  template <typename T, typename TMaybeBase, typename R>
+  struct lookup_one_property_internal<T, R TMaybeBase::*, typename enable_if<is_base_of<TMaybeBase, T> >::type> {
+    BOOST_STATIC_CONSTANT(bool, found = true);
+    typedef R type;
+    static R& lookup(T& x, R TMaybeBase::*ptr) {return x.*ptr;}
+    static const R& lookup(const T& x, R TMaybeBase::*ptr) {return x.*ptr;}
+  };
+#endif
+
+  // Version of above handling const property lists properly
+  template <typename T, typename Tag>
+  struct lookup_one_property: lookup_one_property_internal<T, Tag> {};
+
+  template <typename T, typename Tag>
+  struct lookup_one_property<const T, Tag> {
+    BOOST_STATIC_CONSTANT(bool, found = (lookup_one_property_internal<T, Tag>::found));
+    typedef const typename lookup_one_property_internal<T, Tag>::type type;
+    template <typename U>
+    static typename lazy_enable_if<is_same<T, U>,
+                                   add_reference<const typename lookup_one_property_internal<T, Tag>::type> >::type
+    lookup(const U& p, Tag tag) {
+      return lookup_one_property_internal<T, Tag>::lookup(p, tag);
+    }
   };
 
   // The BGL properties specialize property_kind and
@@ -41,11 +175,6 @@ namespace boost {
   // instead with a nested kind type and num.  Also, we may want to
   // switch BGL back to using class types for properties at some point.
 
-  template <class PropertyTag>
-  struct property_kind {
-    typedef typename PropertyTag::kind type;
-  };
-
   template <class P>
   struct has_property : boost::mpl::true_ {};
   template <>
@@ -58,45 +187,18 @@ namespace boost {
 namespace boost {
 
   template <class PropertyList, class Tag>
-  struct property_value {
-#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-    typedef typename detail::build_property_tag_value_alist<PropertyList>::type AList;
-    typedef typename detail::extract_value<AList,Tag>::type type;
-#else
-    typedef typename detail::build_property_tag_value_alist<PropertyList>::type AList;
-    typedef typename detail::ev_selector<AList>::type Extractor;
-    typedef typename Extractor::template bind_<AList,Tag>::type type;
-#endif
-  };
+  struct property_value: lookup_one_property<PropertyList, Tag> {};
 
-  template <class Tag2>
-  inline detail::error_property_not_found
-  get_property_value(const no_property&, Tag2) {
-    return detail::error_property_not_found();
+  template <class PropertyList, class Tag>
+  inline typename lookup_one_property<PropertyList, Tag>::type&
+  get_property_value(PropertyList& p, Tag tag) {
+    return lookup_one_property<PropertyList, Tag>::lookup(p, tag);
   }
 
-  template <class Tag1, class Tag2, class T1, class Base>
-  inline typename property_value<property<Tag1,T1,Base>, Tag2>::type&
-  get_property_value(property<Tag1,T1,Base>& p, Tag2 tag2) {
-    BOOST_STATIC_CONSTANT(bool,
-                          match = (detail::same_property<Tag1,Tag2>::value));
-    typedef property<Tag1,T1,Base> Prop;
-    typedef typename property_value<Prop, Tag2>::type T2;
-    T2* t2 = 0;
-    typedef detail::property_value_dispatch<match> Dispatcher;
-    return Dispatcher::get_value(p, t2, tag2);
-  }
-  template <class Tag1, class Tag2, class T1, class Base>
-  inline
-  const typename property_value<property<Tag1,T1,Base>, Tag2>::type&
-  get_property_value(const property<Tag1,T1,Base>& p, Tag2 tag2) {
-    BOOST_STATIC_CONSTANT(bool,
-                          match = (detail::same_property<Tag1,Tag2>::value));
-    typedef property<Tag1,T1,Base> Prop;
-    typedef typename property_value<Prop, Tag2>::type T2;
-    T2* t2 = 0;
-    typedef detail::property_value_dispatch<match> Dispatcher;
-    return Dispatcher::const_get_value(p, t2, tag2);
+  template <class PropertyList, class Tag>
+  inline const typename lookup_one_property<PropertyList, Tag>::type&
+  get_property_value(const PropertyList& p, Tag tag) {
+    return lookup_one_property<PropertyList, Tag>::lookup(p, tag);
   }
 
  namespace detail {
@@ -107,61 +209,62 @@ namespace boost {
         : mpl::bool_<is_same<T, no_property>::value>
     { };
 
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-    /** @internal @name Retag Property List
-     * This metafunction is used internally to normalize a property if it is
-     * actually modeling a property. Specifically this is used in Boost.Graph
-     * to map user-provided classes into bundled properties.
-     */
-    //@{
-    // One base case of the recursive form (see below). This matches any
-    // retag request that does not include a property<...> or no_property as
-    // the FinalType. This is used for generating bundles in Boost.Graph.
-    template<typename FinalTag, typename FinalType>
-    struct retag_property_list
-    {
-        typedef property<FinalTag, FinalType> type;
-        typedef FinalType retagged;
-    };
+    template <typename PList, typename Tag>
+    class lookup_one_property_f;
 
-    // Recursively retag the nested property list.
-    template<typename FinalTag, typename Tag, typename T, typename Base>
-    struct retag_property_list<FinalTag, property<Tag, T, Base> >
-    {
-    private:
-        typedef retag_property_list<FinalTag, Base> next;
+    template <typename PList, typename Tag, typename F> struct lookup_one_property_f_result;
 
-    public:
-        typedef property<Tag, T, typename next::type> type;
-        typedef typename next::retagged retagged;
+    template <typename PList, typename Tag>
+    struct lookup_one_property_f_result<PList, Tag, const lookup_one_property_f<PList, Tag>(PList)> {
+      typedef typename lookup_one_property<PList, Tag>::type type;
     };
 
-    // This base case will correctly deduce the final property type if the
-    // retagged property is given in property form. This should not hide
-    // the base case below.
-    // NOTE: This addresses a problem of layering bundled properties in the BGL
-    // where multiple retaggings will fail to deduce the correct retagged
-    // type.
-    template<typename FinalTag, typename FinalType>
-    struct retag_property_list<FinalTag, property<FinalTag, FinalType> >
-    {
-    public:
-        typedef property<FinalTag, FinalType> type;
-        typedef FinalType retagged;
+    template <typename PList, typename Tag>
+    struct lookup_one_property_f_result<PList, Tag, const lookup_one_property_f<PList, Tag>(PList&)> {
+      typedef typename lookup_one_property<PList, Tag>::type& type;
     };
 
-    // A final base case of the retag_property_list, this will terminate a
-    // properly structured list.
-    template<typename FinalTag>
-    struct retag_property_list<FinalTag, no_property>
-    {
-        typedef no_property type;
-        typedef no_property retagged;
+    template <typename PList, typename Tag>
+    struct lookup_one_property_f_result<PList, Tag, const lookup_one_property_f<PList, Tag>(const PList&)> {
+      typedef const typename lookup_one_property<PList, Tag>::type& type;
     };
-    //@}
-#endif
+
+    template <typename PList, typename Tag>
+    class lookup_one_property_f {
+      Tag tag;
+      public:
+      lookup_one_property_f(Tag tag): tag(tag) {}
+      template <typename F> struct result: lookup_one_property_f_result<PList, Tag, F> {};
+
+      typename lookup_one_property_f_result<PList, Tag, const lookup_one_property_f(PList&)>::type
+      operator()(PList& pl) const {
+        return lookup_one_property<PList, Tag>::lookup(pl, tag);
+      }
+    };
+
 } // namespace detail
 
+namespace detail {
+  // Stuff for directed_graph and undirected_graph to skip over their first
+  // vertex_index and edge_index properties when providing vertex_all and
+  // edge_all; make sure you know the exact structure of your properties if you
+  // use there.
+  struct remove_first_property {
+    template <typename F>
+    struct result {
+      typedef typename boost::function_traits<F>::arg1_type a1;
+      typedef typename boost::remove_reference<a1>::type non_ref;
+      typedef typename non_ref::next_type nx;
+      typedef typename boost::mpl::if_<boost::is_const<non_ref>, boost::add_const<nx>, nx>::type with_const;
+      typedef typename boost::add_reference<with_const>::type type;
+    };
+    template <typename Prop>
+    typename Prop::next_type& operator()(Prop& p) const {return p.m_base;}
+    template <typename Prop>
+    const typename Prop::next_type& operator()(const Prop& p) const {return p.m_base;}
+  };
+}
+
 } // namesapce boost
 
 #endif /* BOOST_PROPERTY_HPP */
diff --git a/include/boost/pending/relaxed_heap.hpp b/include/boost/pending/relaxed_heap.hpp
index b3ab2ed20..13f7af4c0 100644
--- a/include/boost/pending/relaxed_heap.hpp
+++ b/include/boost/pending/relaxed_heap.hpp
@@ -163,7 +163,7 @@ class relaxed_heap
   void remove(const value_type& x)
   {
     group* a = &index_to_group[get(id, x) / log_n];
-    assert(groups[get(id, x)] != 0);
+    assert(groups[get(id, x)]);
     a->value = x;
     a->kind = smallest_key;
     promote(a);
diff --git a/src/graphml.cpp b/src/graphml.cpp
index 87cab74ca..76ef0a292 100644
--- a/src/graphml.cpp
+++ b/src/graphml.cpp
@@ -21,6 +21,8 @@
 
 using namespace boost;
 
+namespace {
+
 class graphml_reader
 {
 public:
@@ -32,17 +34,23 @@ class graphml_reader
     }
 
     static void get_graphs(const boost::property_tree::ptree& top,
+                           size_t desired_idx /* or -1 for all */,
                            std::vector<const boost::property_tree::ptree*>& result) {
       using boost::property_tree::ptree;
+      size_t current_idx = 0;
       BOOST_FOREACH(const ptree::value_type& n, top) {
         if (n.first == "graph") {
-          result.push_back(&n.second);
-          get_graphs(n.second, result);
+          if (current_idx == desired_idx || desired_idx == (size_t)(-1)) {
+            result.push_back(&n.second);
+            get_graphs(n.second, (size_t)(-1), result);
+            if (desired_idx != (size_t)(-1)) break;
+          }
+          ++current_idx;
         }
       }
     }
     
-    void run(std::istream& in)
+    void run(std::istream& in, size_t desired_idx)
     {
       using boost::property_tree::ptree;
       ptree pt;
@@ -63,6 +71,7 @@ class graphml_reader
         else if (for_ == "port") kind = port_key;
         else if (for_ == "endpoint") kind = endpoint_key;
         else if (for_ == "all") kind = all_key;
+        else if (for_ == "graphml") kind = graphml_key;
         else {BOOST_THROW_EXCEPTION(parse_error("Attribute for is not valid: " + for_));}
         m_keys[id] = kind;
         m_key_name[id] = name;
@@ -72,7 +81,7 @@ class graphml_reader
       }
       // Search for graphs
       std::vector<const ptree*> graphs;
-      get_graphs(gml, graphs);
+      get_graphs(gml, desired_idx, graphs);
       BOOST_FOREACH(const ptree* gr, graphs) {
         // Search for nodes
         BOOST_FOREACH(const ptree::value_type& node, *gr) {
@@ -92,7 +101,6 @@ class graphml_reader
         // Search for edges
         BOOST_FOREACH(const ptree::value_type& edge, *gr) {
           if (edge.first != "edge") continue;
-          std::string id = edge.second.get<std::string>(path("<xmlattr>/id"));
           std::string source = edge.second.get<std::string>(path("<xmlattr>/source"));
           std::string target = edge.second.get<std::string>(path("<xmlattr>/target"));
           std::string local_directed = edge.second.get(path("<xmlattr>/directed"), "");
@@ -125,7 +133,8 @@ class graphml_reader
         hyperedge_key,
         port_key,
         endpoint_key, 
-        all_key
+        all_key,
+        graphml_key
     };
 
     void 
@@ -203,12 +212,14 @@ class graphml_reader
     std::vector<any> m_edge;
 };
 
+}
+
 namespace boost
 {
 void BOOST_GRAPH_DECL
-read_graphml(std::istream& in, mutate_graph& g)
+read_graphml(std::istream& in, mutate_graph& g, size_t desired_idx)
 {    
     graphml_reader reader(g);
-    reader.run(in);
+    reader.run(in, desired_idx);
 }
 }
diff --git a/src/read_graphviz_new.cpp b/src/read_graphviz_new.cpp
index 9e87ca23c..02dee38e1 100644
--- a/src/read_graphviz_new.cpp
+++ b/src/read_graphviz_new.cpp
@@ -26,6 +26,7 @@
 //
 
 #define BOOST_GRAPH_SOURCE
+#include <boost/assert.hpp>
 #include <boost/ref.hpp>
 #include <boost/function/function2.hpp>
 #include <boost/property_map/dynamic_property_map.hpp>
@@ -143,7 +144,7 @@ namespace read_graphviz_detail {
     {
       std::string end_of_token = "(?=(?:\\W))";
       std::string whitespace = "(?:\\s+)";
-      std::string slash_slash_comment = "(?://.*$)";
+      std::string slash_slash_comment = "(?://.*?$)";
       std::string slash_star_comment = "(?:/\\*.*?\\*/)";
       std::string hash_comment = "(?:^#.*?$)";
       std::string backslash_newline = "(?:[\\\\][\\n])";
@@ -167,10 +168,10 @@ namespace read_graphviz_detail {
 #endif
         boost::regex_search(begin, end, results, stuff_to_skip);
 #ifndef NDEBUG
-      assert (found);
+      BOOST_ASSERT (found);
 #endif
       boost::sub_match<std::string::const_iterator> sm1 = results.suffix();
-      assert (sm1.second == end);
+      BOOST_ASSERT (sm1.second == end);
       begin = sm1.first;
     }
 
@@ -227,10 +228,10 @@ namespace read_graphviz_detail {
             switch (str[1]) {
               case '-': return token(token::dash_dash, str);
               case '>': return token(token::dash_greater, str);
-              default: assert (!"Definition of punctuation_token does not match switch statement");
+              default: BOOST_ASSERT (!"Definition of punctuation_token does not match switch statement");
             }
           }
-          default: assert (!"Definition of punctuation_token does not match switch statement");
+          default: BOOST_ASSERT (!"Definition of punctuation_token does not match switch statement");
         }
       }
       found = boost::regex_search(begin, end, results, number_token);
@@ -244,7 +245,7 @@ namespace read_graphviz_detail {
         std::string str = results[1].str();
         begin = results.suffix().first;
         // Remove the beginning and ending quotes
-        assert (str.size() >= 2);
+        BOOST_ASSERT (str.size() >= 2);
         str.erase(str.begin());
         str.erase(str.end() - 1);
         // Unescape quotes in the middle, but nothing else (see format spec)
@@ -500,7 +501,7 @@ namespace read_graphviz_detail {
         case token::kw_graph: parse_attr_list(current_graph_props()); break;
         case token::kw_node: parse_attr_list(current().def_node_props); break;
         case token::kw_edge: parse_attr_list(current().def_edge_props); break;
-        default: assert (!"Bad attr_stmt case");
+        default: BOOST_ASSERT (!"Bad attr_stmt case");
       }
     }
 
@@ -637,7 +638,7 @@ namespace read_graphviz_detail {
       }
       properties this_edge_props = current().def_edge_props;
       if (peek().type == token::left_bracket) parse_attr_list(this_edge_props);
-      assert (nodes_in_chain.size() >= 2); // Should be in node parser otherwise
+      BOOST_ASSERT (nodes_in_chain.size() >= 2); // Should be in node parser otherwise
       for (size_t i = 0; i + 1 < nodes_in_chain.size(); ++i) {
         do_orig_edge(nodes_in_chain[i], nodes_in_chain[i + 1], this_edge_props);
       }
@@ -717,7 +718,7 @@ namespace read_graphviz_detail {
               std::string rhs = "true";
               if (peek().type == token::equal) {
                 get();
-                if (peek().type != token::identifier) error("Wanted identifier as value of attributed");
+                if (peek().type != token::identifier) error("Wanted identifier as value of attribute");
                 rhs = get().normalized_value;
               }
               props[lhs] = rhs;
@@ -761,7 +762,6 @@ namespace read_graphviz_detail {
   }
 
   void translate_results_to_graph(const parser_result& r, ::boost::detail::graph::mutate_graph* mg) {
-    typedef boost::detail::graph::node_t vertex;
     typedef boost::detail::graph::edge_t edge;
     for (std::map<node_name, properties>::const_iterator i = r.nodes.begin(); i != r.nodes.end(); ++i) {
       // std::cerr << i->first << " " << props_to_string(i->second) << std::endl;
@@ -780,12 +780,13 @@ namespace read_graphviz_detail {
       }
     }
     std::map<subgraph_name, properties>::const_iterator root_graph_props_i = r.graph_props.find("___root___");
-    assert (root_graph_props_i != r.graph_props.end()); // Should not happen
+    BOOST_ASSERT (root_graph_props_i != r.graph_props.end()); // Should not happen
     const properties& root_graph_props = root_graph_props_i->second;
     // std::cerr << "ending graph " << props_to_string(root_graph_props) << std::endl;
     for (properties::const_iterator i = root_graph_props.begin(); i != root_graph_props.end(); ++i) {
       mg->set_graph_property(i->first, i->second);
     }
+    mg->finish_building_graph();
   }
 
 } // end namespace read_graphviz_detail
diff --git a/test/Jamfile.v2 b/test/Jamfile.v2
index 5e01a4e39..5487631ff 100644
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -8,6 +8,7 @@
 # LEDA (also top level directory) at the command line of jam using -s
 
 import modules ;
+import path ;
 
 path-constant TEST_DIR : . ;
 
@@ -42,6 +43,7 @@ test-suite graph_test :
     [ run csr_graph_test.cpp : : : : : <variant>release ]
     [ run dag_longest_paths.cpp ]
     [ run dfs.cpp ../../test/build//boost_test_exec_monitor ]
+    [ run undirected_dfs.cpp ../../test/build//boost_test_exec_monitor ]
     [ compile dfs_cc.cpp ]
     [ compile dijkstra_cc.cpp ]
     [ run dijkstra_heap_performance.cpp : 10000 ]
@@ -102,6 +104,7 @@ test-suite graph_test :
         ../../system/build
         : $(PLANAR_INPUT_FILES) ]
     [ run r_c_shortest_paths_test.cpp ]
+    [ run rcsp_custom_vertex_id.cpp ]
     [ run is_straight_line_draw_test.cpp ]
     [ run metric_tsp_approx.cpp : metric_tsp_approx.graph ]
     [ compile dimacs.cpp ]
@@ -118,29 +121,36 @@ test-suite graph_test :
     [ compile grid_graph_cc.cpp ]
     [ run grid_graph_test.cpp ]
     [ run incremental_components_test.cpp ]
+    [ run two_graphs_common_spanning_trees_test.cpp ]
     [ run random_spanning_tree_test.cpp ../build//boost_graph ]
     [ run graphml_test.cpp ../build//boost_graph : : "graphml_test.xml" ]
-    [ run stoer_wagner_test.cpp ../../test/build : $(TEST_DIR) ]
+    [ run mas_test.cpp ../../test/build//boost_unit_test_framework/<link>static : $(TEST_DIR) ]
+    [ run stoer_wagner_test.cpp ../../test/build//boost_unit_test_framework/<link>static : $(TEST_DIR) ]
+    [ compile filtered_graph_properties_dijkstra.cpp ]
+    [ run vf2_sub_graph_iso_test.cpp ]
+    [ run vf2_sub_graph_iso_test_2.cpp ]
+    [ run hawick_circuits.cpp ]
+    [ run successive_shortest_path_nonnegative_weights_test.cpp ../../test/build//boost_unit_test_framework/<link>static ]
+    [ run cycle_canceling_test.cpp ../../test/build//boost_unit_test_framework/<link>static ]
     ;
 
 # Run SDB tests only when -sSDB= is set.
-if [ modules.peek : SDB ] != ""
+local SDB = [ modules.peek : SDB ] ;
+if $(SDB)
 {
-    local SDB_DEPENDENCIES =
-        <include>$(SGB) <library-file>$(SGB)/libgb.a  ;
+    local sdb-root = [ path.root [ path.make $(SDB) ] [ path.pwd ] ] ;
 
-    compile stanford_graph_cc.cpp
-        $(SDB_DEPENDENCIES)  ;
+    compile stanford_graph_cc.cpp :
+        <include>$(sdb-root) ;
 }
 
 # Run LEDA tests only when -sLEDA= is set.
-if [ modules.peek : LEDA ] != ""
+local LEDA = [ modules.peek : LEDA ] ;
+if $(LEDA)
 {
-     local LEDA_DEPENDENCIES =
-        <include>$(LEDA)/incl
-        <library-file>$(LEDA)/libG.a
-        ;
+    local leda-root = [ path.root [ path.make $(LEDA) ] [ path.pwd ] ] ;
+    local leda-include = [ path.join $(leda-root) incl ] ;
 
-    compile leda_graph_cc.cpp
-       $(LEDA_DEPENDENCIES) ;
+    compile leda_graph_cc.cpp :
+        <include>$(leda-include) ;
 }
diff --git a/test/adj_list_cc.cpp b/test/adj_list_cc.cpp
index 8f22d5735..b1e2d544d 100644
--- a/test/adj_list_cc.cpp
+++ b/test/adj_list_cc.cpp
@@ -9,6 +9,7 @@
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/graph_archetypes.hpp>
 #include <boost/graph/adjacency_list.hpp>
+#include <boost/concept/assert.hpp>
 
 int main(int,char*[])
 {
@@ -21,20 +22,20 @@ int main(int,char*[])
     > Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< EdgeListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< MutableIncidenceGraphConcept<Graph> >();
-    function_requires< MutableEdgeListGraphConcept<Graph> >();
-    function_requires< VertexMutablePropertyGraphConcept<Graph> >();
-    function_requires< EdgeMutablePropertyGraphConcept<Graph> >();
-    function_requires<
-      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> >();
-    function_requires<
-      LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> >();
-    function_requires<
-      LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableIncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( VertexMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( 
+      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> ));
+    BOOST_CONCEPT_ASSERT(( 
+      LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> ));
+    BOOST_CONCEPT_ASSERT(( 
+      LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> ));
   }
   {
     typedef adjacency_list<vecS, vecS, bidirectionalS, 
@@ -43,21 +44,21 @@ int main(int,char*[])
     > Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< EdgeListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< BidirectionalGraphConcept<Graph> >();
-    function_requires< MutableBidirectionalGraphConcept<Graph> >();
-    function_requires< MutableEdgeListGraphConcept<Graph> >();
-    function_requires< VertexMutablePropertyGraphConcept<Graph> >();
-    function_requires< EdgeMutablePropertyGraphConcept<Graph> >();
-    function_requires<
-      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> >();
-    function_requires<
-      LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> >();
-    function_requires<
-      LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableBidirectionalGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( VertexMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( 
+      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> ));
+    BOOST_CONCEPT_ASSERT(( 
+      LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> ));
+    BOOST_CONCEPT_ASSERT(( 
+      LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> ));
   }
   {
     typedef adjacency_list< listS, listS, directedS, 
@@ -66,20 +67,18 @@ int main(int,char*[])
     > Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< EdgeListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< MutableIncidenceGraphConcept<Graph> >();
-    function_requires< MutableEdgeListGraphConcept<Graph> >();
-    function_requires< VertexMutablePropertyGraphConcept<Graph> >();
-    function_requires< EdgeMutablePropertyGraphConcept<Graph> >();
-    function_requires< 
-      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> >();
-    function_requires<
-      LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> >();
-    function_requires<
-      LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableIncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( VertexMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( 
+      LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> ));
+    BOOST_CONCEPT_ASSERT(( 
+      LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> ));
   }
   {
     typedef adjacency_list< listS, listS, undirectedS, 
@@ -88,20 +87,18 @@ int main(int,char*[])
     > Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< EdgeListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< MutableBidirectionalGraphConcept<Graph> >();
-    function_requires< MutableEdgeListGraphConcept<Graph> >();
-    function_requires< VertexMutablePropertyGraphConcept<Graph> >();
-    function_requires< EdgeMutablePropertyGraphConcept<Graph> >();
-    function_requires<
-      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> >();
-    function_requires<
-      LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> >();
-    function_requires<
-      LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableBidirectionalGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( VertexMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( 
+      LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> ));
+    BOOST_CONCEPT_ASSERT(( 
+      LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> ));
   }
   // Checking adjacency_list with EdgeList=setS
   {
@@ -111,21 +108,21 @@ int main(int,char*[])
     > Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< EdgeListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< BidirectionalGraphConcept<Graph> >();
-    function_requires< MutableBidirectionalGraphConcept<Graph> >();
-    function_requires< MutableEdgeListGraphConcept<Graph> >();
-    function_requires< VertexMutablePropertyGraphConcept<Graph> >();
-    function_requires< EdgeMutablePropertyGraphConcept<Graph> >();
-    function_requires<
-      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> >();
-    function_requires<
-      LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> >();
-    function_requires<
-      LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableBidirectionalGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( VertexMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( 
+      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> ));
+    BOOST_CONCEPT_ASSERT(( 
+      LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> ));
+    BOOST_CONCEPT_ASSERT(( 
+      LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> ));
   }
   {
     typedef adjacency_list< setS, listS, directedS, 
@@ -134,20 +131,18 @@ int main(int,char*[])
     > Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< EdgeListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< MutableIncidenceGraphConcept<Graph> >();
-    function_requires< MutableEdgeListGraphConcept<Graph> >();
-    function_requires< VertexMutablePropertyGraphConcept<Graph> >();
-    function_requires< EdgeMutablePropertyGraphConcept<Graph> >();
-    function_requires<
-      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> >();
-    function_requires<
-      LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> >();
-    function_requires<
-      LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableIncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( VertexMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( 
+      LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> ));
+    BOOST_CONCEPT_ASSERT(( 
+      LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> ));
   }
   {
     typedef adjacency_list< setS, listS, undirectedS, 
@@ -156,105 +151,103 @@ int main(int,char*[])
     > Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< EdgeListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< MutableBidirectionalGraphConcept<Graph> >();
-    function_requires< MutableEdgeListGraphConcept<Graph> >();
-    function_requires< VertexMutablePropertyGraphConcept<Graph> >();
-    function_requires< EdgeMutablePropertyGraphConcept<Graph> >();
-    function_requires<
-      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> >();
-    function_requires<
-      LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> >();
-    function_requires<
-      LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableBidirectionalGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( VertexMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( 
+      LvaluePropertyGraphConcept<Graph, Vertex, vertex_color_t> ));
+    BOOST_CONCEPT_ASSERT(( 
+      LvaluePropertyGraphConcept<Graph, Edge, edge_weight_t> ));
   }
   // Check adjacency_list without any properties
   {
     typedef adjacency_list<vecS, vecS, directedS > Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< EdgeListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< MutableIncidenceGraphConcept<Graph> >();
-    function_requires< MutableEdgeListGraphConcept<Graph> >();
-    function_requires< VertexMutablePropertyGraphConcept<Graph> >();
-    function_requires< EdgeMutablePropertyGraphConcept<Graph> >();
-    function_requires<
-      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableIncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( VertexMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( 
+      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> ));
   }
   {
     typedef adjacency_list<vecS, vecS, bidirectionalS> Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< EdgeListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< BidirectionalGraphConcept<Graph> >();
-    function_requires< MutableBidirectionalGraphConcept<Graph> >();
-    function_requires< MutableEdgeListGraphConcept<Graph> >();
-    function_requires<
-      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableBidirectionalGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( 
+      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> ));
   }
   {
     typedef adjacency_list< listS, listS, directedS> Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< EdgeListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< MutableIncidenceGraphConcept<Graph> >();
-    function_requires< MutableEdgeListGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableIncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
   }
   {
     typedef adjacency_list< listS, listS, undirectedS> Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< EdgeListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< MutableBidirectionalGraphConcept<Graph> >();
-    function_requires< MutableEdgeListGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableBidirectionalGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
   }
   // Checking EdgeList=setS with no properties
   {
     typedef adjacency_list<setS, vecS, bidirectionalS> Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< EdgeListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< BidirectionalGraphConcept<Graph> >();
-    function_requires< MutableBidirectionalGraphConcept<Graph> >();
-    function_requires< MutableEdgeListGraphConcept<Graph> >();
-    function_requires< ReadablePropertyGraphConcept<Graph, 
-      Vertex, vertex_index_t> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableBidirectionalGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyGraphConcept<Graph, 
+      Vertex, vertex_index_t> ));
   }
   {
     typedef adjacency_list< setS, listS, directedS> Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< MutableIncidenceGraphConcept<Graph> >();
-    function_requires< MutableEdgeListGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( MutableIncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
   }
   {
     typedef adjacency_list< setS, listS, undirectedS> Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< EdgeListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< MutableBidirectionalGraphConcept<Graph> >();
-    function_requires< MutableEdgeListGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableBidirectionalGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableEdgeListGraphConcept<Graph> ));
   }
   return 0;
 }
diff --git a/test/adj_list_loops.cpp b/test/adj_list_loops.cpp
index 205f37306..cd7b0896d 100644
--- a/test/adj_list_loops.cpp
+++ b/test/adj_list_loops.cpp
@@ -17,7 +17,6 @@ template <typename Graph>
 void test_graph_nonloop()
 {
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
-    typedef typename graph_traits<Graph>::edge_descriptor Edge;
 
     // Build a graph with 1 edge and turn it into a loop.
     Graph g(5);
@@ -36,7 +35,6 @@ template <typename Graph>
 void test_multigraph_nonloop()
 {
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
-    typedef typename graph_traits<Graph>::edge_descriptor Edge;
 
     // Build a graph with 1 edge and turn it into a loop.
     Graph g(5);
@@ -55,7 +53,6 @@ template <typename Graph>
 void test_graph_loop()
 {
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
-    typedef typename graph_traits<Graph>::edge_descriptor Edge;
 
     Graph g(5);
     Vertex v = *next(vertices(g).first, 2);
@@ -70,7 +67,6 @@ template <typename Graph>
 void test_multigraph_loop()
 {
     typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
-    typedef typename graph_traits<Graph>::edge_descriptor Edge;
 
     Graph g(5);
     Vertex v = *next(vertices(g).first, 2);
diff --git a/test/adj_matrix_cc.cpp b/test/adj_matrix_cc.cpp
index 317a22f4a..ae8060145 100644
--- a/test/adj_matrix_cc.cpp
+++ b/test/adj_matrix_cc.cpp
@@ -9,6 +9,7 @@
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/graph_archetypes.hpp>
 #include <boost/graph/adjacency_matrix.hpp>
+#include <boost/concept/assert.hpp>
 
 int main(int,char*[])
 {
@@ -16,21 +17,21 @@ int main(int,char*[])
   // Check adjacency_matrix without properties
   {
     typedef adjacency_matrix<directedS> Graph;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< EdgeListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< MutableGraphConcept<Graph> >();
-    function_requires< AdjacencyMatrixConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept<Graph> ));
   }
   {
     typedef adjacency_matrix<undirectedS> Graph;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< EdgeListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< MutableGraphConcept<Graph> >();
-    function_requires< AdjacencyMatrixConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( MutableGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept<Graph> ));
   }
   // Check adjacency_matrix with properties
   {
@@ -39,17 +40,17 @@ int main(int,char*[])
       property<edge_weight_t, float> > Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< EdgeListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< AdjacencyMatrixConcept<Graph> >();
-    function_requires< VertexMutablePropertyGraphConcept<Graph> >();
-    function_requires< EdgeMutablePropertyGraphConcept<Graph> >();
-    function_requires< ReadablePropertyGraphConcept<Graph, 
-      Vertex, vertex_index_t> >();
-    function_requires< PropertyGraphConcept<Graph, Vertex, vertex_color_t> >();
-    function_requires< PropertyGraphConcept<Graph, Edge, edge_weight_t> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( VertexMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyGraphConcept<Graph, 
+      Vertex, vertex_index_t> ));
+    BOOST_CONCEPT_ASSERT(( PropertyGraphConcept<Graph, Vertex, vertex_color_t> ));
+    BOOST_CONCEPT_ASSERT(( PropertyGraphConcept<Graph, Edge, edge_weight_t> ));
   }
   {
     typedef adjacency_matrix<undirectedS, 
@@ -57,17 +58,17 @@ int main(int,char*[])
       property<edge_weight_t, float> > Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< EdgeListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< AdjacencyMatrixConcept<Graph> >();
-    function_requires< VertexMutablePropertyGraphConcept<Graph> >();
-    function_requires< EdgeMutablePropertyGraphConcept<Graph> >();
-    function_requires< ReadablePropertyGraphConcept<Graph, 
-      Vertex, vertex_index_t> >();
-    function_requires< PropertyGraphConcept<Graph, Vertex, vertex_color_t> >();
-    function_requires< PropertyGraphConcept<Graph, Edge, edge_weight_t> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyMatrixConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( VertexMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyGraphConcept<Graph, 
+      Vertex, vertex_index_t> ));
+    BOOST_CONCEPT_ASSERT(( PropertyGraphConcept<Graph, Vertex, vertex_color_t> ));
+    BOOST_CONCEPT_ASSERT(( PropertyGraphConcept<Graph, Edge, edge_weight_t> ));
   }
   return 0;
 }
diff --git a/test/all_planar_input_files_test.cpp b/test/all_planar_input_files_test.cpp
index b0d5289da..e918f1f84 100644
--- a/test/all_planar_input_files_test.cpp
+++ b/test/all_planar_input_files_test.cpp
@@ -18,6 +18,8 @@ This test needs to be linked against Boost.Filesystem.
 
 */
 
+#define BOOST_FILESYSTEM_VERSION 3
+
 #include <iostream>
 #include <fstream>
 #include <vector>
@@ -120,9 +122,7 @@ int test_graph(const std::string& dimacs_filename)
   typedef graph_traits<graph>::edge_iterator edge_iterator_t;
   typedef graph_traits<graph>::vertex_iterator vertex_iterator_t;
   typedef graph_traits<graph>::edges_size_type e_size_t;
-  typedef graph_traits<graph>::vertices_size_type v_size_t;
   typedef graph_traits<graph>::vertex_descriptor vertex_t;
-  typedef std::pair<vertex_t, vertex_t> vertex_pair_t;
   typedef edge_index_update_visitor<property_map<graph, edge_index_t>::type> 
     edge_visitor_t;
 
@@ -135,7 +135,7 @@ int test_graph(const std::string& dimacs_filename)
   // Initialize the interior edge index
   property_map<graph, edge_index_t>::type e_index = get(edge_index, g);
   e_size_t edge_count = 0;
-  for(tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
+  for(boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
     put(e_index, *ei, edge_count++);
 
   // Initialize the interior vertex index - not needed if the vertices
@@ -143,7 +143,7 @@ int test_graph(const std::string& dimacs_filename)
   /*
   property_map<graph, vertex_index_t>::type v_index = get(vertex_index, g);
   v_size_t vertex_count = 0;
-  for(tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
+  for(boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
     put(v_index, *vi, vertex_count++);
   */
 
@@ -264,20 +264,19 @@ int test_main(int argc, char* argv[])
             << std::endl;
 
   filesystem::path input_directory = 
-    filesystem::system_complete
-    (filesystem::path(input_directory_str, filesystem::native));
-  const std::string dimacs_suffix = ".dimacs";
+    filesystem::system_complete(filesystem::path(input_directory_str));
+  const std::string dimacs_extension = ".dimacs";
 
   filesystem::directory_iterator dir_end;
   for( filesystem::directory_iterator dir_itr(input_directory);
        dir_itr != dir_end; ++dir_itr)
   { 
 
-    if (!ends_with(dir_itr->string(), dimacs_suffix))
+    if (dir_itr->path().extension() != dimacs_extension)
       continue;
 
     std::cout << "Testing " << dir_itr->path().leaf() << "... ";
-    BOOST_REQUIRE (test_graph(dir_itr->string()) == 0);
+    BOOST_REQUIRE (test_graph(dir_itr->path().string()) == 0);
 
     std::cout << std::endl;
   }
diff --git a/test/astar_search_test.cpp b/test/astar_search_test.cpp
index 36fb0a47d..72f29150d 100644
--- a/test/astar_search_test.cpp
+++ b/test/astar_search_test.cpp
@@ -15,6 +15,7 @@
 #include <boost/graph/adjacency_list.hpp>
 #include <boost/graph/random.hpp>
 #include <boost/random.hpp>
+#include <utility>
 #include <vector>
 #include <list>
 #include <iostream>
@@ -30,7 +31,12 @@ struct location
 {
   float y, x; // lat, long
 };
-typedef float cost;
+struct my_float {float v; explicit my_float(float v = float()): v(v) {}};
+typedef my_float cost;
+ostream& operator<<(ostream& o, my_float f) {return o << f.v;}
+my_float operator+(my_float a, my_float b) {return my_float(a.v + b.v);}
+bool operator==(my_float a, my_float b) {return a.v == b.v;}
+bool operator<(my_float a, my_float b) {return a.v < b.v;}
 
 template <class Name, class LocMap>
 class city_writer {
@@ -79,9 +85,9 @@ class distance_heuristic : public astar_heuristic<Graph, CostType>
     : m_location(l), m_goal(goal) {}
   CostType operator()(Vertex u)
   {
-    CostType dx = m_location[m_goal].x - m_location[u].x;
-    CostType dy = m_location[m_goal].y - m_location[u].y;
-    return ::sqrt(dx * dx + dy * dy);
+    float dx = m_location[m_goal].x - m_location[u].x;
+    float dy = m_location[m_goal].y - m_location[u].y;
+    return CostType(::sqrt(dx * dx + dy * dy));
   }
 private:
   LocMap m_location;
@@ -116,7 +122,6 @@ int main(int, char **)
   typedef property_map<mygraph_t, edge_weight_t>::type WeightMap;
   typedef mygraph_t::vertex_descriptor vertex;
   typedef mygraph_t::edge_descriptor edge_descriptor;
-  typedef mygraph_t::vertex_iterator vertex_iterator;
   typedef std::pair<int, int> edge;
   
   // specify data
@@ -152,8 +157,8 @@ int main(int, char **)
   };
   unsigned int num_edges = sizeof(edge_array) / sizeof(edge);
   cost weights[] = { // estimated travel time (mins)
-    96, 134, 143, 65, 115, 133, 117, 116, 74, 56,
-    84, 73, 69, 70, 116, 147, 173, 183, 74, 71, 124
+    my_float(96), my_float(134), my_float(143), my_float(65), my_float(115), my_float(133), my_float(117), my_float(116), my_float(74), my_float(56),
+    my_float(84), my_float(73), my_float(69), my_float(70), my_float(116), my_float(147), my_float(173), my_float(183), my_float(74), my_float(71), my_float(124)
   };
   
   
@@ -179,14 +184,19 @@ int main(int, char **)
   
   vector<mygraph_t::vertex_descriptor> p(num_vertices(g));
   vector<cost> d(num_vertices(g));
+
+  boost::property_map<mygraph_t, boost::vertex_index_t>::const_type
+    idx = get(boost::vertex_index, g);
+
   try {
     // call astar named parameter interface
     astar_search
       (g, start,
        distance_heuristic<mygraph_t, cost, location*>
         (locations, goal),
-       predecessor_map(&p[0]).distance_map(&d[0]).
-       visitor(astar_goal_visitor<vertex>(goal)));
+       predecessor_map(make_iterator_property_map(p.begin(), idx)).
+       distance_map(make_iterator_property_map(d.begin(), idx)).
+       visitor(astar_goal_visitor<vertex>(goal)).distance_inf(my_float((std::numeric_limits<float>::max)())));
   
   
   } catch(found_goal fg) { // found a path to the goal
diff --git a/test/basic_planarity_test.cpp b/test/basic_planarity_test.cpp
index 3c956d7eb..21ae969a6 100644
--- a/test/basic_planarity_test.cpp
+++ b/test/basic_planarity_test.cpp
@@ -25,7 +25,7 @@ struct VertexIndexUpdater
     typename property_map<Graph, vertex_index_t>::type index = get(vertex_index, g);
     typename graph_traits<Graph>::vertex_iterator vi, vi_end;
     typename graph_traits<Graph>::vertices_size_type cnt = 0;
-    for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
+    for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
       put(index, *vi, cnt++);
   }
 };
diff --git a/test/bellman-test.cpp b/test/bellman-test.cpp
index 53bba704a..a285b31d7 100644
--- a/test/bellman-test.cpp
+++ b/test/bellman-test.cpp
@@ -42,7 +42,7 @@ int test_main(int, char*[])
     weight_pmap = get(edge_weight, g);
 
   int i = 0;
-  for(tie(ei, ei_end) = edges(g); ei != ei_end; ++ei, ++i)
+  for(boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei, ++i)
     weight_pmap[*ei] = weight[i];
 
   std::vector<int> parent(numVertex);
@@ -56,8 +56,8 @@ int test_main(int, char*[])
   bool const r = bellman_ford_shortest_paths
     (g, int (numVertex),
      weight_pmap, 
-     &parent[0],
-     &distance[0],
+     boost::make_iterator_property_map(parent.begin(), get(boost::vertex_index, g)),
+     boost::make_iterator_property_map(distance.begin(), get(boost::vertex_index, g)),
      closed_plus<int>(),
      std::less<int>(),
      default_bellman_visitor());
@@ -81,8 +81,10 @@ int test_main(int, char*[])
   std::vector<int> distance2(numVertex, 17);
   bool const r2 = bellman_ford_shortest_paths
                     (g, 
-                     weight_map(weight_pmap).distance_map(&distance2[0]).
-                     predecessor_map(&parent2[0]).root_vertex(s));
+                     weight_map(weight_pmap).
+                     distance_map(boost::make_iterator_property_map(distance2.begin(), get(boost::vertex_index, g))).
+                     predecessor_map(boost::make_iterator_property_map(parent2.begin(), get(boost::vertex_index, g))).
+                     root_vertex(s));
   if (r2) {
     for(int i = 0; i < numVertex; ++i) {
       std::cout << name[i] << ": ";
diff --git a/test/bfs.cpp b/test/bfs.cpp
index 7e59ac9b3..615999a9f 100644
--- a/test/bfs.cpp
+++ b/test/bfs.cpp
@@ -140,20 +140,38 @@ struct bfs_test
           parent[*ui] = *ui;
         std::vector<boost::default_color_type> color(i);
 
+        // Get vertex index map
+        typedef typename boost::property_map<Graph, boost::vertex_index_t>::const_type idx_type;
+        idx_type idx = get(boost::vertex_index, g);
+
+        // Make property maps from vectors
+        typedef
+          boost::iterator_property_map<std::vector<int>::iterator, idx_type>
+          distance_pm_type;
+        distance_pm_type distance_pm(distance.begin(), idx);
+        typedef
+          boost::iterator_property_map<typename std::vector<vertex_descriptor>::iterator, idx_type>
+          parent_pm_type;
+        parent_pm_type parent_pm(parent.begin(), idx);
+        typedef
+          boost::iterator_property_map<std::vector<boost::default_color_type>::iterator, idx_type>
+          color_pm_type;
+        color_pm_type color_pm(color.begin(), idx);
+
         // Create the testing visitor.
-        bfs_testing_visitor<int*,vertex_descriptor*,Graph,
-          boost::default_color_type*>
-          vis(start, &distance[0], &parent[0], &color[0]);
+        bfs_testing_visitor<distance_pm_type, parent_pm_type, Graph,
+          color_pm_type>
+          vis(start, distance_pm, parent_pm, color_pm);
 
         boost::breadth_first_search(g, start,
                                     visitor(vis).
-                                    color_map(&color[0]));
+                                    color_map(color_pm));
 
         // All white vertices should be unreachable from the source.
         for (boost::tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui)
           if (color[*ui] == Color::white()) {
             std::vector<boost::default_color_type> color2(i, Color::white());
-            BOOST_CHECK(!boost::is_reachable(start, *ui, g, &color2[0]));
+            BOOST_CHECK(!boost::is_reachable(start, *ui, g, color_pm_type(color2.begin(), idx)));
           }
 
         // The shortest path to a child should be one longer than
diff --git a/test/biconnected_components_test.cpp b/test/biconnected_components_test.cpp
index ee37375fc..6ec321a9f 100644
--- a/test/biconnected_components_test.cpp
+++ b/test/biconnected_components_test.cpp
@@ -77,23 +77,11 @@ check_articulation_points(const Graph& g, std::vector<Vertex> art_points)
   } else std::cout << "OK." << std::endl;
 }
 
-int test_main(int argc, char* argv[])
-{
-  std::size_t n = 100;
-  std::size_t m = 500;
-  std::size_t seed = 1;
+typedef adjacency_list<listS, vecS, undirectedS,
+                       no_property, EdgeProperty> Graph;
+typedef graph_traits<Graph>::vertex_descriptor Vertex;
 
-  if (argc > 1) n = lexical_cast<std::size_t>(argv[1]);
-  if (argc > 2) m = lexical_cast<std::size_t>(argv[2]);
-  if (argc > 3) seed = lexical_cast<std::size_t>(argv[3]);
-
-  typedef adjacency_list<listS, vecS, undirectedS,
-                         no_property, EdgeProperty> Graph;
-  typedef graph_traits<Graph>::vertex_descriptor Vertex;
-  
-  Graph g(n);
-  minstd_rand gen(seed);
-  generate_random_graph(g, n, m, gen);
+bool test_graph(Graph& g) { // Returns false on failure
   std::vector<Vertex> art_points;
 
   std::cout << "Computing biconnected components & articulation points... ";
@@ -127,5 +115,34 @@ int test_main(int argc, char* argv[])
     out << "}\n";
   }
 
+  return any_errors;
+}
+  
+int test_main(int argc, char* argv[])
+{
+  std::size_t n = 100;
+  std::size_t m = 500;
+  std::size_t seed = 1;
+
+  if (argc > 1) n = lexical_cast<std::size_t>(argv[1]);
+  if (argc > 2) m = lexical_cast<std::size_t>(argv[2]);
+  if (argc > 3) seed = lexical_cast<std::size_t>(argv[3]);
+
+  {
+    Graph g(n);
+    minstd_rand gen(seed);
+    generate_random_graph(g, n, m, gen);
+    if (test_graph(g)) return 1;
+  }
+
+  {
+    Graph g(4);
+    add_edge(2, 3, g);
+    add_edge(0, 3, g);
+    add_edge(0, 2, g);
+    add_edge(1, 0, g);
+    if (test_graph(g)) return 1;
+  }
+
   return 0;
 }
diff --git a/test/boykov_kolmogorov_max_flow_test.cpp b/test/boykov_kolmogorov_max_flow_test.cpp
index 17607fcef..1f0ce5892 100644
--- a/test/boykov_kolmogorov_max_flow_test.cpp
+++ b/test/boykov_kolmogorov_max_flow_test.cpp
@@ -218,7 +218,8 @@ long test_overloads(int n_verts, int n_edges, std::size_t seed){
                                get(edge_capacity,g),
                                get(edge_residual_capacity,g),
                                get(edge_reverse,g),
-                               &(color_vec[0]),
+                               boost::make_iterator_property_map(
+                                 color_vec.begin(), get(vertex_index, g)),
                                get(vertex_index,g),
                                src, sink);
 
diff --git a/test/closeness_centrality.cpp b/test/closeness_centrality.cpp
index 5fd16b9cc..62b65de1a 100644
--- a/test/closeness_centrality.cpp
+++ b/test/closeness_centrality.cpp
@@ -31,8 +31,6 @@ template <typename Graph>
 void build_graph(Graph& g,
                  typename vertex_vector<Graph>::type& v)
 {
-    typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
-
     // add vertices
     for(size_t i = 0; i < N; ++i) {
         v[i] = add_vertex(g);
diff --git a/test/clustering_coefficient.cpp b/test/clustering_coefficient.cpp
index 21eee890d..a4de0417d 100644
--- a/test/clustering_coefficient.cpp
+++ b/test/clustering_coefficient.cpp
@@ -27,8 +27,6 @@ struct vertex_vector
 template <typename Graph>
 void build_graph(Graph& g, typename vertex_vector<Graph>::type& v)
 {
-    typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
-
     // add vertices
     for(size_t i = 0; i < N; ++i) {
         v[i] = add_vertex(g);
@@ -98,7 +96,7 @@ int
 main(int, char *[])
 {
     typedef undirected_graph<> Graph;
-    typedef directed_graph<> Digraph;
+    // typedef directed_graph<> Digraph;
 
     // TODO: write a test for directed clustering coefficient.
 
diff --git a/test/core_numbers_test.cpp b/test/core_numbers_test.cpp
index 733bf4a6f..3af081160 100644
--- a/test/core_numbers_test.cpp
+++ b/test/core_numbers_test.cpp
@@ -78,7 +78,6 @@ int test_2() {
     int num_arcs = sizeof(edge_array) / sizeof(Edge);
 
     graph_t G(edge_array, edge_array + num_arcs, weights, num_nodes);
-    property_map<graph_t, edge_weight_t>::type weightmap = get(edge_weight, G);
 
     std::vector<int> core_nums(num_vertices(G));
     weighted_core_numbers(G,
diff --git a/test/csr_graph_test.cpp b/test/csr_graph_test.cpp
index 757a8841f..b6a99603c 100644
--- a/test/csr_graph_test.cpp
+++ b/test/csr_graph_test.cpp
@@ -280,14 +280,13 @@ void graph_test(const OrigGraph& g)
 
   // Check edge_from_index (and implicitly the edge_index property map) for
   // each edge in g2
-  std::size_t last_src = 0, last_tgt = 0;
+  std::size_t last_src = 0;
   for (boost::tie(ei, ei_end) = edges(g2); ei != ei_end; ++ei) {
     BOOST_CHECK(edge_from_index(get(boost::edge_index, g2, *ei), g2) == *ei);
     std::size_t src = get(boost::vertex_index, g2, source(*ei, g2));
-    std::size_t tgt = get(boost::vertex_index, g2, target(*ei, g2));
+    (void)(std::size_t)get(boost::vertex_index, g2, target(*ei, g2));
     BOOST_CHECK(src >= last_src);
     last_src = src;
-    last_tgt = tgt;
   }
 
   // Check out edge iteration and vertex iteration for sortedness
diff --git a/test/cycle_canceling_test.cpp b/test/cycle_canceling_test.cpp
new file mode 100644
index 000000000..d2acc802b
--- /dev/null
+++ b/test/cycle_canceling_test.cpp
@@ -0,0 +1,63 @@
+//=======================================================================
+// Copyright 2013 University of Warsaw.
+// Authors: Piotr Wygocki 
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//=======================================================================
+
+#define BOOST_TEST_MODULE cycle_canceling_test
+
+#include <boost/test/unit_test.hpp>
+
+#include <boost/graph/cycle_canceling.hpp>
+#include <boost/graph/edmonds_karp_max_flow.hpp>
+
+#include "min_cost_max_flow_utils.hpp"
+
+
+BOOST_AUTO_TEST_CASE(cycle_canceling_def_test) {
+    boost::SampleGraph::vertex_descriptor s,t;
+    boost::SampleGraph::Graph g;
+    boost::SampleGraph::getSampleGraph(g, s, t);
+
+    boost::edmonds_karp_max_flow(g, s, t);
+    boost::cycle_canceling(g);
+
+    int cost = boost::find_flow_cost(g);
+    BOOST_CHECK_EQUAL(cost, 29);
+}
+
+BOOST_AUTO_TEST_CASE(path_augmentation_def_test2) {
+    boost::SampleGraph::vertex_descriptor s,t;
+    boost::SampleGraph::Graph g; 
+    boost::SampleGraph::getSampleGraph2(g, s, t);
+
+    boost::edmonds_karp_max_flow(g, s, t);
+    boost::cycle_canceling(g);
+
+    int cost =  boost::find_flow_cost(g);
+    BOOST_CHECK_EQUAL(cost, 7);
+}
+
+BOOST_AUTO_TEST_CASE(cycle_canceling_test) {
+    boost::SampleGraph::vertex_descriptor s,t;
+    typedef boost::SampleGraph::Graph Graph;
+    boost::SampleGraph::Graph g; 
+    boost::SampleGraph::getSampleGraph(g, s, t);
+
+    int N = num_vertices(g);
+    std::vector<int> dist(N);
+    typedef boost::graph_traits<Graph>::edge_descriptor edge_descriptor;
+    std::vector<edge_descriptor> pred(N);
+
+    boost::property_map<Graph, boost::vertex_index_t>::const_type idx = get(boost::vertex_index, g);
+
+    boost::edmonds_karp_max_flow(g, s, t);
+    boost::cycle_canceling(g, boost::distance_map(boost::make_iterator_property_map(dist.begin(), idx)).predecessor_map(boost::make_iterator_property_map(pred.begin(), idx)).vertex_index_map(idx));
+
+    int cost = boost::find_flow_cost(g);
+    BOOST_CHECK_EQUAL(cost, 29);
+}
+
diff --git a/test/cycle_ratio_tests.cpp b/test/cycle_ratio_tests.cpp
index f7ca69218..5448c87b5 100644
--- a/test/cycle_ratio_tests.cpp
+++ b/test/cycle_ratio_tests.cpp
@@ -224,7 +224,7 @@ int test_main(int argc, char* argv[])
   diGraphInt tg;
   property_map<diGraphInt, vertex_index_t>::type vim = get(vertex_index, tg);
   property_map<diGraphInt, edge_weight_t>::type ew1m = get(edge_weight, tg);
-  property_map<diGraphInt, edge_weight2_t>::type ew2m = ew2m;
+  property_map<diGraphInt, edge_weight2_t>::type ew2m = get(edge_weight2, tg);
 
 
 
@@ -331,7 +331,6 @@ int test_main(int argc, char* argv[])
   {
     GraphMInt gm(10);
     typedef graph_traits<GraphMInt>::vertex_iterator VertexItM;
-    typedef graph_traits<GraphMInt>::edge_descriptor EdgeM;
     VertexItM  vi1, vi2, vi_end;
     for (boost::tie(vi1, vi_end) = vertices(gm); vi1 != vi_end; ++vi1)
     {
diff --git a/test/cycle_test.hpp b/test/cycle_test.hpp
new file mode 100644
index 000000000..537044733
--- /dev/null
+++ b/test/cycle_test.hpp
@@ -0,0 +1,80 @@
+// (C) Copyright 2013 Louis Dionne
+//
+// Modified from `tiernan_all_cycles.cpp`.
+//
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0 (See accompanying file
+// LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_GRAPH_TEST_CYCLE_TEST_HPP
+#define BOOST_GRAPH_TEST_CYCLE_TEST_HPP
+
+#include <boost/assert.hpp>
+#include <boost/graph/directed_graph.hpp>
+#include <boost/graph/erdos_renyi_generator.hpp>
+#include <boost/graph/graph_traits.hpp>
+#include <boost/graph/graph_utility.hpp>
+#include <boost/graph/undirected_graph.hpp>
+#include <boost/next_prior.hpp>
+#include <boost/random/linear_congruential.hpp>
+#include <cstddef>
+#include <iostream>
+
+
+namespace cycle_test_detail {
+    using namespace boost;
+
+    struct cycle_validator {
+        explicit cycle_validator(std::size_t& number_of_cycles)
+            : cycles(number_of_cycles)
+        { }
+
+        template <typename Path, typename Graph>
+        void cycle(Path const& p, Graph const& g) {
+            ++cycles;
+            // Check to make sure that each of the vertices in the path
+            // is truly connected and that the back is connected to the
+            // front - it's not validating that we find all paths, just
+            // that the paths are valid.
+            typename Path::const_iterator i, j, last = prior(p.end());
+            for (i = p.begin(); i != last; ++i) {
+                j = boost::next(i);
+                BOOST_ASSERT(edge(*i, *j, g).second);
+            }
+            BOOST_ASSERT(edge(p.back(), p.front(), g).second);
+        }
+
+        std::size_t& cycles;
+    };
+
+    template <typename Graph, typename Algorithm>
+    void test_one(Algorithm algorithm) {
+        typedef erdos_renyi_iterator<minstd_rand, Graph> er;
+
+        // Generate random graphs with 15 vertices and 15% probability
+        // of edge connection.
+        static std::size_t const N = 20;
+        static double const P = 0.1;
+        minstd_rand rng;
+
+        Graph g(er(rng, N, P), er(), N);
+        renumber_indices(g);
+        print_edges(g, get(vertex_index, g));
+
+        std::size_t cycles = 0;
+        cycle_validator vis(cycles);
+        algorithm(g, vis);
+        std::cout << "# cycles: " << vis.cycles << "\n";
+    }
+} // end namespace cycle_test_detail
+
+template <typename Algorithm>
+void cycle_test(Algorithm const& algorithm) {
+    std::cout << "*** undirected ***\n";
+    cycle_test_detail::test_one<boost::undirected_graph<> >(algorithm);
+
+    std::cout << "*** directed ***\n";
+    cycle_test_detail::test_one<boost::directed_graph<> >(algorithm);
+}
+
+#endif // !BOOST_GRAPH_TEST_CYCLE_TEST_HPP
diff --git a/test/dag_longest_paths.cpp b/test/dag_longest_paths.cpp
index a3793082d..4b5151b32 100644
--- a/test/dag_longest_paths.cpp
+++ b/test/dag_longest_paths.cpp
@@ -20,12 +20,11 @@ int test_main(int, char*[])
         property<edge_weight_t, int> > Graph;
 
     Graph graph;
-    Graph::vertex_descriptor v1, v2, v3, v4;
 
-    v1 = add_vertex(graph);
-    v2 = add_vertex(graph);
-    v3 = add_vertex(graph);
-    v4 = add_vertex(graph);
+    (void)add_vertex(graph);
+    (void)add_vertex(graph);
+    (void)add_vertex(graph);
+    (void)add_vertex(graph);
 
     Graph::edge_descriptor e;
     
diff --git a/test/degree_centrality.cpp b/test/degree_centrality.cpp
index bb6e6b39c..42adb5b11 100644
--- a/test/degree_centrality.cpp
+++ b/test/degree_centrality.cpp
@@ -22,8 +22,6 @@ template <typename Graph>
 void build_graph(Graph& g,
                  vector<typename graph_traits<Graph>::vertex_descriptor>& v)
 {
-    typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
-
     // add vertices
     for(size_t i = 0; i < N; ++i) {
         v[i] = add_vertex(g);
diff --git a/test/dfs.cpp b/test/dfs.cpp
index fdffd4ef1..d958ba441 100644
--- a/test/dfs.cpp
+++ b/test/dfs.cpp
@@ -68,6 +68,12 @@ class dfs_test_visitor {
     using namespace boost;
     BOOST_CHECK( get(m_color, target(e, g)) == Color::black() );
   }
+  template <class Edge, class Graph>
+  void finish_edge(Edge e, Graph& g) {
+    using namespace boost;
+    BOOST_CHECK( get(m_color, target(e, g)) == Color::gray() ||
+                 get(m_color, target(e, g)) == Color::black() );
+  }
   template <class Vertex, class Graph>
   void finish_vertex(Vertex u, Graph&) {
     using namespace boost;
@@ -116,9 +122,24 @@ struct dfs_test
         std::vector<int> discover_time(num_vertices(g)),
           finish_time(num_vertices(g));
 
-        dfs_test_visitor<ColorMap, vertex_descriptor*,
-          int*, int*> vis(color, &parent[0],
-                          &discover_time[0], &finish_time[0]);
+        // Get vertex index map
+        typedef typename boost::property_map<Graph, boost::vertex_index_t>::const_type idx_type;
+        idx_type idx = get(boost::vertex_index, g);
+        
+        typedef
+          boost::iterator_property_map<typename std::vector<vertex_descriptor>::iterator, idx_type>
+          parent_pm_type;
+        parent_pm_type parent_pm(parent.begin(), idx);
+        typedef
+          boost::iterator_property_map<std::vector<int>::iterator, idx_type>
+          time_pm_type;
+        time_pm_type discover_time_pm(discover_time.begin(), idx);
+        time_pm_type finish_time_pm(finish_time.begin(), idx);
+
+        dfs_test_visitor<ColorMap, parent_pm_type,
+          time_pm_type, time_pm_type>
+          vis(color, parent_pm,
+              discover_time_pm, finish_time_pm);
 
         boost::depth_first_search(g, visitor(vis).color_map(color));
 
@@ -136,10 +157,10 @@ struct dfs_test
                           || finish_time[v] < discover_time[u]
                           || (discover_time[v] < discover_time[u]
                                && finish_time[u] < finish_time[v]
-                               && boost::is_descendant(u, v, &parent[0]))
+                               && boost::is_descendant(u, v, parent_pm))
                           || (discover_time[u] < discover_time[v]
                                && finish_time[v] < finish_time[u]
-                               && boost::is_descendant(v, u, &parent[0]))
+                               && boost::is_descendant(v, u, parent_pm))
                         );
             }
           }
diff --git a/test/dijkstra_heap_performance.cpp b/test/dijkstra_heap_performance.cpp
index 72d40f9cc..2cab3fbf2 100644
--- a/test/dijkstra_heap_performance.cpp
+++ b/test/dijkstra_heap_performance.cpp
@@ -117,7 +117,9 @@ int main(int argc, char* argv[])
   dijkstra_relaxed_heap = false;
 #endif
   dijkstra_shortest_paths(g, vertex(0, g),
-                          distance_map(&binary_heap_distances[0]));
+                          distance_map(
+                            boost::make_iterator_property_map(
+                              binary_heap_distances.begin(), get(boost::vertex_index, g))));
   double binary_heap_time = t.elapsed();
   std::cout << binary_heap_time << " seconds.\n";
 
@@ -135,7 +137,9 @@ int main(int argc, char* argv[])
   dijkstra_relaxed_heap = true;
 #endif
   dijkstra_shortest_paths(g, vertex(0, g),
-                          distance_map(&relaxed_heap_distances[0]));
+                          distance_map(
+                            boost::make_iterator_property_map(
+                              relaxed_heap_distances.begin(), get(boost::vertex_index, g))));
   double relaxed_heap_time = t.elapsed();
   std::cout << relaxed_heap_time << " seconds.\n"
             << "Speedup = " << (binary_heap_time / relaxed_heap_time) << ".\n";
@@ -159,7 +163,7 @@ int main(int argc, char* argv[])
   dijkstra_shortest_paths_no_color_map
     (g, vertex(0, g),
      boost::dummy_property_map(),
-     boost::make_iterator_property_map(&no_color_map_distances[0],
+     boost::make_iterator_property_map(no_color_map_distances.begin(),
                                        get(boost::vertex_index, g),
                                        0.),
      get(boost::edge_weight, g),
diff --git a/test/dijkstra_no_color_map_compare.cpp b/test/dijkstra_no_color_map_compare.cpp
index a8c140d19..739b899e7 100644
--- a/test/dijkstra_no_color_map_compare.cpp
+++ b/test/dijkstra_no_color_map_compare.cpp
@@ -94,9 +94,6 @@ int test_main(int argc, char* argv[])
     property<vertex_index_t, int >,
     property<edge_weight_t, double> > graph_t;
 
-  typedef graph_traits<graph_t>::vertex_descriptor vertex_t;
-  typedef graph_traits<graph_t>::edge_descriptor edge_t;
-
   graph_t graph;  
   generate_random_graph(graph, vertices_to_create, edges_to_create, generator);
 
@@ -109,8 +106,6 @@ int test_main(int argc, char* argv[])
     put(index_map, current_vertex, vertex_index++);
   }
 
-  typedef property_map<graph_t, edge_weight_t>::type weight_map_t;
-  weight_map_t weight_map = get(edge_weight, graph);
   randomize_property<edge_weight_t>(graph, generator);
 
   // Run comparison test with original dijkstra_shortest_paths
diff --git a/test/eccentricity.cpp b/test/eccentricity.cpp
index 596f38ef5..2c04c7d63 100644
--- a/test/eccentricity.cpp
+++ b/test/eccentricity.cpp
@@ -31,8 +31,6 @@ template <typename Graph>
 void build_graph(Graph& g,
                  typename vertex_vector<Graph>::type& v)
 {
-    typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
-
     // add vertices
     for(size_t i = 0; i < N; ++i) {
         v[i] = add_vertex(g);
diff --git a/test/edge_list_cc.cpp b/test/edge_list_cc.cpp
index 0741cceac..18d34e050 100644
--- a/test/edge_list_cc.cpp
+++ b/test/edge_list_cc.cpp
@@ -9,6 +9,7 @@
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/graph_archetypes.hpp>
 #include <boost/graph/edge_list.hpp>
+#include <boost/concept/assert.hpp>
 #include <cstddef>
 #include <iterator>
 
@@ -24,10 +25,10 @@ int main(int,char*[])
     
         typedef graph_traits<EdgeList>::edge_descriptor Edge;
     
-        function_requires< EdgeListGraphConcept<EdgeList> >();
+        BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<EdgeList> ));
     
-        function_requires< ReadablePropertyGraphConcept<EdgeList, Edge, 
-            edge_index_t> >();
+        BOOST_CONCEPT_ASSERT(( ReadablePropertyGraphConcept<EdgeList, Edge, 
+            edge_index_t> ));
     }
     return 0;
 }
diff --git a/test/filtered_graph_cc.cpp b/test/filtered_graph_cc.cpp
index 09feb4b00..52221b1ef 100644
--- a/test/filtered_graph_cc.cpp
+++ b/test/filtered_graph_cc.cpp
@@ -10,6 +10,7 @@
 #include <boost/graph/graph_archetypes.hpp>
 #include <boost/graph/adjacency_list.hpp>
 #include <boost/graph/filtered_graph.hpp>
+#include <boost/concept/assert.hpp>
 
 int main(int,char*[])
 {
@@ -22,12 +23,12 @@ int main(int,char*[])
     typedef filtered_graph<Graph, is_residual_edge<ResCapMap> > ResGraph;
     typedef graph_traits<ResGraph>::edge_descriptor Edge;
 
-    function_requires< VertexListGraphConcept<ResGraph> >();
-    function_requires< EdgeListGraphConcept<ResGraph> >();
-    function_requires< IncidenceGraphConcept<ResGraph> >();
-    function_requires< AdjacencyGraphConcept<ResGraph> >();
-    function_requires< PropertyGraphConcept<ResGraph, Edge, 
-      edge_residual_capacity_t> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<ResGraph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeListGraphConcept<ResGraph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<ResGraph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<ResGraph> ));
+    BOOST_CONCEPT_ASSERT(( PropertyGraphConcept<ResGraph, Edge, 
+      edge_residual_capacity_t> ));
   }
   // Check filtered_graph with bidirectional adjacency_list
   {
@@ -35,7 +36,7 @@ int main(int,char*[])
       no_property, property<edge_residual_capacity_t, long> > Graph;
     typedef property_map<Graph, edge_residual_capacity_t>::type ResCapMap;
     typedef filtered_graph<Graph, is_residual_edge<ResCapMap> > ResGraph;
-    function_requires< BidirectionalGraphConcept<ResGraph> >();
+    BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<ResGraph> ));
   }
   return 0;
 }
diff --git a/test/filtered_graph_properties_dijkstra.cpp b/test/filtered_graph_properties_dijkstra.cpp
new file mode 100644
index 000000000..54b8c4cbd
--- /dev/null
+++ b/test/filtered_graph_properties_dijkstra.cpp
@@ -0,0 +1,111 @@
+// (c) Copyright Juergen Hunold 2012
+// Use, modification and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/graph/adjacency_list.hpp>
+#include <boost/graph/dijkstra_shortest_paths.hpp>
+#include <boost/graph/filtered_graph.hpp>
+
+namespace boost {
+
+    enum edge_info_t { edge_info = 114 };
+
+    BOOST_INSTALL_PROPERTY( edge, info );
+}
+
+template< typename EdgeInfo,
+          typename Directed >
+class Graph
+{
+public:
+    typedef boost::property< boost::edge_info_t, EdgeInfo > tEdge_property;
+
+    typedef boost::adjacency_list< boost::setS,
+                                   boost::vecS,
+                                   Directed,
+                                   boost::no_property,
+                                   tEdge_property > tGraph;
+
+    typedef typename boost::graph_traits< tGraph >::vertex_descriptor tNode;
+    typedef typename boost::graph_traits< tGraph >::edge_descriptor   tEdge;
+
+protected:
+
+    tGraph          m_Graph;
+};
+
+class DataEdge;
+
+class UndirectedGraph
+    : public Graph< DataEdge*,
+                    boost::undirectedS >
+{
+public:
+
+    template< class Evaluator, class Filter >
+    void        dijkstra( Evaluator const&,
+                          Filter const& ) const;
+};
+
+template< typename Graph, typename Derived >
+struct Evaluator : public boost::put_get_helper< int, Derived >
+{
+    typedef int value_type;
+    typedef typename Graph::tEdge key_type;
+    typedef int reference;
+    typedef boost::readable_property_map_tag category;
+
+    explicit Evaluator( Graph const* pGraph );
+};
+
+
+template< typename Graph >
+struct LengthEvaluator : public Evaluator< Graph, LengthEvaluator<Graph> >
+{
+    explicit LengthEvaluator( Graph const* pGraph );
+
+    typedef typename Evaluator<Graph, LengthEvaluator<Graph> >::reference reference;
+    typedef typename Evaluator<Graph, LengthEvaluator<Graph> >::key_type key_type;
+
+    virtual reference operator[] ( key_type const& edge ) const;
+};
+
+template< class Graph >
+struct EdgeFilter
+{
+    typedef typename Graph::tEdge key_type;
+
+    EdgeFilter();
+
+    explicit EdgeFilter( Graph const*);
+
+    bool    operator()( key_type const& ) const;
+
+private:
+    const Graph*    m_pGraph;
+};
+
+
+template< class Evaluator, class Filter >
+void
+UndirectedGraph::dijkstra( Evaluator const& rEvaluator,
+                           Filter const& rFilter ) const
+{
+    tNode nodeSource = vertex(0, m_Graph);
+
+    std::vector< tNode > predecessors( num_vertices(m_Graph) );
+
+    boost::filtered_graph< tGraph, Filter > filteredGraph( m_Graph, rFilter );
+
+    boost::dijkstra_shortest_paths( filteredGraph,
+                                    nodeSource,
+                                    boost::predecessor_map( &predecessors[0] )
+                                    .weight_map( rEvaluator ) );
+}
+
+// explicit instantiation
+template void UndirectedGraph::dijkstra( LengthEvaluator<UndirectedGraph> const&,
+                                         EdgeFilter<UndirectedGraph> const& ) const;
+
+int main(int, char**) {return 0;} // Tests above will fail to compile if anything is broken
diff --git a/test/graph_concepts.cpp b/test/graph_concepts.cpp
index cfab6b4dd..c2edc342e 100644
--- a/test/graph_concepts.cpp
+++ b/test/graph_concepts.cpp
@@ -8,6 +8,7 @@
 //=======================================================================
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/graph_archetypes.hpp>
+#include <boost/concept/assert.hpp>
 
 int main(int,char*[])
 {
@@ -19,22 +20,22 @@ int main(int,char*[])
 
   typedef incidence_graph_archetype<Vertex, directed_tag, 
     allow_parallel_edge_tag> Graph1;
-  function_requires< IncidenceGraphConcept<Graph1> >();
+  BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph1> ));
 
   typedef adjacency_graph_archetype<Vertex, directed_tag, 
     allow_parallel_edge_tag> Graph2;
-  function_requires< AdjacencyGraphConcept<Graph2> >();
+  BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph2> ));
 
   typedef vertex_list_graph_archetype<Vertex, directed_tag, 
     allow_parallel_edge_tag> Graph3;
-  function_requires< VertexListGraphConcept<Graph3> >();
+  BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph3> ));
 
-  function_requires< ColorValueConcept<color_value_archetype> >();
+  BOOST_CONCEPT_ASSERT(( ColorValueConcept<color_value_archetype> ));
 
   typedef incidence_graph_archetype<Vertex, directed_tag, allow_parallel_edge_tag> G;
   typedef property_graph_archetype<G, vertex_color_t, color_value_archetype>
     Graph4;
-  function_requires< PropertyGraphConcept<Graph4, Vertex, vertex_color_t> >();
+  BOOST_CONCEPT_ASSERT(( PropertyGraphConcept<Graph4, Vertex, vertex_color_t> ));
 
   return 0;
 }
diff --git a/test/graphviz_test.cpp b/test/graphviz_test.cpp
index 5ff2f80b6..94f200a01 100644
--- a/test/graphviz_test.cpp
+++ b/test/graphviz_test.cpp
@@ -17,6 +17,7 @@
 #include <boost/graph/graphviz.hpp>
 #include <boost/assign/std/map.hpp>
 #include <boost/graph/adjacency_list.hpp>
+#include <boost/graph/compressed_sparse_row_graph.hpp>
 #include <boost/graph/graph_traits.hpp>
 #include <boost/tuple/tuple.hpp>
 #include <boost/property_map/dynamic_property_map.hpp>
@@ -41,33 +42,43 @@ typedef std::pair<node_t,node_t> edge_t;
 typedef std::map<node_t,float> mass_map_t;
 typedef std::map<edge_t,double> weight_map_t;
 
-template <typename Directedness, typename OutEdgeList>
+template <typename graph_t, typename NameMap, typename MassMap, typename WeightMap>
+bool test_graph(std::istream& dotfile, graph_t& graph,
+                std::size_t correct_num_vertices,
+                mass_map_t const& masses,
+                weight_map_t const& weights,
+                std::string const& node_id,
+                std::string const& g_name,
+                NameMap name,
+                MassMap mass,
+                WeightMap weight);
+
+template <typename graph_t>
 bool test_graph(std::istream& dotfile, std::size_t correct_num_vertices,
                 mass_map_t const& masses,
                 weight_map_t const& weights,
                 std::string const& node_id = "node_id",
                 std::string const& g_name = std::string()) {
-
-  typedef property < vertex_name_t, std::string,
-            property < vertex_color_t, float > > vertex_p;  
-  typedef property < edge_weight_t, double > edge_p;
-  typedef property < graph_name_t, std::string > graph_p;
-  typedef adjacency_list < OutEdgeList, vecS, Directedness,
-    vertex_p, edge_p, graph_p > graph_t;
-  typedef typename graph_traits < graph_t >::edge_descriptor edge_t;
-  typedef typename graph_traits < graph_t >::vertex_descriptor vertex_t;
+  graph_t g;
+  return test_graph(dotfile, g, correct_num_vertices, masses, weights, node_id, g_name,
+                    get(vertex_name, g), get(vertex_color, g), get(edge_weight, g));
+}
+
+template <typename graph_t, typename NameMap, typename MassMap, typename WeightMap>
+bool test_graph(std::istream& dotfile, graph_t& graph,
+                std::size_t correct_num_vertices,
+                mass_map_t const& masses,
+                weight_map_t const& weights,
+                std::string const& node_id,
+                std::string const& g_name,
+                NameMap name,
+                MassMap mass,
+                WeightMap weight) {
 
   // Construct a graph and set up the dynamic_property_maps.
-  graph_t graph(0);
   dynamic_properties dp(ignore_other_properties);
-  typename property_map<graph_t, vertex_name_t>::type name =
-    get(vertex_name, graph);
   dp.property(node_id,name);
-  typename property_map<graph_t, vertex_color_t>::type mass =
-    get(vertex_color, graph);
   dp.property("mass",mass);
-  typename property_map<graph_t, edge_weight_t>::type weight =
-    get(edge_weight, graph);
   dp.property("weight",weight);
 
   boost::ref_property_map<graph_t*,std::string> gname(
@@ -97,6 +108,7 @@ bool test_graph(std::istream& dotfile, std::size_t correct_num_vertices,
         std::string node_name = get(name,*i);
         //  - get its mass
         float node_mass = get(mass,*i);
+        BOOST_CHECK(masses.find(node_name) != masses.end());
         float ref_mass = masses.find(node_name)->second;
         //  - compare the mass to the result in the table
         BOOST_CHECK_CLOSE(node_mass, ref_mass, 0.01f);
@@ -114,6 +126,7 @@ bool test_graph(std::istream& dotfile, std::size_t correct_num_vertices,
                                 get(name, target(*i,graph)));
         // - get its weight
         double edge_weight = get(weight,*i);
+        BOOST_CHECK(weights.find(edge_name) != weights.end());
         double ref_weight = weights.find(edge_name)->second;
         // - compare the weight to teh result in the table
         BOOST_CHECK_CLOSE(edge_weight, ref_weight, 0.01);
@@ -137,19 +150,31 @@ bool test_graph(std::istream& dotfile, std::size_t correct_num_vertices,
 
   typedef istringstream gs_t;
 
+  typedef property < vertex_name_t, std::string,
+            property < vertex_color_t, float > > vertex_p;  
+  typedef property < edge_weight_t, double > edge_p;
+  typedef property < graph_name_t, std::string > graph_p;
+
+  struct vertex_p_bundled {std::string name; float color;};
+  struct edge_p_bundled {double weight;};
+
   // Basic directed graph tests
   BOOST_AUTO_TEST_CASE (basic_directed_graph_1) {
     mass_map_t masses;
     insert ( masses )  ("a",0.0f) ("c",7.7f) ("e", 6.66f);
     gs_t gs("digraph { a  node [mass = 7.7] c e [mass = 6.66] }");
-    BOOST_CHECK((test_graph<directedS,vecS>(gs,3,masses,weight_map_t())));
+    typedef adjacency_list < vecS, vecS, directedS,
+      vertex_p, edge_p, graph_p > graph_t;
+    BOOST_CHECK((test_graph<graph_t>(gs,3,masses,weight_map_t())));
   }
 
   BOOST_AUTO_TEST_CASE (basic_directed_graph_2) {
     mass_map_t masses;
     insert ( masses )  ("a",0.0f) ("e", 6.66f);
     gs_t gs("digraph { a  node [mass = 7.7] \"a\" e [mass = 6.66] }");
-    BOOST_CHECK((test_graph<directedS,vecS>(gs,2,masses,weight_map_t())));
+    typedef adjacency_list < vecS, vecS, directedS,
+      vertex_p, edge_p, graph_p > graph_t;
+    BOOST_CHECK((test_graph<graph_t>(gs,2,masses,weight_map_t())));
   }
 
   BOOST_AUTO_TEST_CASE (basic_directed_graph_3) {
@@ -160,7 +185,9 @@ bool test_graph(std::istream& dotfile, std::size_t correct_num_vertices,
     gs_t gs("digraph { a -> b eDge [weight = 7.7] "
             "c -> d e-> f [weight = 6.66] "
             "d ->e->a [weight=.5]}");
-    BOOST_CHECK((test_graph<directedS,vecS>(gs,6,mass_map_t(),weights)));
+    typedef adjacency_list < vecS, vecS, directedS,
+      vertex_p, edge_p, graph_p > graph_t;
+    BOOST_CHECK((test_graph<graph_t>(gs,6,mass_map_t(),weights)));
   }
 
   // undirected graph with alternate node_id property name
@@ -168,8 +195,10 @@ bool test_graph(std::istream& dotfile, std::size_t correct_num_vertices,
     mass_map_t masses;
     insert ( masses )  ("a",0.0f) ("c",7.7f) ("e", 6.66f);
     gs_t gs("graph { a  node [mass = 7.7] c e [mass = 6.66] }");
-    BOOST_CHECK((test_graph<undirectedS,vecS>(gs,3,masses,weight_map_t(),
-                                             "nodenames")));
+    typedef adjacency_list < vecS, vecS, undirectedS,
+      vertex_p, edge_p, graph_p > graph_t;
+    BOOST_CHECK((test_graph<graph_t>(gs,3,masses,weight_map_t(),
+                                     "nodenames")));
   }
 
   // Basic undirected graph tests
@@ -177,7 +206,9 @@ bool test_graph(std::istream& dotfile, std::size_t correct_num_vertices,
     mass_map_t masses;
     insert ( masses )  ("a",0.0f) ("c",7.7f) ("e", 6.66f);
     gs_t gs("graph { a  node [mass = 7.7] c e [mass =\\\n6.66] }");
-    BOOST_CHECK((test_graph<undirectedS,vecS>(gs,3,masses,weight_map_t())));
+    typedef adjacency_list < vecS, vecS, undirectedS,
+      vertex_p, edge_p, graph_p > graph_t;
+    BOOST_CHECK((test_graph<graph_t>(gs,3,masses,weight_map_t())));
   }
 
   BOOST_AUTO_TEST_CASE (basic_undirected_graph_2) {
@@ -186,7 +217,9 @@ bool test_graph(std::istream& dotfile, std::size_t correct_num_vertices,
       (make_pair("c","d"),7.7)(make_pair("e","f"),6.66);
     gs_t gs("graph { a -- b eDge [weight = 7.7] "
             "c -- d e -- f [weight = 6.66] }");
-    BOOST_CHECK((test_graph<undirectedS,vecS>(gs,6,mass_map_t(),weights)));
+    typedef adjacency_list < vecS, vecS, undirectedS,
+      vertex_p, edge_p, graph_p > graph_t;
+    BOOST_CHECK((test_graph<graph_t>(gs,6,mass_map_t(),weights)));
   }
 
   // Mismatch directed graph test
@@ -195,7 +228,9 @@ bool test_graph(std::istream& dotfile, std::size_t correct_num_vertices,
     insert ( masses )  ("a",0.0f) ("c",7.7f) ("e", 6.66f);
     gs_t gs("graph { a  nodE [mass = 7.7] c e [mass = 6.66] }");
     try {
-      test_graph<directedS,vecS>(gs,3,masses,weight_map_t());
+      typedef adjacency_list < vecS, vecS, directedS,
+        vertex_p, edge_p, graph_p > graph_t;
+      test_graph<graph_t>(gs,3,masses,weight_map_t());
       BOOST_ERROR("Failed to throw boost::undirected_graph_error.");
     } catch (boost::undirected_graph_error&) {
     } catch (boost::directed_graph_error&) {
@@ -209,7 +244,9 @@ bool test_graph(std::istream& dotfile, std::size_t correct_num_vertices,
     insert ( masses )  ("a",0.0f) ("c",7.7f) ("e", 6.66f);
     gs_t gs("digraph { a  node [mass = 7.7] c e [mass = 6.66] }");
     try {
-      test_graph<undirectedS,vecS>(gs,3,masses,weight_map_t());
+      typedef adjacency_list < vecS, vecS, undirectedS,
+        vertex_p, edge_p, graph_p > graph_t;
+      test_graph<graph_t>(gs,3,masses,weight_map_t());
       BOOST_ERROR("Failed to throw boost::directed_graph_error.");
     } catch (boost::directed_graph_error&) {}
   }
@@ -221,7 +258,9 @@ bool test_graph(std::istream& dotfile, std::size_t correct_num_vertices,
     insert( weights )(make_pair("a","b"),7.7);
     gs_t gs("diGraph { a -> b [weight = 7.7]  a -> b [weight = 7.7] }");
     try {
-      test_graph<directedS,setS>(gs,2,mass_map_t(),weights);
+      typedef adjacency_list < setS, vecS, directedS,
+        vertex_p, edge_p, graph_p > graph_t;
+      test_graph<graph_t>(gs,2,mass_map_t(),weights);
       BOOST_ERROR("Failed to throw boost::bad_parallel_edge.");
     } catch (boost::bad_parallel_edge&) {}
   }
@@ -231,7 +270,9 @@ bool test_graph(std::istream& dotfile, std::size_t correct_num_vertices,
     weight_map_t weights;
     insert( weights )(make_pair("a","b"),7.7);
     gs_t gs("digraph { a -> b [weight = 7.7]  a -> b [weight = 7.7] }");
-    BOOST_CHECK((test_graph<directedS,vecS>(gs,2,mass_map_t(),weights)));
+    typedef adjacency_list < vecS, vecS, directedS,
+      vertex_p, edge_p, graph_p > graph_t;
+    BOOST_CHECK((test_graph<graph_t>(gs,2,mass_map_t(),weights)));
   }
 
   // Graph Property Test 1
@@ -240,8 +281,10 @@ bool test_graph(std::istream& dotfile, std::size_t correct_num_vertices,
     insert ( masses )  ("a",0.0f) ("c",0.0f) ("e", 6.66f);
     gs_t gs("digraph { graph [name=\"foo \\\"escaped\\\"\"]  a  c e [mass = 6.66] }");
     std::string graph_name("foo \"escaped\"");
-    BOOST_CHECK((test_graph<directedS,vecS>(gs,3,masses,weight_map_t(),"",
-                                            graph_name)));
+    typedef adjacency_list < vecS, vecS, directedS,
+      vertex_p, edge_p, graph_p > graph_t;
+    BOOST_CHECK((test_graph<graph_t>(gs,3,masses,weight_map_t(),"",
+                                     graph_name)));
   }
 
   // Graph Property Test 2
@@ -250,8 +293,10 @@ bool test_graph(std::istream& dotfile, std::size_t correct_num_vertices,
     insert ( masses )  ("a",0.0f) ("c",0.0f) ("e", 6.66f);
     gs_t gs("digraph { name=\"fo\"+ \"\\\no\"  a  c e [mass = 6.66] }");
     std::string graph_name("foo");
-    BOOST_CHECK((test_graph<directedS,vecS>(gs,3,masses,weight_map_t(),"",
-                                            graph_name)));
+    typedef adjacency_list < vecS, vecS, directedS,
+      vertex_p, edge_p, graph_p > graph_t;
+    BOOST_CHECK((test_graph<graph_t>(gs,3,masses,weight_map_t(),"",
+                                     graph_name)));
   }
 
   // Graph Property Test 3 (HTML)
@@ -260,8 +305,10 @@ bool test_graph(std::istream& dotfile, std::size_t correct_num_vertices,
     insert ( masses )  ("a",0.0f) ("c",0.0f) ("e", 6.66f);
     std::string graph_name = "<html title=\"x'\" title2='y\"'>foo<b><![CDATA[><bad tag&>]]>bar</b>\n<br/>\nbaz</html>";
     gs_t gs("digraph { name=" + graph_name + "  a  c e [mass = 6.66] }");
-    BOOST_CHECK((test_graph<directedS,vecS>(gs,3,masses,weight_map_t(),"",
-                                            graph_name)));
+    typedef adjacency_list < vecS, vecS, directedS,
+      vertex_p, edge_p, graph_p > graph_t;
+    BOOST_CHECK((test_graph<graph_t>(gs,3,masses,weight_map_t(),"",
+                                     graph_name)));
   }
 
   // Comments embedded in strings
@@ -272,7 +319,40 @@ bool test_graph(std::istream& dotfile, std::size_t correct_num_vertices,
       "a1 [ label = \"//depot/path/to/file_29#9\" ];"
       "a0 -> a1 [ color=gray ];"
       "}");
-    BOOST_CHECK((test_graph<directedS,vecS>(gs,2,mass_map_t(),weight_map_t())));
+    typedef adjacency_list < vecS, vecS, directedS,
+      vertex_p, edge_p, graph_p > graph_t;
+    BOOST_CHECK((test_graph<graph_t>(gs,2,mass_map_t(),weight_map_t())));
+  }
+
+#if 0 // Currently broken
+  BOOST_AUTO_TEST_CASE (basic_csr_directed_graph) {
+    weight_map_t weights;
+    insert( weights )(make_pair("a","b"),0.0)
+      (make_pair("c","d"),7.7)(make_pair("e","f"),6.66)
+      (make_pair("d","e"),0.5)(make_pair("e","a"),0.5);
+    gs_t gs("digraph { a -> b eDge [weight = 7.7] "
+            "c -> d e-> f [weight = 6.66] "
+            "d ->e->a [weight=.5]}");
+    typedef compressed_sparse_row_graph<directedS, vertex_p_bundled, edge_p_bundled, graph_p > graph_t;
+    BOOST_CHECK((test_graph<graph_t>(gs,6,mass_map_t(),weights,"node_id","",&vertex_p_bundled::name,&vertex_p_bundled::color,&edge_p_bundled::weight)));
+  }
+#endif
+
+  BOOST_AUTO_TEST_CASE (basic_csr_directed_graph_ext_props) {
+    weight_map_t weights;
+    insert( weights )(make_pair("a","b"),0.0)
+      (make_pair("c","d"),7.7)(make_pair("e","f"),6.66)
+      (make_pair("d","e"),0.5)(make_pair("e","a"),0.5);
+    gs_t gs("digraph { a -> b eDge [weight = 7.7] "
+            "c -> d e-> f [weight = 6.66] "
+            "d ->e->a [weight=.5]}");
+    typedef compressed_sparse_row_graph<directedS, no_property, no_property, graph_p > graph_t;
+    graph_t g;
+    vector_property_map<std::string, property_map<graph_t, vertex_index_t>::const_type> vertex_name(get(vertex_index, g));
+    vector_property_map<float, property_map<graph_t, vertex_index_t>::const_type> vertex_color(get(vertex_index, g));
+    vector_property_map<double, property_map<graph_t, edge_index_t>::const_type> edge_weight(get(edge_index, g));
+    BOOST_CHECK((test_graph(gs,g,6,mass_map_t(),weights,"node_id","",vertex_name,vertex_color,edge_weight)));
   }
+
 // return 0;
 // }
diff --git a/test/grid_graph_cc.cpp b/test/grid_graph_cc.cpp
index 6c7d76a33..d49de7c35 100644
--- a/test/grid_graph_cc.cpp
+++ b/test/grid_graph_cc.cpp
@@ -10,24 +10,32 @@
 #include <boost/graph/graph_archetypes.hpp>
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/grid_graph.hpp>
+#include <boost/concept/assert.hpp>
 
-#define DIMENSIONS 3
 using namespace boost;
 
-int main (int, char*[]) {
+template <unsigned int Dims>
+void check() {
+  typedef grid_graph<Dims> Graph;
+  typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
+  typedef typename graph_traits<Graph>::edge_descriptor Edge;
 
-  typedef grid_graph<DIMENSIONS> Graph;
-  typedef graph_traits<Graph>::vertex_descriptor Vertex;
-  typedef graph_traits<Graph>::edge_descriptor Edge;
+  BOOST_CONCEPT_ASSERT((BidirectionalGraphConcept<Graph> ));
+  BOOST_CONCEPT_ASSERT((VertexListGraphConcept<Graph> ));
+  BOOST_CONCEPT_ASSERT((EdgeListGraphConcept<Graph> ));
+  BOOST_CONCEPT_ASSERT((IncidenceGraphConcept<Graph> ));
+  BOOST_CONCEPT_ASSERT((AdjacencyGraphConcept<Graph> ));
+  BOOST_CONCEPT_ASSERT((AdjacencyMatrixConcept<Graph> ));
+  BOOST_CONCEPT_ASSERT((ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> ));
+  BOOST_CONCEPT_ASSERT((ReadablePropertyGraphConcept<Graph, Edge, edge_index_t> ));
+}
 
-  function_requires<BidirectionalGraphConcept<Graph> >();
-  function_requires<VertexListGraphConcept<Graph> >();
-  function_requires<EdgeListGraphConcept<Graph> >();
-  function_requires<IncidenceGraphConcept<Graph> >();
-  function_requires<AdjacencyGraphConcept<Graph> >();
-  function_requires<AdjacencyMatrixConcept<Graph> >();
-  function_requires<ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> >();
-  function_requires<ReadablePropertyGraphConcept<Graph, Edge, edge_index_t> >();
+int main (int, char*[]) {
+  check<0>();
+  check<1>();
+  check<2>();
+  check<3>();
+  check<4>();
 
   return (0);
 }
diff --git a/test/grid_graph_test.cpp b/test/grid_graph_test.cpp
index 3cd665bdf..d88e68d2e 100644
--- a/test/grid_graph_test.cpp
+++ b/test/grid_graph_test.cpp
@@ -17,8 +17,6 @@
 #include <boost/random.hpp>
 #include <boost/test/minimal.hpp>
 
-#define DIMENSIONS 3
-
 using namespace boost;
 
 // Function that prints a vertex to std::cout
@@ -28,11 +26,11 @@ void print_vertex(Vertex vertex_to_print) {
   std::cout << "(";
 
   for (std::size_t dimension_index = 0;
-       dimension_index < DIMENSIONS;
+       dimension_index < vertex_to_print.size();
        ++dimension_index) {
     std::cout << vertex_to_print[dimension_index];
 
-    if (dimension_index != (DIMENSIONS - 1)) {
+    if (dimension_index != (vertex_to_print.size() - 1)) {
       std::cout << ", ";
     }
   }
@@ -40,31 +38,23 @@ void print_vertex(Vertex vertex_to_print) {
   std::cout << ")";
 }
 
-int test_main(int argc, char* argv[]) {
-
-  std::size_t random_seed = time(0);
-
-  if (argc > 1) {
-    random_seed = lexical_cast<std::size_t>(argv[1]);
-  }
-
-  minstd_rand generator(random_seed);
-
-  typedef grid_graph<DIMENSIONS> Graph;
-  typedef graph_traits<Graph>::vertices_size_type vertices_size_type;
-  typedef graph_traits<Graph>::edges_size_type edges_size_type;
+template <unsigned int Dims>
+void do_test(minstd_rand& generator) {
+  typedef grid_graph<Dims> Graph;
+  typedef typename graph_traits<Graph>::vertices_size_type vertices_size_type;
+  typedef typename graph_traits<Graph>::edges_size_type edges_size_type;
 
-  typedef graph_traits<Graph>::vertex_descriptor vertex_descriptor;
-  typedef graph_traits<Graph>::edge_descriptor edge_descriptor;
+  typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor;
+  typedef typename graph_traits<Graph>::edge_descriptor edge_descriptor;
 
-  std::cout << "Dimensions: " << DIMENSIONS << ", lengths: ";
+  std::cout << "Dimensions: " << Dims << ", lengths: ";
 
   // Randomly generate the dimension lengths (3-10) and wrapping
-  array<Graph::vertices_size_type, DIMENSIONS> lengths;
-  array<bool, DIMENSIONS> wrapped;
+  boost::array<vertices_size_type, Dims> lengths;
+  boost::array<bool, Dims> wrapped;
 
-  for (int dimension_index = 0;
-       dimension_index < DIMENSIONS;
+  for (unsigned int dimension_index = 0;
+       dimension_index < Dims;
        ++dimension_index) {
     lengths[dimension_index] = 3 + (generator() % 8);
     wrapped[dimension_index] = ((generator() % 2) == 0);
@@ -78,8 +68,8 @@ int test_main(int argc, char* argv[]) {
   Graph graph(lengths, wrapped);
 
   // Verify dimension lengths and wrapping
-  for (int dimension_index = 0;
-       dimension_index < DIMENSIONS;
+  for (unsigned int dimension_index = 0;
+       dimension_index < Dims;
        ++dimension_index) {
     BOOST_REQUIRE(graph.length(dimension_index) == lengths[dimension_index]);
     BOOST_REQUIRE(graph.wrapped(dimension_index) == wrapped[dimension_index]);
@@ -107,8 +97,8 @@ int test_main(int argc, char* argv[]) {
     vertices_size_type current_index =
       get(boost::vertex_index, graph, current_vertex);
 
-    for (int dimension_index = 0;
-         dimension_index < DIMENSIONS;
+    for (unsigned int dimension_index = 0;
+         dimension_index < Dims;
          ++dimension_index) {
       BOOST_REQUIRE(/*(current_vertex[dimension_index] >= 0) && */ // Always true
                    (current_vertex[dimension_index] < lengths[dimension_index]));        
@@ -205,6 +195,23 @@ int test_main(int argc, char* argv[]) {
   }
 
   BOOST_REQUIRE(edge_count == num_edges(graph));
+}
+
+int test_main(int argc, char* argv[]) {
+
+  std::size_t random_seed = time(0);
+
+  if (argc > 1) {
+    random_seed = lexical_cast<std::size_t>(argv[1]);
+  }
+
+  minstd_rand generator(random_seed);
+
+  do_test<0>(generator);
+  do_test<1>(generator);
+  do_test<2>(generator);
+  do_test<3>(generator);
+  do_test<4>(generator);
 
   return (0);
 }
diff --git a/test/hawick_circuits.cpp b/test/hawick_circuits.cpp
new file mode 100644
index 000000000..29b6470be
--- /dev/null
+++ b/test/hawick_circuits.cpp
@@ -0,0 +1,32 @@
+// (C) Copyright 2013 Louis Dionne
+//
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0 (See accompanying file
+// LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+
+#include "cycle_test.hpp"
+#include <boost/graph/hawick_circuits.hpp>
+#include <iostream>
+
+
+struct call_hawick_circuits {
+    template <typename Graph, typename Visitor>
+    void operator()(Graph const& g, Visitor const& v) const {
+        boost::hawick_circuits(g, v);
+    }
+};
+
+struct call_hawick_unique_circuits {
+    template <typename Graph, typename Visitor>
+    void operator()(Graph const& g, Visitor const& v) const {
+        boost::hawick_unique_circuits(g, v);
+    }
+};
+
+int main() {
+    std::cout << "---------hawick_circuits---------\n";
+    cycle_test(call_hawick_circuits());
+
+    std::cout << "\n\n---------hawick_unique_circuits---------\n";
+    cycle_test(call_hawick_unique_circuits());
+}
diff --git a/test/index_graph.cpp b/test/index_graph.cpp
index b988179f6..aaa7958bd 100644
--- a/test/index_graph.cpp
+++ b/test/index_graph.cpp
@@ -20,7 +20,7 @@ void test()
     static const size_t N = 5;
 
     Graph g;
-    IndexMap x = get(vertex_index, g);
+    (void)(IndexMap)get(vertex_index, g);
 
     // build up the graph
     Vertex v[N];
@@ -64,7 +64,6 @@ void test()
 template <typename Graph>
 void build()
 {
-    typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
     typedef typename graph_traits<Graph>::vertex_iterator Iterator;
     typedef typename property_map<Graph, vertex_index_t>::type IndexMap;
 
@@ -73,7 +72,7 @@ void build()
     Graph g(N);
     BOOST_ASSERT(max_vertex_index(g) == N);
 
-    IndexMap x = get(vertex_index, g);
+    (void)(IndexMap)get(vertex_index, g);
 
     // Each vertex should be numbered correctly.
     Iterator i, end;
diff --git a/test/isomorphism.cpp b/test/isomorphism.cpp
index 3650fdbba..fee22a21d 100644
--- a/test/isomorphism.cpp
+++ b/test/isomorphism.cpp
@@ -93,8 +93,67 @@ void generate_random_digraph(Graph& g, double edge_probability)
   }
 }
 
+void test_isomorphism2()
+{
+  using namespace boost::graph::keywords;
+  typedef adjacency_list<vecS, vecS, bidirectionalS> graph1;
+  typedef adjacency_list<listS, listS, bidirectionalS,
+                         property<vertex_index_t, int> > graph2;
+
+  graph1 g1(2);
+  add_edge(vertex(0, g1), vertex(1, g1), g1);
+  add_edge(vertex(1, g1), vertex(1, g1), g1);
+  graph2 g2;
+  randomly_permute_graph(g1, g2);
+
+  int v_idx = 0;
+  for (graph2::vertex_iterator v = vertices(g2).first;
+       v != vertices(g2).second; ++v) {
+    put(vertex_index_t(), g2, *v, v_idx++);
+  }
+
+  std::map<graph1::vertex_descriptor, graph2::vertex_descriptor> mapping;
+
+  bool isomorphism_correct;
+  clock_t start = clock();
+  BOOST_CHECK(isomorphism_correct = boost::graph::isomorphism
+               (g1, g2, _isomorphism_map = make_assoc_property_map(mapping)));
+  clock_t end = clock();
+
+  std::cout << "Elapsed time (clock cycles): " << (end - start) << std::endl;
+
+  bool verify_correct;
+  BOOST_CHECK(verify_correct =
+             verify_isomorphism(g1, g2, make_assoc_property_map(mapping)));
+
+  if (!isomorphism_correct || !verify_correct) {
+    // Output graph 1
+    {
+      std::ofstream out("isomorphism_failure.bg1");
+      out << num_vertices(g1) << std::endl;
+      for (graph1::edge_iterator e = edges(g1).first;
+           e != edges(g1).second; ++e) {
+        out << get(vertex_index_t(), g1, source(*e, g1)) << ' '
+            << get(vertex_index_t(), g1, target(*e, g1)) << std::endl;
+      }
+    }
+
+    // Output graph 2
+    {
+      std::ofstream out("isomorphism_failure.bg2");
+      out << num_vertices(g2) << std::endl;
+      for (graph2::edge_iterator e = edges(g2).first;
+           e != edges(g2).second; ++e) {
+        out << get(vertex_index_t(), g2, source(*e, g2)) << ' '
+            << get(vertex_index_t(), g2, target(*e, g2)) << std::endl;
+      }
+    }
+  }
+}
+
 void test_isomorphism(int n, double edge_probability)
 {
+  using namespace boost::graph::keywords;
   typedef adjacency_list<vecS, vecS, bidirectionalS> graph1;
   typedef adjacency_list<listS, listS, bidirectionalS,
                          property<vertex_index_t, int> > graph2;
@@ -114,8 +173,8 @@ void test_isomorphism(int n, double edge_probability)
 
   bool isomorphism_correct;
   clock_t start = clock();
-  BOOST_CHECK(isomorphism_correct = isomorphism
-               (g1, g2, isomorphism_map(make_assoc_property_map(mapping))));
+  BOOST_CHECK(isomorphism_correct = boost::graph::isomorphism
+               (g1, g2, _isomorphism_map = make_assoc_property_map(mapping)));
   clock_t end = clock();
 
   std::cout << "Elapsed time (clock cycles): " << (end - start) << std::endl;
diff --git a/test/labeled_graph.cpp b/test/labeled_graph.cpp
index 455675d52..df16aa0f4 100644
--- a/test/labeled_graph.cpp
+++ b/test/labeled_graph.cpp
@@ -62,7 +62,7 @@ void label_graph(Graph& g)
     typedef typename graph_traits<Graph>::vertex_iterator Iter;
     Iter f, l;
     int x = 0;
-    for(tie(f, l) = vertices(g); f != l; ++f, ++x) {
+    for(boost::tie(f, l) = vertices(g); f != l; ++f, ++x) {
         label_vertex(*f, x, g);
     }
 }
diff --git a/test/layout_test.cpp b/test/layout_test.cpp
index 7f85614a9..4bf9e7052 100644
--- a/test/layout_test.cpp
+++ b/test/layout_test.cpp
@@ -78,10 +78,8 @@ template<typename Graph>
 void 
 test_circle_layout(Graph*, typename graph_traits<Graph>::vertices_size_type n)
 {
-  typedef typename graph_traits<Graph>::vertex_descriptor vertex;
   typedef typename graph_traits<Graph>::vertex_iterator vertex_iterator;
   typedef typename graph_traits<Graph>::vertices_size_type vertices_size_type;
-  typedef typename graph_traits<Graph>::edges_size_type edges_size_type;
 
   Graph g(n);
 
diff --git a/test/leda_graph_cc.cpp b/test/leda_graph_cc.cpp
index 40fafcf5c..389985162 100644
--- a/test/leda_graph_cc.cpp
+++ b/test/leda_graph_cc.cpp
@@ -8,7 +8,7 @@
 //=======================================================================
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/leda_graph.hpp>
-
+#include <boost/concept/assert.hpp>
 
 int
 main(int,char*[])
@@ -18,21 +18,21 @@ main(int,char*[])
     typedef leda::GRAPH<int,int> Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< BidirectionalGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< VertexMutableGraphConcept<Graph> >();
-    function_requires< EdgeMutableGraphConcept<Graph> >();
-    function_requires< VertexMutablePropertyGraphConcept<Graph> >();
-    function_requires< EdgeMutablePropertyGraphConcept<Graph> >();
-    function_requires<
-      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> >();
-    function_requires<
-      ReadablePropertyGraphConcept<Graph, Edge, edge_index_t> >();
-    function_requires<
-      LvaluePropertyGraphConcept<Graph, Vertex, vertex_all_t> >();
-    function_requires<
-      LvaluePropertyGraphConcept<Graph, Vertex, edge_all_t> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( VertexMutableGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeMutableGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( VertexMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( EdgeMutablePropertyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT((
+      ReadablePropertyGraphConcept<Graph, Vertex, vertex_index_t> ));
+    BOOST_CONCEPT_ASSERT((
+      ReadablePropertyGraphConcept<Graph, Edge, edge_index_t> ));
+    BOOST_CONCEPT_ASSERT((
+      LvaluePropertyGraphConcept<Graph, Vertex, vertex_all_t> ));
+    BOOST_CONCEPT_ASSERT((
+      LvaluePropertyGraphConcept<Graph, Vertex, edge_all_t> ));
   }
   return 0;
 }
diff --git a/test/make_bicon_planar_test.cpp b/test/make_bicon_planar_test.cpp
index 1eacf0a04..9e31c4c11 100644
--- a/test/make_bicon_planar_test.cpp
+++ b/test/make_bicon_planar_test.cpp
@@ -25,7 +25,7 @@ void reset_edge_index(Graph& g)
   typename property_map<Graph, edge_index_t>::type index = get(edge_index, g);
   typename graph_traits<Graph>::edge_iterator ei, ei_end;
   typename graph_traits<Graph>::edges_size_type cnt = 0;
-  for(tie(ei,ei_end) = edges(g); ei != ei_end; ++ei)
+  for(boost::tie(ei,ei_end) = edges(g); ei != ei_end; ++ei)
     put(index, *ei, cnt++);
 }
 
@@ -54,7 +54,7 @@ struct UpdateVertexIndex
     typename property_map<Graph, vertex_index_t>::type index = get(vertex_index, g);
     typename graph_traits<Graph>::vertex_iterator vi, vi_end;
     typename graph_traits<Graph>::vertices_size_type cnt = 0;
-    for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
+    for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
       put(index, *vi, cnt++);
   }
 };
@@ -87,7 +87,7 @@ void test_line_graph(VertexIndexUpdater vertex_index_updater, int size)
   embedding_t embedding(embedding_storage.begin(), get(vertex_index, g));
 
   typename graph_traits<Graph>::vertex_iterator vi, vi_end;
-  for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
+  for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
     std::copy(out_edges(*vi,g).first, out_edges(*vi,g).second, std::back_inserter(embedding[*vi]));
 
   BOOST_CHECK(biconnected_components(g, make_vector_property_map<int>(get(edge_index,g))) > 1);
diff --git a/test/make_connected_test.cpp b/test/make_connected_test.cpp
index a33ee9a8e..d1d5d41df 100644
--- a/test/make_connected_test.cpp
+++ b/test/make_connected_test.cpp
@@ -24,7 +24,7 @@ void reset_edge_index(Graph& g)
   typename property_map<Graph, edge_index_t>::type index = get(edge_index, g);
   typename graph_traits<Graph>::edge_iterator ei, ei_end;
   typename graph_traits<Graph>::edges_size_type cnt = 0;
-  for(tie(ei,ei_end) = edges(g); ei != ei_end; ++ei)
+  for(boost::tie(ei,ei_end) = edges(g); ei != ei_end; ++ei)
     put(index, *ei, cnt++);
 }
 
@@ -36,7 +36,7 @@ void reset_vertex_index(Graph& g)
   typename property_map<Graph, vertex_index_t>::type index = get(vertex_index, g);
   typename graph_traits<Graph>::vertex_iterator vi, vi_end;
   typename graph_traits<Graph>::vertices_size_type cnt = 0;
-  for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
+  for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
     put(index, *vi, cnt++);
 }
 
@@ -114,10 +114,14 @@ int test_main(int, char* [])
   make_disconnected_cycles(gVV, num_cycles, cycle_size);
   reset_edge_index(gVV);
   std::vector<int> gVV_components(num_vertices(gVV));
-  BOOST_CHECK(connected_components(gVV, &gVV_components[0]) == 
+  boost::iterator_property_map<
+    std::vector<int>::iterator,
+    boost::property_map<VVgraph_t, boost::vertex_index_t>::const_type
+  > gVV_components_pm(gVV_components.begin(), get(boost::vertex_index, gVV));
+  BOOST_CHECK(connected_components(gVV, gVV_components_pm) == 
               static_cast<int>(num_cycles));
   make_connected(gVV);
-  BOOST_CHECK(connected_components(gVV, &gVV_components[0]) == 1);
+  BOOST_CHECK(connected_components(gVV, gVV_components_pm) == 1);
   BOOST_CHECK(num_edges(gVV) == num_cycles * cycle_size + num_cycles - 1);
 
   LVgraph_t gLV;
@@ -126,10 +130,14 @@ int test_main(int, char* [])
   make_disconnected_cycles(gLV, num_cycles, cycle_size);
   reset_edge_index(gLV);
   std::vector<int> gLV_components(num_vertices(gLV));
-  BOOST_CHECK(connected_components(gLV, &gLV_components[0]) == 
+  boost::iterator_property_map<
+    std::vector<int>::iterator,
+    boost::property_map<VVgraph_t, boost::vertex_index_t>::const_type
+  > gLV_components_pm(gLV_components.begin(), get(boost::vertex_index, gLV));
+  BOOST_CHECK(connected_components(gLV, gLV_components_pm) == 
               static_cast<int>(num_cycles));
   make_connected(gLV);
-  BOOST_CHECK(connected_components(gLV, &gLV_components[0]) == 1);
+  BOOST_CHECK(connected_components(gLV, gLV_components_pm) == 1);
   BOOST_CHECK(num_edges(gLV) == num_cycles * cycle_size + num_cycles - 1);
 
   VLgraph_t gVL;
diff --git a/test/make_maximal_planar_test.cpp b/test/make_maximal_planar_test.cpp
index 7d5c6a570..7b174f43d 100644
--- a/test/make_maximal_planar_test.cpp
+++ b/test/make_maximal_planar_test.cpp
@@ -24,7 +24,7 @@ void reset_edge_index(Graph& g)
   typename property_map<Graph, edge_index_t>::type index = get(edge_index, g);
   typename graph_traits<Graph>::edge_iterator ei, ei_end;
   typename graph_traits<Graph>::edges_size_type cnt = 0;
-  for(tie(ei,ei_end) = edges(g); ei != ei_end; ++ei)
+  for(boost::tie(ei,ei_end) = edges(g); ei != ei_end; ++ei)
     put(index, *ei, cnt++);
 }
 
@@ -56,7 +56,7 @@ struct UpdateVertexIndex
     typename property_map<Graph, vertex_index_t>::type index = get(vertex_index, g);
     typename graph_traits<Graph>::vertex_iterator vi, vi_end;
     typename graph_traits<Graph>::vertices_size_type cnt = 0;
-    for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
+    for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
       put(index, *vi, cnt++);
   }
 };
@@ -89,7 +89,7 @@ void test_cycle(VertexIndexUpdater vertex_index_updater, int size)
   embedding_t embedding(embedding_storage.begin(), get(vertex_index, g));
 
   typename graph_traits<Graph>::vertex_iterator vi, vi_end;
-  for(tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
+  for(boost::tie(vi,vi_end) = vertices(g); vi != vi_end; ++vi)
     std::copy(out_edges(*vi,g).first, out_edges(*vi,g).second, std::back_inserter(embedding[*vi]));
 
   BOOST_CHECK(boyer_myrvold_planarity_test(g));
diff --git a/test/mas_test.cpp b/test/mas_test.cpp
new file mode 100644
index 000000000..3553d65fe
--- /dev/null
+++ b/test/mas_test.cpp
@@ -0,0 +1,227 @@
+//            Copyright Fernando Vilas 2012.
+//     Based on stoer_wagner_test.cpp by Daniel Trebbien.
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE_1_0.txt or the copy at
+//         http://www.boost.org/LICENSE_1_0.txt)
+
+#include <fstream>
+#include <iostream>
+#include <map>
+#include <vector>
+#include <string>
+#include <boost/graph/adjacency_list.hpp>
+#include <boost/graph/connected_components.hpp>
+#include <boost/graph/exception.hpp>
+#include <boost/graph/graph_traits.hpp>
+#include <boost/graph/read_dimacs.hpp>
+#include <boost/graph/maximum_adjacency_search.hpp>
+#include <boost/graph/visitors.hpp>
+#include <boost/graph/property_maps/constant_property_map.hpp>
+#include <boost/property_map/property_map.hpp>
+#include <boost/test/unit_test.hpp>
+#include <boost/tuple/tuple.hpp>
+#include <boost/tuple/tuple_comparison.hpp>
+#include <boost/tuple/tuple_io.hpp>
+
+#include <boost/graph/iteration_macros.hpp>
+
+typedef boost::adjacency_list<boost::vecS, boost::vecS, boost::undirectedS, boost::no_property, boost::property<boost::edge_weight_t, int> > undirected_graph;
+typedef boost::property_map<undirected_graph, boost::edge_weight_t>::type weight_map_type;
+typedef boost::property_traits<weight_map_type>::value_type weight_type;
+
+typedef boost::adjacency_list<boost::vecS, boost::vecS, boost::undirectedS> undirected_unweighted_graph;
+
+std::string test_dir;
+
+boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] ) {
+  if (argc != 2) {
+    std::cerr << "Usage: " << argv[0] << " path-to-libs-graph-test" << std::endl;
+    throw boost::unit_test::framework::setup_error("Invalid command line arguments");
+  }
+  test_dir = argv[1];
+  return 0;
+}
+
+struct edge_t
+{
+  unsigned long first;
+  unsigned long second;
+};
+
+template <typename Graph, typename KeyedUpdatablePriorityQueue>
+class mas_edge_connectivity_visitor : public boost::default_mas_visitor {
+  public:
+    typedef typename boost::graph_traits<Graph>::vertex_descriptor vertex_descriptor;
+    typedef typename KeyedUpdatablePriorityQueue::key_type weight_type;
+#if 0
+    mas_edge_connectivity_visitor(const mas_edge_connectivity_visitor<Graph, KeyedUpdatablePriorityQueue>& r)
+      : m_pq(r.m_pq), m_curr(r.m_curr), m_prev(r.m_prev), 
+        m_reach_weight(r.m_reach_weight) {
+          BOOST_TEST_MESSAGE( "COPY CTOR" );
+        }
+#endif
+    explicit mas_edge_connectivity_visitor(KeyedUpdatablePriorityQueue& pq)
+      : m_pq(pq),
+        m_curr(new vertex_descriptor(0)), m_prev(new vertex_descriptor(0)),
+        m_reach_weight(new weight_type(0)) {
+      //    BOOST_TEST_MESSAGE( "CTOR" );
+        }
+
+  void clear() {
+    *m_curr = 0;
+    *m_prev = 0;
+    *m_reach_weight = 0;
+  }
+
+  //template <typename Vertex> //, typename Graph>
+  //void start_vertex(Vertex u, const Graph& g) {
+  void start_vertex(vertex_descriptor u, const Graph& g) {
+    *m_prev = *m_curr;
+    *m_curr = u;
+    //BOOST_TEST_MESSAGE( "Initializing Vertex(weight): " << u << "(" << *m_reach_weight << ")" );
+    *m_reach_weight = get(m_pq.keys(), u);
+  }
+
+  vertex_descriptor curr() const { return *m_curr; }
+  vertex_descriptor prev() const { return *m_prev; }
+  weight_type reach_weight() const { return *m_reach_weight; }
+
+  private:
+
+    const KeyedUpdatablePriorityQueue& m_pq;
+    boost::shared_ptr<vertex_descriptor> m_curr, m_prev;
+    boost::shared_ptr<weight_type> m_reach_weight;
+};
+
+
+// the example from Stoer & Wagner (1997)
+// Check various implementations of the ArgPack where
+// the weights are provided in it, and one case where
+// they are not.
+BOOST_AUTO_TEST_CASE(test0)
+{
+  typedef boost::graph_traits<undirected_graph>::vertex_descriptor vertex_descriptor;
+  typedef boost::graph_traits<undirected_graph>::edge_descriptor edge_descriptor;
+
+  edge_t edges[] = {{0, 1}, {1, 2}, {2, 3},
+    {0, 4}, {1, 4}, {1, 5}, {2, 6}, {3, 6}, {3, 7}, {4, 5}, {5, 6}, {6, 7}};
+  weight_type ws[] = {2, 3, 4, 3, 2, 2, 2, 2, 2, 3, 1, 3};
+  undirected_graph g(edges, edges + 12, ws, 8, 12);
+
+  weight_map_type weights = get(boost::edge_weight, g);
+
+  std::map<vertex_descriptor, vertex_descriptor> assignment;
+  boost::associative_property_map<std::map<vertex_descriptor, vertex_descriptor> > assignments(assignment);
+
+  typedef boost::shared_array_property_map<weight_type, boost::property_map<undirected_graph, boost::vertex_index_t>::const_type> distances_type;
+  distances_type distances = boost::make_shared_array_property_map(num_vertices(g), weight_type(0), get(boost::vertex_index, g));
+  typedef std::vector<vertex_descriptor>::size_type index_in_heap_type;
+  typedef boost::shared_array_property_map<index_in_heap_type, boost::property_map<undirected_graph, boost::vertex_index_t>::const_type> indicesInHeap_type;
+  indicesInHeap_type indicesInHeap = boost::make_shared_array_property_map(num_vertices(g), index_in_heap_type(-1), get(boost::vertex_index, g));
+  boost::d_ary_heap_indirect<vertex_descriptor, 22, indicesInHeap_type, distances_type, std::greater<weight_type> > pq(distances, indicesInHeap);
+
+  mas_edge_connectivity_visitor<undirected_graph,boost::d_ary_heap_indirect<vertex_descriptor, 22, indicesInHeap_type, distances_type, std::greater<weight_type> > >  test_vis(pq);
+
+  boost::maximum_adjacency_search(g,
+        boost::weight_map(weights).
+        visitor(test_vis).
+        root_vertex(*vertices(g).first).
+        vertex_assignment_map(assignments).
+        max_priority_queue(pq));
+
+  BOOST_CHECK_EQUAL(test_vis.curr(), vertex_descriptor(7));
+  BOOST_CHECK_EQUAL(test_vis.prev(), vertex_descriptor(6));
+  BOOST_CHECK_EQUAL(test_vis.reach_weight(), 5);
+
+  test_vis.clear();
+  boost::maximum_adjacency_search(g,
+        boost::weight_map(weights).
+        visitor(test_vis).
+        root_vertex(*vertices(g).first).
+        max_priority_queue(pq));
+
+  BOOST_CHECK_EQUAL(test_vis.curr(), vertex_descriptor(7));
+  BOOST_CHECK_EQUAL(test_vis.prev(), vertex_descriptor(6));
+  BOOST_CHECK_EQUAL(test_vis.reach_weight(), 5);
+
+  test_vis.clear();
+  boost::maximum_adjacency_search(g,
+        boost::weight_map(weights).
+        visitor(test_vis).
+        max_priority_queue(pq));
+
+  BOOST_CHECK_EQUAL(test_vis.curr(), vertex_descriptor(7));
+  BOOST_CHECK_EQUAL(test_vis.prev(), vertex_descriptor(6));
+  BOOST_CHECK_EQUAL(test_vis.reach_weight(), 5);
+
+  boost::maximum_adjacency_search(g,
+        boost::weight_map(weights).
+        visitor(boost::make_mas_visitor(boost::null_visitor())));
+
+  boost::maximum_adjacency_search(g,
+        boost::weight_map(weights));
+
+  boost::maximum_adjacency_search(g,
+        boost::root_vertex(*vertices(g).first));
+
+  test_vis.clear();
+  boost::maximum_adjacency_search(g,
+      boost::weight_map(boost::make_constant_property<edge_descriptor>(weight_type(1))).
+      visitor(test_vis).
+      max_priority_queue(pq));
+  BOOST_CHECK_EQUAL(test_vis.curr(), vertex_descriptor(7));
+  BOOST_CHECK_EQUAL(test_vis.prev(), vertex_descriptor(3));
+  BOOST_CHECK_EQUAL(test_vis.reach_weight(), 2);
+
+}
+
+// Check the unweighted case
+// with and without providing a weight_map
+BOOST_AUTO_TEST_CASE(test1)
+{
+  typedef boost::graph_traits<undirected_unweighted_graph>::vertex_descriptor vertex_descriptor;
+  typedef boost::graph_traits<undirected_unweighted_graph>::edge_descriptor edge_descriptor;
+
+  edge_t edge_list[] = {{0, 1}, {1, 2}, {2, 3},
+    {0, 4}, {1, 4}, {1, 5}, {2, 6}, {3, 6}, {3, 7}, {4, 5}, {5, 6}, {6, 7}};
+  undirected_unweighted_graph g(edge_list, edge_list + 12, 8);
+
+  std::map<vertex_descriptor, vertex_descriptor> assignment;
+  boost::associative_property_map<std::map<vertex_descriptor, vertex_descriptor> > assignments(assignment);
+
+  typedef unsigned weight_type;
+  typedef boost::shared_array_property_map<weight_type, boost::property_map<undirected_graph, boost::vertex_index_t>::const_type> distances_type;
+  distances_type distances = boost::make_shared_array_property_map(num_vertices(g), weight_type(0), get(boost::vertex_index, g));
+  typedef std::vector<vertex_descriptor>::size_type index_in_heap_type;
+  typedef boost::shared_array_property_map<index_in_heap_type, boost::property_map<undirected_graph, boost::vertex_index_t>::const_type> indicesInHeap_type;
+  indicesInHeap_type indicesInHeap = boost::make_shared_array_property_map(num_vertices(g), index_in_heap_type(-1), get(boost::vertex_index, g));
+  boost::d_ary_heap_indirect<vertex_descriptor, 22, indicesInHeap_type, distances_type, std::greater<weight_type> > pq(distances, indicesInHeap);
+
+  mas_edge_connectivity_visitor<undirected_unweighted_graph,boost::d_ary_heap_indirect<vertex_descriptor, 22, indicesInHeap_type, distances_type, std::greater<weight_type> > >  test_vis(pq);
+
+  boost::maximum_adjacency_search(g, 
+         boost::weight_map(boost::make_constant_property<edge_descriptor>(weight_type(1))).visitor(test_vis).max_priority_queue(pq));
+
+  BOOST_CHECK_EQUAL(test_vis.curr(), vertex_descriptor(7));
+  BOOST_CHECK_EQUAL(test_vis.prev(), vertex_descriptor(3));
+  BOOST_CHECK_EQUAL(test_vis.reach_weight(), weight_type(2));
+
+  weight_type ws[] = {2, 3, 4, 3, 2, 2, 2, 2, 2, 3, 1, 3};
+  std::map<edge_descriptor, weight_type> wm;
+
+  weight_type i = 0;
+  BGL_FORALL_EDGES(e, g, undirected_unweighted_graph) {
+    wm[e] = ws[i];
+    ++i;
+  }
+  boost::associative_property_map<std::map<edge_descriptor, weight_type> > ws_map(wm);
+
+  boost::maximum_adjacency_search(g, boost::weight_map(ws_map).visitor(test_vis).max_priority_queue(pq));
+  BOOST_CHECK_EQUAL(test_vis.curr(), vertex_descriptor(7));
+  BOOST_CHECK_EQUAL(test_vis.prev(), vertex_descriptor(6));
+  BOOST_CHECK_EQUAL(test_vis.reach_weight(), weight_type(5));
+
+}
+
+#include <boost/graph/iteration_macros_undef.hpp>
+
diff --git a/test/matching_test.cpp b/test/matching_test.cpp
index 784fca587..f15269651 100644
--- a/test/matching_test.cpp
+++ b/test/matching_test.cpp
@@ -131,7 +131,6 @@ void matching_test(std::size_t num_v, const std::string& graph_name)
   typedef vector_property_map< typename graph_traits<Graph>::vertex_descriptor, vertex_index_map_t > mate_t;
   typedef typename graph_traits<Graph>::vertex_iterator vertex_iterator_t;
   typedef typename graph_traits<Graph>::vertex_descriptor vertex_descriptor_t;
-  typedef typename graph_traits<Graph>::vertices_size_type v_size_t;
 
   const std::size_t double_num_v = num_v * 2;
 
diff --git a/test/mcgregor_subgraphs_test.cpp b/test/mcgregor_subgraphs_test.cpp
index 516a32aa3..96cf4fa07 100644
--- a/test/mcgregor_subgraphs_test.cpp
+++ b/test/mcgregor_subgraphs_test.cpp
@@ -195,10 +195,6 @@ struct simple_callback {
 
     typedef typename boost::graph_traits<Graph>::vertex_descriptor Vertex;
 
-    typedef typename boost::property_map<Graph, boost::vertex_index_t>::type VertexIndexMap;
-    typedef typename boost::property_map<Graph, boost::vertex_name_t>::type VertexNameMap;
-    typedef typename boost::property_map<Graph, boost::edge_name_t>::type EdgeNameMap;
-
     std::stringstream subgraph_string;
 
     BGL_FORALL_VERTICES_T(vertex1, m_graph1, Graph) {
@@ -308,9 +304,6 @@ int test_main (int argc, char *argv[]) {
     boost::property<boost::vertex_index_t, unsigned int> >,
     boost::property<boost::edge_name_t, unsigned int> > Graph;
 
-  typedef boost::graph_traits<Graph>::vertex_descriptor Vertex;
-  typedef boost::graph_traits<Graph>::edge_descriptor Edge;
-
   typedef boost::property_map<Graph, boost::vertex_name_t>::type VertexNameMap;
   typedef boost::property_map<Graph, boost::edge_name_t>::type EdgeNameMap;
 
diff --git a/test/mean_geodesic.cpp b/test/mean_geodesic.cpp
index c5b0f91f4..d78f677d7 100644
--- a/test/mean_geodesic.cpp
+++ b/test/mean_geodesic.cpp
@@ -31,8 +31,6 @@ struct vertex_vector
 template <typename Graph>
 void build_graph(Graph& g, typename vertex_vector<Graph>::type& v)
 {
-    typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
-
     // add vertices
     for(size_t i = 0; i < N; ++i) {
         v[i] = add_vertex(g);
diff --git a/test/metric_tsp_approx.cpp b/test/metric_tsp_approx.cpp
index 111a8e26e..57560bd4d 100644
--- a/test/metric_tsp_approx.cpp
+++ b/test/metric_tsp_approx.cpp
@@ -86,7 +86,6 @@ void testScalability(unsigned numpts)
         property <edge_weight_t, double,
         property<edge_index_t, int> > > Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
-    typedef graph_traits <Graph>::edge_descriptor Edge;
     typedef property_map<Graph, edge_weight_t>::type WeightMap;
     typedef set<simple_point<double>, cmpPnt<double> > PointSet;
     typedef vector< Vertex > Container;
@@ -199,7 +198,6 @@ int main(int argc, char* argv[])
     typedef adjacency_matrix<undirectedS, no_property,
         property <edge_weight_t, double> > Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
-    typedef graph_traits <Graph>::edge_descriptor Edge;
     typedef vector<Vertex> Container;
     typedef property_map<Graph, edge_weight_t>::type WeightMap;
     typedef property_map<Graph, vertex_index_t>::type VertexMap;
diff --git a/test/min_cost_max_flow_utils.hpp b/test/min_cost_max_flow_utils.hpp
new file mode 100644
index 000000000..37c97953c
--- /dev/null
+++ b/test/min_cost_max_flow_utils.hpp
@@ -0,0 +1,136 @@
+//=======================================================================
+// Copyright 2013 University of Warsaw.
+// Authors: Piotr Wygocki 
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//=======================================================================
+
+#ifndef SAMPLE_GRAPH_UNDIRECTED_HPP
+#define SAMPLE_GRAPH_UNDIRECTED_HPP 
+
+#include <iostream>
+#include <cstdlib>
+#include <boost/graph/adjacency_list.hpp>
+
+
+namespace boost {
+struct SampleGraph {
+    typedef adjacency_list_traits < vecS, vecS, directedS > Traits;
+
+    typedef adjacency_list < vecS, vecS, directedS, no_property,
+            property < edge_capacity_t, long,
+                property < edge_residual_capacity_t, long,
+                    property < edge_reverse_t, Traits::edge_descriptor, 
+                        property <edge_weight_t, long>
+                             > 
+                        > 
+                     > > Graph;
+    typedef property_map < Graph, edge_capacity_t >::type Capacity;
+    typedef property_map < Graph, edge_residual_capacity_t >::type ResidualCapacity;
+    typedef property_map < Graph, edge_weight_t >::type Weight;
+    typedef property_map < Graph, edge_reverse_t>::type Reversed;
+    typedef boost::graph_traits<Graph>::vertices_size_type size_type;
+    typedef Traits::vertex_descriptor vertex_descriptor;
+    
+    class EdgeAdder {
+    public:
+        EdgeAdder(Graph & g, Weight & w, Capacity & c, Reversed & rev, ResidualCapacity & residualCapacity) 
+            : m_g(g), m_w(w), m_cap(c), m_resCap(residualCapacity), m_rev(rev) {}
+        void addEdge(vertex_descriptor v, vertex_descriptor w, long weight, long capacity) {
+            Traits::edge_descriptor e,f;
+            e = add(v, w, weight, capacity);
+            f = add(w, v, -weight, 0);
+            m_rev[e] = f; 
+            m_rev[f] = e; 
+        }
+    private:
+        Traits::edge_descriptor add(vertex_descriptor v, vertex_descriptor w, long weight, long capacity) {
+            bool b;
+            Traits::edge_descriptor e;
+            boost::tie(e, b) = add_edge(vertex(v, m_g), vertex(w, m_g), m_g);
+            if (!b) {
+              std::cerr << "Edge between " << v << " and " << w << " already exists." << std::endl;
+              std::abort();
+            }
+            m_cap[e] = capacity;
+            m_w[e] = weight;
+            return e;
+        }
+        Graph & m_g;
+        Weight & m_w;
+        Capacity & m_cap;
+        ResidualCapacity & m_resCap;
+        Reversed & m_rev;
+    };
+
+
+    static void getSampleGraph(Graph &g, vertex_descriptor & s, vertex_descriptor & t) {
+        size_type N(6);
+        typedef property_map < Graph, edge_reverse_t >::type Reversed;
+
+        for(size_type i = 0; i < N; ++i){
+            add_vertex(g);
+        }
+        Capacity  capacity = get(edge_capacity, g);
+        Reversed rev = get(edge_reverse, g);
+        ResidualCapacity residual_capacity = get(edge_residual_capacity, g); 
+        Weight weight = get(edge_weight, g);
+
+        s = 0;
+        t = 5;
+
+        EdgeAdder ea(g, weight, capacity, rev, residual_capacity);
+
+        ea.addEdge(0, 1, 4 ,2);
+        ea.addEdge(0, 2, 2 ,2);
+
+        ea.addEdge(1, 3, 2 ,2);
+        ea.addEdge(1, 4, 1 ,1);
+        ea.addEdge(2, 3, 1 ,1);
+        ea.addEdge(2, 4, 1 ,1);
+
+        ea.addEdge(3, 5, 4 ,20);
+        ea.addEdge(4, 5, 2 ,20);
+    }       
+
+    static void getSampleGraph2(Graph &g, vertex_descriptor & s, vertex_descriptor & t) {
+
+        const boost::graph_traits<Graph>::vertices_size_type N(5);
+        typedef property_map < Graph, edge_reverse_t >::type Reversed;
+
+        for(size_type i = 0; i < N; ++i){
+            add_vertex(g);
+        }
+
+        Capacity  capacity = get(edge_capacity, g);
+        Reversed rev = get(edge_reverse, g);
+        ResidualCapacity residual_capacity = get(edge_residual_capacity, g); 
+        Weight weight = get(edge_weight, g);
+
+        s = 0;
+        t = 4;
+
+        EdgeAdder ea(g, weight, capacity, rev, residual_capacity);
+
+        ea.addEdge(0, 1, 4 ,2);
+        ea.addEdge(0, 2, 2 ,2);
+        ea.addEdge(1, 2, 2 ,2);
+        ea.addEdge(2, 3, 1 ,1);
+        ea.addEdge(2, 4, 1 ,1);
+        ea.addEdge(3, 4, 1 ,1);
+
+
+        ea.addEdge(1, 0, 2 ,2);
+        ea.addEdge(2, 0, 1 ,1);
+        ea.addEdge(2, 1, 5 ,2);
+        ea.addEdge(3, 2, 1 ,1);
+        ea.addEdge(4, 2, 2 ,2);
+        ea.addEdge(4, 3, 1 ,3);
+    }       
+};
+} //boost
+
+#endif /* SAMPLE_GRAPH_UNDIRECTED_HPP */
+
diff --git a/test/parallel_edges_loops_test.cpp b/test/parallel_edges_loops_test.cpp
index 27ccf3ec8..6045c37c3 100644
--- a/test/parallel_edges_loops_test.cpp
+++ b/test/parallel_edges_loops_test.cpp
@@ -16,6 +16,8 @@ This test needs to be linked against Boost.Filesystem.
 
 */
 
+#define BOOST_FILESYSTEM_VERSION 3
+
 #include <iostream>
 #include <fstream>
 #include <vector>
@@ -109,7 +111,7 @@ void read_dimacs(Graph& g, const std::string& filename)
           vertex_iterator_t vi, vi_end;
           long count = 0;
           long mult_count = 0;
-          for(tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
+          for(boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
             {
               if (count % vertex_stride == 0)
                 {
@@ -193,9 +195,7 @@ int test_graph(const std::string& dimacs_filename)
   typedef graph_traits<graph>::edge_iterator edge_iterator_t;
   typedef graph_traits<graph>::vertex_iterator vertex_iterator_t;
   typedef graph_traits<graph>::edges_size_type e_size_t;
-  typedef graph_traits<graph>::vertices_size_type v_size_t;
   typedef graph_traits<graph>::vertex_descriptor vertex_t;
-  typedef std::pair<vertex_t, vertex_t> vertex_pair_t;
   typedef edge_index_update_visitor<property_map<graph, edge_index_t>::type> 
     edge_visitor_t;
 
@@ -208,7 +208,7 @@ int test_graph(const std::string& dimacs_filename)
   // Initialize the interior edge index
   property_map<graph, edge_index_t>::type e_index = get(edge_index, g);
   e_size_t edge_count = 0;
-  for(tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
+  for(boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
     put(e_index, *ei, edge_count++);
 
   // Initialize the interior vertex index - not needed if the vertices
@@ -216,7 +216,7 @@ int test_graph(const std::string& dimacs_filename)
   /*
   property_map<graph, vertex_index_t>::type v_index = get(vertex_index, g);
   v_size_t vertex_count = 0;
-  for(tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
+  for(boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
     put(v_index, *vi, vertex_count++);
   */
 
@@ -340,20 +340,19 @@ int test_main(int argc, char* argv[])
             << std::endl;
 
   filesystem::path input_directory = 
-    filesystem::system_complete
-    (filesystem::path(input_directory_str, filesystem::native));
-  const std::string dimacs_suffix = ".dimacs";
+    filesystem::system_complete(filesystem::path(input_directory_str));
+  const std::string dimacs_extension = ".dimacs";
 
   filesystem::directory_iterator dir_end;
   for( filesystem::directory_iterator dir_itr(input_directory);
        dir_itr != dir_end; ++dir_itr)
   { 
 
-    if (!ends_with(dir_itr->string(), dimacs_suffix))
+    if (dir_itr->path().extension() != dimacs_extension)
       continue;
 
     std::cerr << "Testing " << dir_itr->path().leaf() << "... ";
-    BOOST_REQUIRE (test_graph(dir_itr->string()) == 0);
+    BOOST_REQUIRE (test_graph(dir_itr->path().string()) == 0);
 
     std::cerr << std::endl;
   }
diff --git a/test/property_iter.cpp b/test/property_iter.cpp
index 150061e9f..3c27f9425 100644
--- a/test/property_iter.cpp
+++ b/test/property_iter.cpp
@@ -68,8 +68,10 @@ int main(int, char* [])
   std::size_t current_edge_id = 0;
 
   property_map<Graph, vertex_id_t>::type vertex_id_map = get(vertex_id, g);
+  (void)vertex_id_map;
 
   property_map<Graph, edge_id_t>::type edge_id_map = get(edge_id, g);
+  (void)edge_id_map;
 
   for (std::size_t k = 0; k < N; ++k)
     add_vertex(current_vertex_id++, g);
@@ -107,19 +109,9 @@ int main(int, char* [])
       ++E;
     }
 
-  typedef boost::graph_property_iter_range< Graph, vertex_id_t>::const_iterator    TNodeConstIterator;
-  typedef boost::graph_property_iter_range< Graph, vertex_id_t>::const_type        TNodeConstIteratorType;
-
   typedef boost::graph_property_iter_range< Graph, vertex_id_t>::iterator    TNodeIterator;
-  typedef boost::graph_property_iter_range< Graph, vertex_id_t>::type        TNodeIteratorType;
-
-  typedef boost::graph_property_iter_range< Graph, edge_id_t>::const_iterator    TLinkConstIterator;
-  typedef boost::graph_property_iter_range< Graph, edge_id_t>::const_type        TLinkConstIteratorType;
 
   typedef boost::graph_property_iter_range< Graph, edge_id_t>::iterator    TLinkIterator;
-  typedef boost::graph_property_iter_range< Graph, edge_id_t>::type        TLinkIteratorType;
-
-  typedef std::pair<TLinkConstIterator, TLinkConstIterator> tLinkConstIteratorPair;
 
   TLinkIterator itEdgeBegin, itEdgeEnd;
 
diff --git a/test/random_spanning_tree_test.cpp b/test/random_spanning_tree_test.cpp
index db31e1424..48ae405f2 100644
--- a/test/random_spanning_tree_test.cpp
+++ b/test/random_spanning_tree_test.cpp
@@ -48,7 +48,7 @@ void write_spanning_tree(const Graph& g, PredMap pred, WeightMap weight, string
 
 int main(int, char**) {
 
-  array<size_t, 2> sizes = {{ 5, 5 }};
+  boost::array<size_t, 2> sizes = {{ 5, 5 }};
   graph_type g(sizes);
 
   shared_array_property_map<gt::vertex_descriptor, property_map<graph_type, vertex_index_t>::const_type> pred(num_vertices(g), get(vertex_index, g));
diff --git a/test/rcsp_custom_vertex_id.cpp b/test/rcsp_custom_vertex_id.cpp
new file mode 100644
index 000000000..467709671
--- /dev/null
+++ b/test/rcsp_custom_vertex_id.cpp
@@ -0,0 +1,110 @@
+//=======================================================================
+// Copyright (c) 2013 Alberto Santini
+// Author: Alberto Santini <alberto@santini.in>
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//=======================================================================
+
+#include <boost/graph/graph_traits.hpp>
+#include <boost/graph/adjacency_list.hpp>
+#include <boost/graph/r_c_shortest_paths.hpp>
+#include <boost/graph/iteration_macros.hpp>
+#include <vector>
+#include <memory>
+
+using std::vector;
+using std::allocator;
+using namespace boost;
+
+class VertexProperty {
+public:
+  int property1;
+  int property2;
+  int id;
+  VertexProperty() {}
+  VertexProperty(const int property1, const int property2) : property1(property1), property2(property2) {}
+};
+
+class EdgeProperty {
+public:
+  int cost;
+  int id;
+  EdgeProperty() {}
+  EdgeProperty(const int cost) : cost(cost) {}
+};
+
+typedef adjacency_list<listS, listS, bidirectionalS, VertexProperty, EdgeProperty> Graph;
+typedef graph_traits<Graph>::vertex_descriptor Vertex;
+typedef graph_traits<Graph>::edge_descriptor Edge;
+
+class ResourceCont {
+public:
+  int res;
+  ResourceCont(const int res = 5) : res(res) {}
+  bool operator==(const ResourceCont& rc) const { return (res == rc.res); }
+  bool operator<(const ResourceCont& rc) const { return (res > rc.res); }
+};
+
+class LabelExt {
+public:
+  bool operator()(const Graph& g, ResourceCont& rc, const ResourceCont& old_rc, Edge e) const {
+    rc.res = old_rc.res - g[e].cost;
+    return (rc.res > 0);
+  }
+};
+
+class LabelDom {
+public:
+  bool operator()(const ResourceCont& rc1, const ResourceCont& rc2) const {
+    return (rc1 == rc2 || rc1 < rc2);
+  }
+};
+
+int main() {
+  VertexProperty vp1(1, 1);
+  VertexProperty vp2(5, 9);
+  VertexProperty vp3(4, 3);
+  EdgeProperty e12(1);
+  EdgeProperty e23(2);
+        
+  Graph g;
+        
+  Vertex v1 = add_vertex(g); g[v1] = vp1;
+  Vertex v2 = add_vertex(g); g[v2] = vp2;
+  Vertex v3 = add_vertex(g); g[v3] = vp3;
+  
+  add_edge(v1, v2, e12, g);
+  add_edge(v2, v3, e23, g);
+    
+  int index = 0;
+  BGL_FORALL_VERTICES(v, g, Graph) {
+    g[v].id = index++;
+  }
+  index = 0;
+  BGL_FORALL_EDGES(e, g, Graph) {
+    g[e].id = index++;
+  }
+  
+  typedef vector<vector<Edge> > OptPath;
+  typedef vector<ResourceCont> ParetoOpt;
+  
+  OptPath op;
+  ParetoOpt ol;
+  
+  r_c_shortest_paths( g,
+                      get(&VertexProperty::id, g),
+                      get(&EdgeProperty::id, g),
+                      v1,
+                      v2,
+                      op,
+                      ol,
+                      ResourceCont(5),
+                      LabelExt(),
+                      LabelDom(),
+                      allocator<r_c_shortest_paths_label<Graph, ResourceCont> >(),
+                      default_r_c_shortest_paths_visitor());
+  
+  return 0;
+}
diff --git a/test/read_propmap.cpp b/test/read_propmap.cpp
index 3c0aa69a6..5e22fd443 100644
--- a/test/read_propmap.cpp
+++ b/test/read_propmap.cpp
@@ -6,6 +6,7 @@
 
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/adjacency_list.hpp>
+#include <boost/concept/assert.hpp>
 
 // Test contributed by Dmitry that validates a read-only property map bug
 // for bundled properties.
@@ -24,7 +25,7 @@ int main()
     typedef property_map<graph_t, double EdgeProp::*>::type WeightMap;
     typedef property_map<graph_t, double EdgeProp::*>::const_type cWeightMap;
     typedef graph_traits<graph_t>::edge_descriptor Edge;
-    function_requires<ReadablePropertyMapConcept<WeightMap, Edge> >();
-    function_requires<ReadablePropertyMapConcept<cWeightMap, Edge> >();
+    BOOST_CONCEPT_ASSERT((ReadablePropertyMapConcept<WeightMap, Edge> ));
+    BOOST_CONCEPT_ASSERT((ReadablePropertyMapConcept<cWeightMap, Edge> ));
     return 0;
 }
diff --git a/test/reverse_graph_cc.cpp b/test/reverse_graph_cc.cpp
index 00a362e93..eef53bf97 100644
--- a/test/reverse_graph_cc.cpp
+++ b/test/reverse_graph_cc.cpp
@@ -10,6 +10,7 @@
 #include <boost/graph/graph_archetypes.hpp>
 #include <boost/graph/adjacency_list.hpp>
 #include <boost/graph/reverse_graph.hpp>
+#include <boost/concept/assert.hpp>
 #include <string>
 
 int main(int,char*[])
@@ -23,11 +24,12 @@ int main(int,char*[])
       property<graph_name_t, std::string>
     > AdjList;
     typedef reverse_graph<AdjList> Graph;
-    function_requires< VertexListGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< ReadablePropertyGraphConcept<Graph, Vertex, vertex_color_t> >();
-    function_requires< ReadablePropertyGraphConcept<Graph, Edge, edge_weight_t> >();
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyGraphConcept<Graph, Vertex, vertex_color_t> ));
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyGraphConcept<Graph, Edge, edge_weight_t> ));
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyGraphConcept<Graph, Edge, edge_underlying_t> ));
     AdjList g;
     Graph gr(g);
     get_property(gr, graph_name_t());
@@ -40,11 +42,12 @@ int main(int,char*[])
       property<graph_name_t, std::string>
     > AdjList;
     typedef reverse_graph<AdjList,AdjList&> Graph;
-    function_requires< VertexListGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< PropertyGraphConcept<Graph, Vertex, vertex_color_t> >();
-    function_requires< PropertyGraphConcept<Graph, Edge, edge_weight_t> >();
+    BOOST_CONCEPT_ASSERT(( PropertyGraphConcept<Graph, Vertex, vertex_color_t> ));
+    BOOST_CONCEPT_ASSERT(( PropertyGraphConcept<Graph, Edge, edge_weight_t> ));
+    BOOST_CONCEPT_ASSERT(( ReadablePropertyGraphConcept<Graph, Edge, edge_underlying_t> ));
     AdjList g;
     Graph gr(g);
     get_property(gr, graph_name_t());
diff --git a/test/sequential_vertex_coloring.cpp b/test/sequential_vertex_coloring.cpp
index 2a0775ae0..eee7d7387 100644
--- a/test/sequential_vertex_coloring.cpp
+++ b/test/sequential_vertex_coloring.cpp
@@ -16,7 +16,6 @@ using namespace boost;
 int test_main(int, char*[])
 {
   typedef adjacency_list<listS, vecS, undirectedS> Graph;
-  typedef graph_traits<Graph>::vertex_descriptor vertex_descriptor;
   typedef graph_traits<Graph>::vertices_size_type vertices_size_type;
   typedef property_map<Graph, vertex_index_t>::const_type vertex_index_map;
 
diff --git a/test/stanford_graph_cc.cpp b/test/stanford_graph_cc.cpp
index 1da24d646..c237fdb3e 100644
--- a/test/stanford_graph_cc.cpp
+++ b/test/stanford_graph_cc.cpp
@@ -9,6 +9,7 @@
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/graph_archetypes.hpp>
 #include <boost/graph/stanford_graph.hpp>
+#include <boost/concept/assert.hpp>
 
 int main(int,char*[])
 {
@@ -18,28 +19,28 @@ int main(int,char*[])
     typedef Graph* Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< PropertyGraphConcept<Graph, Edge, edge_length_t > >();
-    function_requires< 
-      PropertyGraphConcept<Graph, Vertex, u_property<Vertex> > >();
-    function_requires< 
-      PropertyGraphConcept<Graph, Edge, a_property<Vertex> > >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( PropertyGraphConcept<Graph, Edge, edge_length_t > ));
+    BOOST_CONCEPT_ASSERT(( 
+      PropertyGraphConcept<Graph, Vertex, u_property<Vertex> > ));
+    BOOST_CONCEPT_ASSERT(( 
+      PropertyGraphConcept<Graph, Edge, a_property<Vertex> > ));
   }
   {
     typedef const Graph* Graph;
     typedef graph_traits<Graph>::vertex_descriptor Vertex;
     typedef graph_traits<Graph>::edge_descriptor Edge;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
-    function_requires< 
-      ReadablePropertyGraphConcept<Graph, Edge, edge_length_t > >();
-    function_requires< 
-      ReadablePropertyGraphConcept<Graph, Vertex, u_property<Vertex> > >();
-    function_requires< 
-      ReadablePropertyGraphConcept<Graph, Edge, a_property<Vertex> > >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( 
+      ReadablePropertyGraphConcept<Graph, Edge, edge_length_t > ));
+    BOOST_CONCEPT_ASSERT(( 
+      ReadablePropertyGraphConcept<Graph, Vertex, u_property<Vertex> > ));
+    BOOST_CONCEPT_ASSERT(( 
+      ReadablePropertyGraphConcept<Graph, Edge, a_property<Vertex> > ));
   }
   return 0;
 }
diff --git a/test/stoer_wagner_test.cpp b/test/stoer_wagner_test.cpp
index 1fc4332b7..0b7e83e20 100644
--- a/test/stoer_wagner_test.cpp
+++ b/test/stoer_wagner_test.cpp
@@ -16,7 +16,6 @@
 #include <boost/graph/stoer_wagner_min_cut.hpp>
 #include <boost/graph/property_maps/constant_property_map.hpp>
 #include <boost/property_map/property_map.hpp>
-#define BOOST_TEST_DYN_LINK 1
 #include <boost/test/unit_test.hpp>
 #include <boost/tuple/tuple.hpp>
 
@@ -46,9 +45,6 @@ struct edge_t
 // the example from Stoer & Wagner (1997)
 BOOST_AUTO_TEST_CASE(test0)
 {
-  typedef boost::graph_traits<undirected_graph>::vertex_descriptor vertex_descriptor;
-  typedef boost::graph_traits<undirected_graph>::edge_descriptor edge_descriptor;
-  
   edge_t edges[] = {{0, 1}, {1, 2}, {2, 3},
     {0, 4}, {1, 4}, {1, 5}, {2, 6}, {3, 6}, {3, 7}, {4, 5}, {5, 6}, {6, 7}};
   weight_type ws[] = {2, 3, 4, 3, 2, 2, 2, 2, 2, 3, 1, 3};
@@ -73,16 +69,12 @@ BOOST_AUTO_TEST_CASE(test0)
 BOOST_AUTO_TEST_CASE(test1)
 {
   { // if only one vertex, can't run `boost::stoer_wagner_min_cut`
-    typedef boost::graph_traits<undirected_graph>::vertex_descriptor vertex_descriptor;
-    typedef boost::graph_traits<undirected_graph>::edge_descriptor edge_descriptor;
-  
     undirected_graph g;
     add_vertex(g);
     
     BOOST_CHECK_THROW(boost::stoer_wagner_min_cut(g, get(boost::edge_weight, g)), boost::bad_graph);
   }{ // three vertices with one multi-edge
     typedef boost::graph_traits<undirected_graph>::vertex_descriptor vertex_descriptor;
-    typedef boost::graph_traits<undirected_graph>::edge_descriptor edge_descriptor;
     
     edge_t edges[] = {{0, 1}, {1, 2}, {1, 2}, {2, 0}};
     weight_type ws[] = {3, 1, 1, 1};
@@ -105,9 +97,6 @@ BOOST_AUTO_TEST_CASE(test1)
 // example by Daniel Trebbien
 BOOST_AUTO_TEST_CASE(test2)
 {
-  typedef boost::graph_traits<undirected_graph>::vertex_descriptor vertex_descriptor;
-  typedef boost::graph_traits<undirected_graph>::edge_descriptor edge_descriptor;
-  
   edge_t edges[] = {{5, 2}, {0, 6}, {5, 6},
     {3, 1}, {0, 1}, {6, 3}, {4, 6}, {2, 4}, {5, 3}};
   weight_type ws[] = {1, 3, 4, 6, 4, 1, 2, 5, 2};
@@ -130,9 +119,6 @@ BOOST_AUTO_TEST_CASE(test2)
 // example by Daniel Trebbien
 BOOST_AUTO_TEST_CASE(test3)
 {
-  typedef boost::graph_traits<undirected_graph>::vertex_descriptor vertex_descriptor;
-  typedef boost::graph_traits<undirected_graph>::edge_descriptor edge_descriptor;
-  
   edge_t edges[] = {{3, 4}, {3, 6}, {3, 5}, {0, 4}, {0, 1}, {0, 6}, {0, 7},
     {0, 5}, {0, 2}, {4, 1}, {1, 6}, {1, 5}, {6, 7}, {7, 5}, {5, 2}, {3, 4}};
   weight_type ws[] = {0, 3, 1, 3, 1, 2, 6, 1, 8, 1, 1, 80, 2, 1, 1, 4};
@@ -197,7 +183,6 @@ BOOST_AUTO_TEST_CASE(test4)
 BOOST_AUTO_TEST_CASE(test_prgen_20_70_2)
 {
   typedef boost::graph_traits<undirected_graph>::vertex_descriptor vertex_descriptor;
-  typedef boost::graph_traits<undirected_graph>::edge_descriptor edge_descriptor;
   
   std::ifstream ifs((test_dir + "/prgen_input_graphs/prgen_20_70_2.net").c_str());
   undirected_graph g;
@@ -207,10 +192,12 @@ BOOST_AUTO_TEST_CASE(test_prgen_20_70_2)
   boost::associative_property_map<std::map<vertex_descriptor, std::size_t> > components(component);
   BOOST_CHECK_EQUAL(boost::connected_components(g, components), 1U); // verify the connectedness assumption
   
-  BOOST_AUTO(distances, (boost::make_shared_array_property_map(num_vertices(g), weight_type(0), get(boost::vertex_index, g))));
+  typedef boost::shared_array_property_map<weight_type, boost::property_map<undirected_graph, boost::vertex_index_t>::const_type> distances_type;
+  distances_type distances = boost::make_shared_array_property_map(num_vertices(g), weight_type(0), get(boost::vertex_index, g));
   typedef std::vector<vertex_descriptor>::size_type index_in_heap_type;
-  BOOST_AUTO(indicesInHeap, (boost::make_shared_array_property_map(num_vertices(g), index_in_heap_type(-1), get(boost::vertex_index, g))));
-  boost::d_ary_heap_indirect<vertex_descriptor, 22, BOOST_TYPEOF(indicesInHeap), BOOST_TYPEOF(distances), std::greater<weight_type> > pq(distances, indicesInHeap);
+  typedef boost::shared_array_property_map<index_in_heap_type, boost::property_map<undirected_graph, boost::vertex_index_t>::const_type> indicesInHeap_type;
+  indicesInHeap_type indicesInHeap = boost::make_shared_array_property_map(num_vertices(g), index_in_heap_type(-1), get(boost::vertex_index, g));
+  boost::d_ary_heap_indirect<vertex_descriptor, 22, indicesInHeap_type, distances_type, std::greater<weight_type> > pq(distances, indicesInHeap);
   
   int w = boost::stoer_wagner_min_cut(g, get(boost::edge_weight, g), boost::max_priority_queue(pq));
   BOOST_CHECK_EQUAL(w, 3407);
@@ -220,7 +207,6 @@ BOOST_AUTO_TEST_CASE(test_prgen_20_70_2)
 BOOST_AUTO_TEST_CASE(test_prgen_50_40_2)
 {
   typedef boost::graph_traits<undirected_graph>::vertex_descriptor vertex_descriptor;
-  typedef boost::graph_traits<undirected_graph>::edge_descriptor edge_descriptor;
   
   std::ifstream ifs((test_dir + "/prgen_input_graphs/prgen_50_40_2.net").c_str());
   undirected_graph g;
@@ -238,7 +224,6 @@ BOOST_AUTO_TEST_CASE(test_prgen_50_40_2)
 BOOST_AUTO_TEST_CASE(test_prgen_50_70_2)
 {
   typedef boost::graph_traits<undirected_graph>::vertex_descriptor vertex_descriptor;
-  typedef boost::graph_traits<undirected_graph>::edge_descriptor edge_descriptor;
   
   std::ifstream ifs((test_dir + "/prgen_input_graphs/prgen_50_70_2.net").c_str());
   undirected_graph g;
diff --git a/test/subgraph.cpp b/test/subgraph.cpp
index d0154a314..b1dcdb59f 100644
--- a/test/subgraph.cpp
+++ b/test/subgraph.cpp
@@ -27,7 +27,6 @@ int test_main(int, char*[])
   > graph_t;
   typedef subgraph<graph_t> subgraph_t;
   typedef graph_traits<subgraph_t>::vertex_descriptor vertex_t;
-  typedef graph_traits<subgraph_t>::edge_descriptor edge_t;
 
   mt19937 gen;
   for (int t = 0; t < 100; t += 5) {
diff --git a/test/subgraph_bundled.cpp b/test/subgraph_bundled.cpp
index 81629c95b..ccfcb42b6 100644
--- a/test/subgraph_bundled.cpp
+++ b/test/subgraph_bundled.cpp
@@ -127,7 +127,7 @@ int test_main(int, char*[])
         graph_traits<Graph>::edge_iterator ei, ee;
         for (boost::tie(ei, ee) = edges(sub); ei != ee; ++ei) {
             // This used to segfault.
-            get(edge_weight, sub, *ei);
+            get(&arc::weight, sub, *ei);
         }
     }
 
diff --git a/test/successive_shortest_path_nonnegative_weights_test.cpp b/test/successive_shortest_path_nonnegative_weights_test.cpp
new file mode 100644
index 000000000..cf9fe50c1
--- /dev/null
+++ b/test/successive_shortest_path_nonnegative_weights_test.cpp
@@ -0,0 +1,67 @@
+//=======================================================================
+// Copyright 2013 University of Warsaw.
+// Authors: Piotr Wygocki 
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//=======================================================================
+
+#define BOOST_TEST_MODULE successive_shortest_path_nonnegative_weights_test
+
+#include <boost/test/unit_test.hpp>
+
+#include <boost/graph/successive_shortest_path_nonnegative_weights.hpp>
+#include <boost/graph/find_flow_cost.hpp>
+
+#include "min_cost_max_flow_utils.hpp"
+
+
+BOOST_AUTO_TEST_CASE(path_augmentation_def_test) {
+    boost::SampleGraph::vertex_descriptor s,t;
+    boost::SampleGraph::Graph g; 
+    boost::SampleGraph::getSampleGraph(g, s, t);
+
+    boost::successive_shortest_path_nonnegative_weights(g, s, t);
+
+    int cost =  boost::find_flow_cost(g);
+    BOOST_CHECK_EQUAL(cost, 29);
+}
+
+BOOST_AUTO_TEST_CASE(path_augmentation_def_test2) {
+    boost::SampleGraph::vertex_descriptor s,t;
+    boost::SampleGraph::Graph g; 
+    boost::SampleGraph::getSampleGraph2(g, s, t);
+
+    boost::successive_shortest_path_nonnegative_weights(g, s, t);
+
+    int cost =  boost::find_flow_cost(g);
+    BOOST_CHECK_EQUAL(cost, 7);
+}
+
+BOOST_AUTO_TEST_CASE(path_augmentation_test) {
+    boost::SampleGraph::vertex_descriptor s,t;
+    typedef boost::SampleGraph::Graph Graph;
+    Graph g;
+    boost::SampleGraph::getSampleGraph(g, s, t);
+
+    int N = boost::num_vertices(g);
+    std::vector<int> dist(N);
+    std::vector<int> dist_prev(N);
+    typedef boost::graph_traits<Graph>::edge_descriptor edge_descriptor;
+    std::vector<edge_descriptor> pred(N);
+        
+    boost::property_map<Graph, boost::vertex_index_t>::const_type
+      idx = get(boost::vertex_index, g);
+
+    boost::successive_shortest_path_nonnegative_weights(g, s, t, 
+            boost::distance_map(boost::make_iterator_property_map(dist.begin(), idx)).
+            predecessor_map(boost::make_iterator_property_map(pred.begin(), idx)).
+            distance_map2(boost::make_iterator_property_map(dist_prev.begin(), idx)).
+            vertex_index_map(idx));
+
+    int cost =  boost::find_flow_cost(g);
+    BOOST_CHECK_EQUAL(cost, 29);
+}
+
+
diff --git a/test/test_construction.hpp b/test/test_construction.hpp
index 4a5a4bbf2..0243f6d2b 100644
--- a/test/test_construction.hpp
+++ b/test/test_construction.hpp
@@ -7,6 +7,7 @@
 #ifndef TEST_CONSTRUCTION_HPP
 #define TEST_CONSTRUCTION_HPP
 
+#include <boost/concept/assert.hpp>
 #include <utility>
 
 /** @name Build Graph
@@ -65,7 +66,7 @@ template <typename Graph>
 void build_property_graph(Graph const&, boost::mpl::true_, boost::mpl::false_) {
     using namespace boost;
     BOOST_CONCEPT_ASSERT((VertexMutablePropertyGraphConcept<Graph>));
-    typedef typename vertex_property<Graph>::type VertexProp;
+    typedef typename vertex_property_type<Graph>::type VertexProp;
 
     std::cout << "...build mutable\n";
 
@@ -93,7 +94,7 @@ void connect_graph(Graph& g, VertexSet const& verts, boost::mpl::false_) {
 
     std::cout << "...connect_normal\n";
     Pair *f, *l;
-    for(tie(f, l) = edge_pairs(); f != l; ++f) {
+    for(boost::tie(f, l) = edge_pairs(); f != l; ++f) {
         Pair const& e = *f;
         add_edge(verts[e.first], verts[e.second], g);
     }
diff --git a/test/test_destruction.hpp b/test/test_destruction.hpp
index f6d8b14c7..8cdfa1b67 100644
--- a/test/test_destruction.hpp
+++ b/test/test_destruction.hpp
@@ -7,6 +7,7 @@
 #ifndef TEST_DESTRUCTION_HPP
 #define TEST_DESTRUCTION_HPP
 
+#include <boost/concept/assert.hpp>
 #include <utility>
 
 /** @name Destroy Graph
@@ -36,7 +37,7 @@ template <typename Graph, typename VertexSet>
 void destroy_graph(Graph& g, VertexSet const&, boost::mpl::false_, boost::mpl::true_) {
     using namespace boost;
     BOOST_CONCEPT_ASSERT((VertexListGraphConcept<Graph>));
-    // function_requires< VeretexMutableGraphConcept<Graph> >();
+    // BOOST_CONCEPT_ASSERT(( VeretexMutableGraphConcept<Graph> ));
 
     std::cout << "...destroy_labeled\n";
     // Remove the roof vertex
diff --git a/test/test_direction.hpp b/test/test_direction.hpp
index b2774b1af..1084c06b9 100644
--- a/test/test_direction.hpp
+++ b/test/test_direction.hpp
@@ -9,6 +9,7 @@
 
 #include <algorithm>
 #include <boost/range.hpp>
+#include <boost/concept/assert.hpp>
 
 /** @name Test Out-Directed Graph
  * Test all graphs that have directed out edges.
diff --git a/test/test_graph.hpp b/test/test_graph.hpp
index 481008b1a..f12230426 100644
--- a/test/test_graph.hpp
+++ b/test/test_graph.hpp
@@ -20,6 +20,7 @@
 #include <utility>
 #include <vector>
 #include <boost/assert.hpp>
+#include <boost/concept/assert.hpp>
 #include <boost/graph/graph_concepts.hpp>
 #include <boost/graph/graph_traits.hpp>
 #include <boost/graph/graph_mutability_traits.hpp>
diff --git a/test/test_iteration.hpp b/test/test_iteration.hpp
index ce48e0d73..7842dd39c 100644
--- a/test/test_iteration.hpp
+++ b/test/test_iteration.hpp
@@ -7,6 +7,7 @@
 #ifndef TEST_ITERATION_HPP
 #define TEST_ITERATION_HPP
 
+#include <boost/concept/assert.hpp>
 #include <algorithm>
 
 /** @name Test Vertex List
diff --git a/test/test_properties.hpp b/test/test_properties.hpp
index 9c3d49796..2d71b9b28 100644
--- a/test/test_properties.hpp
+++ b/test/test_properties.hpp
@@ -7,6 +7,8 @@
 #ifndef TEST_PROPERTIES_HPP
 #define TEST_PROPERTIES_HPP
 
+#include <boost/concept/assert.hpp>
+
 template<typename T> T const& as_const(T& x) { return x; }
 template<typename T> void ignore(T const&) { }
 
@@ -15,9 +17,6 @@ void test_graph_bundle(Graph& g, boost::mpl::true_) {
   using namespace boost;
   std::cout << "...test_graph_bundle\n";
 
-  typedef typename graph_property_type<Graph>::type Property;
-  typedef typename graph_bundle_type<Graph>::type Bundle;
-
   GraphBundle& b1 = g[graph_bundle];
   GraphBundle& b2 = get_property(g);
   ignore(b1); ignore(b2);
diff --git a/test/tiernan_all_cycles.cpp b/test/tiernan_all_cycles.cpp
index 39f8af84e..0e77c784c 100644
--- a/test/tiernan_all_cycles.cpp
+++ b/test/tiernan_all_cycles.cpp
@@ -27,8 +27,6 @@ struct cycle_validator
     void cycle(const Path& p, const Graph& g)
     {
         ++cycles;
-        typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
-        typedef typename graph_traits<Graph>::edge_descriptor Edge;
         // Check to make sure that each of the vertices in the path
         // is truly connected and that the back is connected to the
         // front - it's not validating that we find all paths, just
diff --git a/test/transitive_closure_test.cpp b/test/transitive_closure_test.cpp
index 16ec350f8..cdae591dc 100644
--- a/test/transitive_closure_test.cpp
+++ b/test/transitive_closure_test.cpp
@@ -74,7 +74,7 @@ bool check_transitive_closure(Graph& g, GraphTC& tc)
           typename graph_traits<Graph>::adjacency_iterator k, k_end;
           for (boost::tie(k, k_end) = adjacent_vertices(*i, g); k != k_end; ++k) {
             std::vector<default_color_type> color_map_vec(num_vertices(g));
-            if (is_reachable(*k, *i, g, &color_map_vec[0])) {
+            if (is_reachable(*k, *i, g, boost::make_iterator_property_map(color_map_vec.begin(), get(boost::vertex_index, g)))) {
               can_reach = true;
               break;
             }
@@ -93,7 +93,7 @@ bool check_transitive_closure(Graph& g, GraphTC& tc)
         }
       } else {
         std::vector<default_color_type> color_map_vec(num_vertices(g));
-        if (is_reachable(*i, *j, g, &color_map_vec[0])) {
+        if (is_reachable(*i, *j, g, boost::make_iterator_property_map(color_map_vec.begin(), get(boost::vertex_index, g)))) {
           if (num_tc != 1)
             return false;
         } else {
@@ -117,16 +117,16 @@ bool test(int n, double p)
   {
     progress_timer t;
     cout << "transitive_closure" << endl;
-    transitive_closure(g1, g1_tc, vertex_index_map(identity_property_map()));
+    transitive_closure(g1, g1_tc, vertex_index_map(get(boost::vertex_index, g1)));
   }
 
   if(check_transitive_closure(g1, g1_tc))
     return true;
   else {
     cout << "Original graph was ";
-    print_graph(g1, identity_property_map());
+    print_graph(g1, get(boost::vertex_index, g1));
     cout << "Result is ";
-    print_graph(g1_tc, identity_property_map());
+    print_graph(g1_tc, get(boost::vertex_index, g1_tc));
     return false;
   }
 }
diff --git a/test/transitive_closure_test2.cpp b/test/transitive_closure_test2.cpp
index 1dde3e449..02d38f36e 100644
--- a/test/transitive_closure_test2.cpp
+++ b/test/transitive_closure_test2.cpp
@@ -29,7 +29,7 @@ int main(int argc, char *argv[]) {
        << endl;
   cout << "transitive closure: ";
   graph_t::edge_iterator i,iend;
-  for(tie(i,iend) = edges(g_TC);i!=iend;++i) {
+  for(boost::tie(i,iend) = edges(g_TC);i!=iend;++i) {
     cout << source(*i,g_TC) << "->" << target(*i,g_TC) << " ";
   }
   cout << endl;
diff --git a/test/two_graphs_common_spanning_trees_test.cpp b/test/two_graphs_common_spanning_trees_test.cpp
new file mode 100644
index 000000000..741845a39
--- /dev/null
+++ b/test/two_graphs_common_spanning_trees_test.cpp
@@ -0,0 +1,148 @@
+//          Copyright (C) 2012, Michele Caini.
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+
+//          Two Graphs Common Spanning Trees Algorithm
+//      Based on academic article of Mint, Read and Tarjan
+//     Efficient Algorithm for Common Spanning Tree Problem
+// Electron. Lett., 28 April 1983, Volume 19, Issue 9, p.346-347
+
+
+#include <boost/type_traits.hpp>
+#include <boost/concept/requires.hpp>
+#include <boost/assign/std/vector.hpp>
+#include <boost/graph/adjacency_list.hpp>
+#include <boost/compressed_pair.hpp>
+#include <boost/test/minimal.hpp>
+#include <boost/graph/two_graphs_common_spanning_trees.hpp>
+#include <vector>
+
+using namespace boost::assign;
+
+
+namespace boost
+{
+
+
+typedef
+boost::adjacency_list
+  <
+    boost::vecS,         // OutEdgeList
+    boost::vecS,         // VertexList
+    boost::undirectedS,  // Directed
+    boost::no_property,  // VertexProperties
+    boost::no_property,  // EdgeProperties
+    boost::no_property,  // GraphProperties
+    boost::listS         // EdgeList
+  >
+Graph
+;
+
+typedef
+boost::graph_traits<Graph>::vertex_descriptor
+vertex_descriptor;
+
+typedef
+boost::graph_traits<Graph>::edge_descriptor
+edge_descriptor;
+
+typedef
+boost::graph_traits<Graph>::vertex_iterator
+vertex_iterator;
+
+typedef
+boost::graph_traits<Graph>::edge_iterator
+edge_iterator;
+
+
+template < typename Coll, typename Seq >
+struct check_edge
+{
+public:
+  BOOST_CONCEPT_ASSERT((RandomAccessContainer<Coll>));
+  BOOST_CONCEPT_ASSERT((RandomAccessContainer<Seq>));
+
+  typedef typename Coll::value_type coll_value_type;
+  typedef typename Seq::value_type seq_value_type;
+
+  BOOST_STATIC_ASSERT((is_same<coll_value_type, Seq>::value));
+  BOOST_STATIC_ASSERT((is_same<seq_value_type, bool>::value));
+
+  void operator()(Coll& coll, Seq& seq)
+  {
+    bool found = false;
+
+    for(typename Coll::iterator iterator = coll.begin();
+        !found && iterator != coll.end(); ++iterator)
+    {
+      Seq& coll_seq = *iterator;
+
+      BOOST_REQUIRE(coll_seq.size() == seq.size());
+
+      found = true;
+      for(typename Seq::size_type pos = 0; found && pos < seq.size(); ++pos) {
+        found &= coll_seq[pos] == seq[pos];
+      }
+    }
+
+    BOOST_REQUIRE(found);
+  }
+};
+
+
+void two_graphs_common_spanning_trees_test()
+{
+  Graph iG, vG;
+  std::vector< edge_descriptor > iG_o;
+  std::vector< edge_descriptor > vG_o;
+
+  iG_o.push_back(boost::add_edge(0, 1, iG).first);
+  iG_o.push_back(boost::add_edge(1, 3, iG).first);
+  iG_o.push_back(boost::add_edge(3, 2, iG).first);
+  iG_o.push_back(boost::add_edge(1, 5, iG).first);
+  iG_o.push_back(boost::add_edge(5, 4, iG).first);
+  iG_o.push_back(boost::add_edge(5, 6, iG).first);
+  iG_o.push_back(boost::add_edge(5, 3, iG).first);
+  iG_o.push_back(boost::add_edge(3, 1, iG).first);
+  iG_o.push_back(boost::add_edge(1, 3, iG).first);
+
+  vG_o.push_back(boost::add_edge(0, 2, vG).first);
+  vG_o.push_back(boost::add_edge(0, 4, vG).first);
+  vG_o.push_back(boost::add_edge(0, 5, vG).first);
+  vG_o.push_back(boost::add_edge(5, 1, vG).first);
+  vG_o.push_back(boost::add_edge(5, 3, vG).first);
+  vG_o.push_back(boost::add_edge(5, 6, vG).first);
+  vG_o.push_back(boost::add_edge(5, 4, vG).first);
+  vG_o.push_back(boost::add_edge(5, 2, vG).first);
+  vG_o.push_back(boost::add_edge(2, 6, vG).first);
+
+  std::vector< std::vector<bool> > coll;
+  boost::tree_collector<
+      std::vector< std::vector<bool> >, std::vector<bool>
+    > collector(coll);
+  std::vector<bool> inL(iG_o.size(), false);
+
+  boost::two_graphs_common_spanning_trees(iG, iG_o, vG, vG_o, collector, inL);
+
+  check_edge< std::vector< std::vector<bool> >, std::vector<bool> > checker;
+  std::vector<bool> check;
+
+  check.clear();
+  check += true, true, true, true, true, true, false, false, false;
+  checker(coll, check);
+
+  check.clear();
+  check += true, true, true, true, true, true, false, false, false;
+  checker(coll, check);
+}
+
+
+}
+
+
+int test_main ( int argc, char** argv )
+{
+  boost::two_graphs_common_spanning_trees_test();
+  return EXIT_SUCCESS;
+}
diff --git a/test/undirected_dfs.cpp b/test/undirected_dfs.cpp
new file mode 100644
index 000000000..74e7d3884
--- /dev/null
+++ b/test/undirected_dfs.cpp
@@ -0,0 +1,202 @@
+//=======================================================================
+// Copyright 2001 University of Notre Dame.
+// Author: Jeremy G. Siek
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//=======================================================================
+
+#include <boost/config.hpp>
+#include <boost/test/minimal.hpp>
+#include <stdlib.h>
+
+#include <boost/graph/undirected_dfs.hpp>
+#include <boost/graph/adjacency_list.hpp>
+#include <boost/graph/graph_archetypes.hpp>
+#include <boost/graph/graph_utility.hpp>
+#include <boost/graph/random.hpp>
+
+#include <boost/random/mersenne_twister.hpp>
+
+template <typename ColorMap, typename ParentMap,
+  typename DiscoverTimeMap, typename FinishTimeMap>
+class dfs_test_visitor {
+  typedef typename boost::property_traits<ColorMap>::value_type ColorValue;
+  typedef typename boost::color_traits<ColorValue> Color;
+public:
+  dfs_test_visitor(ColorMap color, ParentMap p, DiscoverTimeMap d,
+                   FinishTimeMap f)
+    : m_color(color), m_parent(p),
+    m_discover_time(d), m_finish_time(f), m_time(0) { }
+
+  template <class Vertex, class Graph>
+  void initialize_vertex(Vertex u, Graph&) {
+    BOOST_CHECK( boost::get(m_color, u) == Color::white() );
+  }
+  template <class Vertex, class Graph>
+  void start_vertex(Vertex u, Graph&) {
+    BOOST_CHECK( boost::get(m_color, u) == Color::white() );
+  }
+  template <class Vertex, class Graph>
+  void discover_vertex(Vertex u, Graph&) {
+    using namespace boost;
+    BOOST_CHECK( get(m_color, u) == Color::gray() );
+    BOOST_CHECK( get(m_color, get(m_parent, u)) == Color::gray() );
+
+    put(m_discover_time, u, m_time++);
+  }
+  template <class Edge, class Graph>
+  void examine_edge(Edge e, Graph& g) {
+    using namespace boost;
+    BOOST_CHECK( get(m_color, source(e, g)) == Color::gray() );
+  }
+  template <class Edge, class Graph>
+  void tree_edge(Edge e, Graph& g) {
+    using namespace boost;
+    BOOST_CHECK( get(m_color, target(e, g)) == Color::white() );
+
+    put(m_parent, target(e, g), source(e, g));
+  }
+  template <class Edge, class Graph>
+  void back_edge(Edge e, Graph& g) {
+    using namespace boost;
+    BOOST_CHECK( get(m_color, target(e, g)) == Color::gray() );
+  }
+  template <class Edge, class Graph>
+  void forward_or_cross_edge(Edge e, Graph& g) {
+    using namespace boost;
+    BOOST_CHECK( get(m_color, target(e, g)) == Color::black() );
+  }
+  template <class Edge, class Graph>
+  void finish_edge(Edge e, Graph& g) {
+    using namespace boost;
+    BOOST_CHECK(
+        (get(m_color, target(e, g)) == Color::gray())
+     || (get(m_color, target(e, g)) == Color::black())
+    );
+  }
+  template <class Vertex, class Graph>
+  void finish_vertex(Vertex u, Graph&) {
+    using namespace boost;
+    BOOST_CHECK( get(m_color, u) == Color::black() );
+
+    put(m_finish_time, u, m_time++);
+  }
+private:
+  ColorMap m_color;
+  ParentMap m_parent;
+  DiscoverTimeMap m_discover_time;
+  FinishTimeMap m_finish_time;
+  typename boost::property_traits<DiscoverTimeMap>::value_type m_time;
+};
+
+template <typename Graph>
+struct dfs_test
+{
+  typedef boost::graph_traits<Graph> Traits;
+  typedef typename Traits::vertices_size_type
+    vertices_size_type;
+
+  static void go(vertices_size_type max_V) {
+    using namespace boost;
+    typedef typename Traits::vertex_descriptor vertex_descriptor;
+    typedef typename boost::property_map<Graph,
+      boost::vertex_color_t>::type ColorMap;
+    typedef typename boost::property_traits<ColorMap>::value_type ColorValue;
+    typedef typename boost::color_traits<ColorValue> Color;
+    typedef typename boost::property_map<Graph,
+      boost::edge_color_t>::type EColorMap;
+    typedef typename boost::property_traits<EColorMap>::value_type EColorValue;
+    typedef typename boost::color_traits<EColorValue> EColor;
+
+    vertices_size_type i, k;
+    typename Traits::edges_size_type j;
+    typename Traits::vertex_iterator vi, vi_end, ui, ui_end;
+    typename Traits::edge_iterator ei, ei_end;
+
+    boost::mt19937 gen;
+
+    for (i = 0; i < max_V; ++i)
+      for (j = 0; j < i*i; ++j) {
+        Graph g;
+        generate_random_graph(g, i, j, gen);
+
+        ColorMap color = get(boost::vertex_color, g);
+        EColorMap e_color = get(boost::edge_color, g);
+        std::vector<vertex_descriptor> parent(num_vertices(g));
+        for (k = 0; k < num_vertices(g); ++k)
+          parent[k] = k;
+        std::vector<int> discover_time(num_vertices(g)),
+          finish_time(num_vertices(g));
+
+        // Get vertex index map
+        typedef typename boost::property_map<Graph, boost::vertex_index_t>::const_type idx_type;
+        idx_type idx = get(boost::vertex_index, g);
+        
+        typedef
+          boost::iterator_property_map<typename std::vector<vertex_descriptor>::iterator, idx_type>
+          parent_pm_type;
+        parent_pm_type parent_pm(parent.begin(), idx);
+        typedef
+          boost::iterator_property_map<std::vector<int>::iterator, idx_type>
+          time_pm_type;
+        time_pm_type discover_time_pm(discover_time.begin(), idx);
+        time_pm_type finish_time_pm(finish_time.begin(), idx);
+
+        dfs_test_visitor<ColorMap, parent_pm_type,
+          time_pm_type, time_pm_type>
+          vis(color, parent_pm,
+              discover_time_pm, finish_time_pm);
+
+        boost::undirected_dfs(g, visitor(vis).color_map(color)
+                              .edge_color_map(e_color));
+
+        // all vertices should be black
+        for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi)
+          BOOST_CHECK(get(color, *vi) == Color::black());
+
+        // all edges should be black
+        for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei)
+          BOOST_CHECK(get(e_color, *ei) == EColor::black());
+
+        // check parenthesis structure of discover/finish times
+        // See CLR p.480
+        for (boost::tie(ui, ui_end) = vertices(g); ui != ui_end; ++ui)
+          for (boost::tie(vi, vi_end) = vertices(g); vi != vi_end; ++vi) {
+            vertex_descriptor u = *ui, v = *vi;
+            if (u != v) {
+              BOOST_CHECK( finish_time[u] < discover_time[v]
+                          || finish_time[v] < discover_time[u]
+                          || (discover_time[v] < discover_time[u]
+                               && finish_time[u] < finish_time[v]
+                               && boost::is_descendant(u, v, parent_pm))
+                          || (discover_time[u] < discover_time[v]
+                               && finish_time[v] < finish_time[u]
+                               && boost::is_descendant(v, u, parent_pm))
+                        );
+            }
+          }
+      }
+
+  }
+};
+
+
+// usage: undirected_dfs.exe [max-vertices=15]
+
+int test_main(int argc, char* argv[])
+{
+  int max_V = 7;
+  if (argc > 1)
+    max_V = atoi(argv[1]);
+
+  // Test undirected graphs.
+  dfs_test< boost::adjacency_list<boost::vecS, boost::vecS, boost::undirectedS,
+           boost::property<boost::vertex_color_t, boost::default_color_type>,
+           boost::property<boost::edge_color_t, boost::default_color_type> >
+    >::go(max_V);
+
+  return 0;
+}
+
diff --git a/test/vector_graph_cc.cpp b/test/vector_graph_cc.cpp
index 7f7c5ebdb..f9b1cfac5 100644
--- a/test/vector_graph_cc.cpp
+++ b/test/vector_graph_cc.cpp
@@ -7,6 +7,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 //=======================================================================
 #include <boost/config.hpp>
+#include <boost/concept/assert.hpp>
 #include <vector>
 #include <list>
 
@@ -24,9 +25,9 @@ int main(int,char*[])
   // Check "vector as graph"
   {
     typedef std::vector< std::list<int> > Graph;
-    function_requires< VertexListGraphConcept<Graph> >();
-    function_requires< IncidenceGraphConcept<Graph> >();
-    function_requires< AdjacencyGraphConcept<Graph> >();
+    BOOST_CONCEPT_ASSERT(( VertexListGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( IncidenceGraphConcept<Graph> ));
+    BOOST_CONCEPT_ASSERT(( AdjacencyGraphConcept<Graph> ));
   }
   return 0;
 }
diff --git a/test/vf2_sub_graph_iso_test.cpp b/test/vf2_sub_graph_iso_test.cpp
new file mode 100644
index 000000000..21ef97ee1
--- /dev/null
+++ b/test/vf2_sub_graph_iso_test.cpp
@@ -0,0 +1,296 @@
+//=======================================================================
+// Boost.Graph library vf2_sub_graph_iso test
+// Adapted from isomorphism.cpp and mcgregor_subgraphs_test.cpp
+//
+// Copyright (C) 2012 Flavio De Lorenzi (fdlorenzi@gmail.com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//=======================================================================
+
+// Revision History:
+//   8 April 2013: Fixed a typo in random_functor. (Flavio De Lorenzi) 
+
+#include <iostream>
+#include <fstream>
+#include <map>
+#include <algorithm>
+#include <cstdlib>
+#include <time.h> 
+#include <boost/test/minimal.hpp>
+#include <boost/graph/adjacency_list.hpp>
+#include <boost/graph/vf2_sub_graph_iso.hpp>
+#include <boost/graph/random.hpp>
+#include <boost/property_map/property_map.hpp>
+#include <boost/random.hpp>
+#include <boost/random/variate_generator.hpp>
+#include <boost/random/uniform_real.hpp>
+#include <boost/random/uniform_int.hpp>
+#include <boost/random/mersenne_twister.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/graph/graphviz.hpp>
+
+using namespace boost;
+
+
+template <typename Generator>
+struct random_functor {
+  random_functor(Generator& g) : g(g) { }
+  std::size_t operator()(std::size_t n) {
+    boost::uniform_int<std::size_t> distrib(0, n-1);
+    boost::variate_generator<Generator&, boost::uniform_int<std::size_t> >
+      x(g, distrib);
+    return x();
+  }
+  Generator& g;
+};
+
+
+template<typename Graph1, typename Graph2>
+void randomly_permute_graph(Graph1& g1, const Graph2& g2) {
+  BOOST_REQUIRE(num_vertices(g1) <= num_vertices(g2));
+  BOOST_REQUIRE(num_edges(g1) == 0);
+  
+  typedef typename graph_traits<Graph1>::vertex_descriptor vertex1;
+  typedef typename graph_traits<Graph2>::vertex_descriptor vertex2;
+  typedef typename graph_traits<Graph1>::vertex_iterator vertex_iterator;
+  typedef typename graph_traits<Graph2>::edge_iterator edge_iterator;
+  
+  boost::mt19937 gen;
+  random_functor<boost::mt19937> rand_fun(gen);
+  
+  // Decide new order
+  std::vector<vertex2> orig_vertices;
+  std::copy(vertices(g2).first, vertices(g2).second, std::back_inserter(orig_vertices));
+  std::random_shuffle(orig_vertices.begin(), orig_vertices.end(), rand_fun);
+  std::map<vertex2, vertex1> vertex_map;
+  
+  std::size_t i = 0;
+  for (vertex_iterator vi = vertices(g1).first; 
+       vi != vertices(g1).second; ++i, ++vi) {
+    vertex_map[orig_vertices[i]] = *vi;
+    put(vertex_name_t(), g1, *vi, get(vertex_name_t(), g2, orig_vertices[i]));
+  }
+
+  for (edge_iterator ei = edges(g2).first; ei != edges(g2).second; ++ei) {
+    typename std::map<vertex2, vertex1>::iterator si = vertex_map.find(source(*ei, g2)),
+      ti = vertex_map.find(target(*ei, g2));
+    if ((si != vertex_map.end()) && (ti != vertex_map.end()))
+      add_edge(si->second, ti->second, get(edge_name_t(), g2, *ei), g1);
+  }
+}
+
+
+template<typename Graph>
+void generate_random_digraph(Graph& g, double edge_probability, 
+                             int max_parallel_edges, double parallel_edge_probability,
+                             int max_edge_name, int max_vertex_name) {
+
+  BOOST_REQUIRE((0 <= edge_probability) && (edge_probability <= 1));
+  BOOST_REQUIRE((0 <= parallel_edge_probability) && (parallel_edge_probability <= 1));
+  BOOST_REQUIRE(0 <= max_parallel_edges);
+  BOOST_REQUIRE(0 <= max_edge_name);
+  BOOST_REQUIRE(0 <= max_vertex_name);
+
+  typedef typename graph_traits<Graph>::vertex_iterator vertex_iterator;
+  boost::mt19937 random_gen;
+  boost::uniform_real<double> dist_real(0.0, 1.0);
+  boost::variate_generator<boost::mt19937&, boost::uniform_real<double> >
+    random_real_dist(random_gen, dist_real);
+
+  for (vertex_iterator u = vertices(g).first; u != vertices(g).second; ++u) {
+    for (vertex_iterator v = vertices(g).first; v != vertices(g).second; ++v) {
+      if (random_real_dist() <= edge_probability) {
+        add_edge(*u, *v, g);
+        for (int i = 0; i < max_parallel_edges; ++i) {
+          if (random_real_dist() <= parallel_edge_probability)
+            add_edge(*u, *v, g);
+        }
+      }
+    }
+  }
+  
+  {
+    boost::uniform_int<int> dist_int(0, max_edge_name);
+    boost::variate_generator<boost::mt19937&, boost::uniform_int<int> >
+      random_int_dist(random_gen, dist_int);
+    randomize_property<vertex_name_t>(g, random_int_dist);
+  }
+
+  {
+    boost::uniform_int<int> dist_int(0, max_vertex_name);
+    boost::variate_generator<boost::mt19937&, boost::uniform_int<int> >
+      random_int_dist(random_gen, dist_int);
+    
+    randomize_property<edge_name_t>(g, random_int_dist);
+  }
+
+}
+
+
+template <typename Graph1,
+          typename Graph2,
+          typename EdgeEquivalencePredicate,
+          typename VertexEquivalencePredicate>
+struct test_callback {
+  
+  test_callback(const Graph1& graph1, const Graph2& graph2, 
+                EdgeEquivalencePredicate edge_comp, 
+                VertexEquivalencePredicate vertex_comp, bool output) 
+    : graph1_(graph1), graph2_(graph2), edge_comp_(edge_comp), vertex_comp_(vertex_comp),
+      output_(output) {}
+  
+  template <typename CorrespondenceMap1To2,
+            typename CorrespondenceMap2To1>
+  bool operator()(CorrespondenceMap1To2 f, CorrespondenceMap2To1) {
+    
+    bool verified;
+    BOOST_CHECK(verified = verify_vf2_subgraph_iso(graph1_, graph2_, f, edge_comp_, vertex_comp_));
+  
+    // Output (sub)graph isomorphism map
+    if (!verified || output_) {
+      std::cout << "Verfied: " << std::boolalpha << verified << std::endl;
+      std::cout << "Num vertices: " << num_vertices(graph1_) << ' ' << num_vertices(graph2_) << std::endl;
+      BGL_FORALL_VERTICES_T(v, graph1_, Graph1) 
+        std::cout << '(' << get(vertex_index_t(), graph1_, v) << ", " 
+                  << get(vertex_index_t(), graph2_, get(f, v)) << ") ";
+    
+      std::cout << std::endl;
+    }
+    
+    return true;
+  }
+ 
+private:
+  const Graph1& graph1_;
+  const Graph2& graph2_;
+  EdgeEquivalencePredicate edge_comp_;
+  VertexEquivalencePredicate vertex_comp_;
+  bool output_;
+};
+
+
+void test_vf2_sub_graph_iso(int n1, int n2, double edge_probability, 
+                            int max_parallel_edges, double parallel_edge_probability,
+                            int max_edge_name, int max_vertex_name, bool output) {
+
+  typedef property<edge_name_t, int> edge_property;
+  typedef property<vertex_name_t, int, property<vertex_index_t, int> > vertex_property;
+  
+  typedef adjacency_list<listS, listS, bidirectionalS, vertex_property, edge_property> graph1;
+  typedef adjacency_list<vecS, vecS, bidirectionalS, vertex_property, edge_property> graph2;
+  
+  graph1 g1(n1);
+  graph2 g2(n2);
+  generate_random_digraph(g2, edge_probability, max_parallel_edges, parallel_edge_probability,
+                          max_edge_name, max_vertex_name);
+  randomly_permute_graph(g1, g2);
+
+  int v_idx = 0;
+  for (graph_traits<graph1>::vertex_iterator vi = vertices(g1).first;
+       vi != vertices(g1).second; ++vi) {
+    put(vertex_index_t(), g1, *vi, v_idx++);
+  }
+
+
+  // Create vertex and edge predicates
+  typedef property_map<graph1, vertex_name_t>::type vertex_name_map1;
+  typedef property_map<graph2, vertex_name_t>::type vertex_name_map2;
+  
+  typedef property_map_equivalent<vertex_name_map1, vertex_name_map2> vertex_predicate;
+  vertex_predicate vertex_comp =
+    make_property_map_equivalent(get(vertex_name, g1), get(vertex_name, g2));
+  
+  typedef property_map<graph1, edge_name_t>::type edge_name_map1;
+  typedef property_map<graph2, edge_name_t>::type edge_name_map2;
+  
+  typedef property_map_equivalent<edge_name_map1, edge_name_map2> edge_predicate;
+  edge_predicate edge_comp =
+    make_property_map_equivalent(get(edge_name, g1), get(edge_name, g2));
+  
+  
+  std::clock_t start = std::clock();
+  
+  // Create callback
+  test_callback<graph1, graph2, edge_predicate, vertex_predicate> 
+    callback(g1, g2, edge_comp, vertex_comp, output);
+
+  std::cout << std::endl;
+  BOOST_CHECK(vf2_subgraph_iso(g1, g2, callback, vertex_order_by_mult(g1),
+                               edges_equivalent(edge_comp).vertices_equivalent(vertex_comp)));
+
+  std::clock_t end1 = std::clock();
+  std::cout << "vf2_subgraph_iso: elapsed time (clock cycles): " << (end1 - start) << std::endl;
+
+  if (num_vertices(g1) == num_vertices(g2)) {
+    std::cout << std::endl;
+    BOOST_CHECK(vf2_graph_iso(g1, g2, callback, vertex_order_by_mult(g1),
+                              edges_equivalent(edge_comp).vertices_equivalent(vertex_comp)));
+    
+    std::clock_t end2 = std::clock();
+    std::cout << "vf2_graph_iso: elapsed time (clock cycles): " << (end2 - end1) << std::endl;
+  }
+  
+  if (output) {
+    std::fstream file_graph1("graph1.dot", std::fstream::out);
+    write_graphviz(file_graph1, g1,
+                   make_label_writer(get(boost::vertex_name, g1)),
+                   make_label_writer(get(boost::edge_name, g1)));
+    
+    std::fstream file_graph2("graph2.dot", std::fstream::out);
+    write_graphviz(file_graph2, g2,
+                   make_label_writer(get(boost::vertex_name, g2)),
+                   make_label_writer(get(boost::edge_name, g2)));
+  }
+}
+
+int test_main(int argc, char* argv[]) {
+
+  int num_vertices_g1 = 10;
+  int num_vertices_g2 = 20;
+  double edge_probability = 0.4;
+  int max_parallel_edges = 2;
+  double parallel_edge_probability = 0.4;
+  int max_edge_name = 5;
+  int max_vertex_name = 5;
+  bool output = false;
+  
+  if (argc > 1) {
+    num_vertices_g1 = boost::lexical_cast<int>(argv[1]);
+  }
+  
+  if (argc > 2) {
+    num_vertices_g2 = boost::lexical_cast<int>(argv[2]);
+  }
+  
+  if (argc > 3) {
+    edge_probability = boost::lexical_cast<double>(argv[3]);
+  }
+  
+  if (argc > 4) {
+    max_parallel_edges = boost::lexical_cast<int>(argv[4]);
+  }
+  
+  if (argc > 5) {
+    parallel_edge_probability = boost::lexical_cast<double>(argv[5]);
+  }
+  
+  if (argc > 6) {
+    max_edge_name = boost::lexical_cast<int>(argv[6]);
+  }
+  
+  if (argc > 7) {
+    max_vertex_name = boost::lexical_cast<int>(argv[7]);
+  }
+  
+  if (argc > 8) {
+    output = boost::lexical_cast<bool>(argv[8]);
+  }
+
+  test_vf2_sub_graph_iso(num_vertices_g1, num_vertices_g2, edge_probability, 
+                         max_parallel_edges, parallel_edge_probability, 
+                         max_edge_name, max_vertex_name, output);
+  
+  return 0;
+}
diff --git a/test/vf2_sub_graph_iso_test_2.cpp b/test/vf2_sub_graph_iso_test_2.cpp
new file mode 100644
index 000000000..c5c7664ae
--- /dev/null
+++ b/test/vf2_sub_graph_iso_test_2.cpp
@@ -0,0 +1,194 @@
+//=======================================================================
+// Boost.Graph library vf2_sub_graph_iso test 2
+// Test of return value and behaviour with empty graphs
+//
+// Copyright (C) 2013 Jakob Lykke Andersen, University of Southern Denmark (jlandersen@imada.sdu.dk)
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//=======================================================================
+
+#include <iostream>
+#include <boost/test/minimal.hpp>
+#include <boost/graph/adjacency_list.hpp>
+#include <boost/graph/vf2_sub_graph_iso.hpp>
+
+struct test_callback {
+  test_callback(bool &got_hit, bool stop) : got_hit(got_hit), stop(stop) { }
+
+  template<typename Map1To2, typename Map2To1>
+  bool operator()(Map1To2 map1to2, Map2To1 map2to1) {
+    got_hit = true;
+    return stop;
+  }
+
+  bool &got_hit;
+  bool stop;
+};
+
+struct false_predicate {
+  template<typename VertexOrEdge1, typename VertexOrEdge2>
+  bool operator()(VertexOrEdge1 ve1, VertexOrEdge2 ve2) const {
+    return false;
+  }
+};
+
+void test_empty_graph_cases() {
+  typedef boost::adjacency_list<boost::vecS, boost::vecS, boost::bidirectionalS> Graph;
+  Graph gEmpty, gLarge;
+  add_vertex(gLarge);
+
+  { // isomorphism
+    bool got_hit = false;
+    test_callback callback(got_hit, true);
+    bool exists = vf2_graph_iso(gEmpty, gEmpty, callback);
+    BOOST_CHECK(exists);
+    BOOST_CHECK(got_hit); // even empty matches are reported
+  }
+  { // subgraph isomorphism (induced)
+    { // empty vs. empty
+      bool got_hit = false;
+      test_callback callback(got_hit, true);
+      bool exists = vf2_subgraph_iso(gEmpty, gEmpty, callback);
+      BOOST_CHECK(exists);
+      BOOST_CHECK(got_hit); // even empty matches are reported
+    }
+    { // empty vs. non-empty
+      bool got_hit = false;
+      test_callback callback(got_hit, true);
+      bool exists = vf2_subgraph_iso(gEmpty, gLarge, callback);
+      BOOST_CHECK(exists);
+      BOOST_CHECK(got_hit); // even empty matches are reported
+    }
+  }
+  { // subgraph monomorphism (non-induced subgraph isomorphism)
+    { // empty vs. empty
+      bool got_hit = false;
+      test_callback callback(got_hit, true);
+      bool exists = vf2_subgraph_mono(gEmpty, gEmpty, callback);
+      BOOST_CHECK(exists);
+      BOOST_CHECK(got_hit); // even empty matches are reported
+    }
+    { // empty vs. non-empty
+      bool got_hit = false;
+      test_callback callback(got_hit, true);
+      bool exists = vf2_subgraph_mono(gEmpty, gLarge, callback);
+      BOOST_CHECK(exists);
+      BOOST_CHECK(got_hit); // even empty matches are reported
+    }
+  }
+}
+
+void test_return_value() {
+  typedef boost::adjacency_list<boost::vecS, boost::vecS, boost::bidirectionalS> Graph;
+  typedef boost::graph_traits<Graph>::vertex_descriptor Vertex;
+  Graph gSmall, gLarge;
+  add_vertex(gSmall);
+  Vertex v1 = add_vertex(gLarge);
+  Vertex v2 = add_vertex(gLarge);
+  add_edge(v1, v2, gLarge);
+
+  { // isomorphism
+    { // no morphism due to sizes
+      bool got_hit = false;
+      test_callback callback(got_hit, true);
+      bool exists = vf2_graph_iso(gSmall, gLarge, callback);
+      BOOST_CHECK(!exists);
+      BOOST_CHECK(!got_hit);
+    }
+    { // no morphism due to vertex mismatches
+      bool got_hit = false;
+      test_callback callback(got_hit, true);
+      false_predicate pred;
+      bool exists = vf2_graph_iso(gLarge, gLarge, callback, vertex_order_by_mult(gLarge),
+                                  boost::edges_equivalent(pred).vertices_equivalent(pred));
+      BOOST_CHECK(!exists);
+      BOOST_CHECK(!got_hit);
+    }
+    { // morphism, find all
+      bool got_hit = false;
+      test_callback callback(got_hit, false);
+      bool exists = vf2_graph_iso(gLarge, gLarge, callback);
+      BOOST_CHECK(exists);
+      BOOST_CHECK(got_hit);
+    }
+    { // morphism, stop after first hit
+      bool got_hit = false;
+      test_callback callback(got_hit, true);
+      bool exists = vf2_graph_iso(gLarge, gLarge, callback);
+      BOOST_CHECK(exists);
+      BOOST_CHECK(got_hit);
+    }
+  }
+  { // subgraph isomorphism (induced)
+    { // no morphism due to sizes
+      bool got_hit = false;
+      test_callback callback(got_hit, true);
+      bool exists = vf2_subgraph_iso(gLarge, gSmall, callback);
+      BOOST_CHECK(!exists);
+      BOOST_CHECK(!got_hit);
+    }
+    { // no morphism due to vertex mismatches
+      bool got_hit = false;
+      test_callback callback(got_hit, true);
+      false_predicate pred;
+      bool exists = vf2_subgraph_iso(gLarge, gLarge, callback, vertex_order_by_mult(gLarge),
+                                  boost::edges_equivalent(pred).vertices_equivalent(pred));
+      BOOST_CHECK(!exists);
+      BOOST_CHECK(!got_hit);
+    }
+    { // morphism, find all
+      bool got_hit = false;
+      test_callback callback(got_hit, false);
+      bool exists = vf2_subgraph_iso(gLarge, gLarge, callback);
+      BOOST_CHECK(exists);
+      BOOST_CHECK(got_hit);
+    }
+    { // morphism, stop after first hit
+      bool got_hit = false;
+      test_callback callback(got_hit, true);
+      bool exists = vf2_subgraph_iso(gLarge, gLarge, callback);
+      BOOST_CHECK(exists);
+      BOOST_CHECK(got_hit);
+    }
+  }
+  { // subgraph monomorphism (non-induced subgraph isomorphism)
+    { // no morphism due to sizes
+      bool got_hit = false;
+      test_callback callback(got_hit, true);
+      bool exists = vf2_subgraph_mono(gLarge, gSmall, callback);
+      BOOST_CHECK(!exists);
+      BOOST_CHECK(!got_hit);
+    }
+    { // no morphism due to vertex mismatches
+      bool got_hit = false;
+      test_callback callback(got_hit, true);
+      false_predicate pred;
+      bool exists = vf2_subgraph_mono(gLarge, gLarge, callback, vertex_order_by_mult(gLarge),
+                                  boost::edges_equivalent(pred).vertices_equivalent(pred));
+      BOOST_CHECK(!exists);
+      BOOST_CHECK(!got_hit);
+    }
+    { // morphism, find all
+      bool got_hit = false;
+      test_callback callback(got_hit, false);
+      bool exists = vf2_subgraph_mono(gLarge, gLarge, callback);
+      BOOST_CHECK(exists);
+      BOOST_CHECK(got_hit);
+    }
+    { // morphism, stop after first hit
+      bool got_hit = false;
+      test_callback callback(got_hit, true);
+      bool exists = vf2_subgraph_mono(gLarge, gLarge, callback);
+      BOOST_CHECK(exists);
+      BOOST_CHECK(got_hit);
+    }
+  }
+}
+
+int test_main(int argc, char* argv[]) {
+  test_empty_graph_cases();
+  test_return_value();
+  return 0;
+}