Index: boost/graph/chrobak_payne_drawing.hpp
===================================================================
--- boost/graph/chrobak_payne_drawing.hpp	(revision 75419)
+++ boost/graph/chrobak_payne_drawing.hpp	(working copy)
@@ -240,7 +240,7 @@
       (*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];
Index: boost/graph/closeness_centrality.hpp
===================================================================
--- boost/graph/closeness_centrality.hpp	(revision 75419)
+++ boost/graph/closeness_centrality.hpp	(working copy)
@@ -126,7 +126,7 @@
     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);
Index: boost/graph/degree_centrality.hpp
===================================================================
--- boost/graph/degree_centrality.hpp	(revision 75419)
+++ boost/graph/degree_centrality.hpp	(working copy)
@@ -101,7 +101,7 @@
     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);
     }
Index: boost/graph/detail/geodesic.hpp
===================================================================
--- boost/graph/detail/geodesic.hpp	(revision 75419)
+++ boost/graph/detail/geodesic.hpp	(working copy)
@@ -65,7 +65,7 @@
         // 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));
Index: boost/graph/geodesic_distance.hpp
===================================================================
--- boost/graph/geodesic_distance.hpp	(revision 75419)
+++ boost/graph/geodesic_distance.hpp	(working copy)
@@ -156,7 +156,7 @@
     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);
Index: boost/graph/is_kuratowski_subgraph.hpp
===================================================================
--- boost/graph/is_kuratowski_subgraph.hpp	(revision 75419)
+++ boost/graph/is_kuratowski_subgraph.hpp	(working copy)
@@ -33,7 +33,7 @@
     {
       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 +47,7 @@
         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 +158,7 @@
       {
 
         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);
 
@@ -242,7 +242,7 @@
         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 +261,7 @@
     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);
Index: boost/graph/is_straight_line_drawing.hpp
===================================================================
--- boost/graph/is_straight_line_drawing.hpp	(revision 75419)
+++ boost/graph/is_straight_line_drawing.hpp	(working copy)
@@ -126,7 +126,7 @@
     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));
Index: boost/graph/make_maximal_planar.hpp
===================================================================
--- boost/graph/make_maximal_planar.hpp	(revision 75419)
+++ boost/graph/make_maximal_planar.hpp	(working copy)
@@ -62,7 +62,7 @@
       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 @@
 
       // 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
           )
         {
Index: boost/graph/planar_canonical_ordering.hpp
===================================================================
--- boost/graph/planar_canonical_ordering.hpp	(revision 75419)
+++ boost/graph/planar_canonical_ordering.hpp	(working copy)
@@ -67,7 +67,7 @@
     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;
Index: boost/graph/planar_face_traversal.hpp
===================================================================
--- boost/graph/planar_face_traversal.hpp	(revision 75419)
+++ boost/graph/planar_face_traversal.hpp	(working copy)
@@ -98,7 +98,7 @@
     // 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 +122,7 @@
     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);
Index: boost/graph/tiernan_all_cycles.hpp
===================================================================
--- boost/graph/tiernan_all_cycles.hpp	(revision 75419)
+++ boost/graph/tiernan_all_cycles.hpp	(working copy)
@@ -193,7 +193,7 @@
             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;
             }
@@ -220,7 +220,7 @@
 
         // 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,
@@ -324,7 +324,7 @@
     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);
     }
 }
Index: boost/graph/write_dimacs.hpp
===================================================================
--- boost/graph/write_dimacs.hpp	(revision 75419)
+++ boost/graph/write_dimacs.hpp	(working copy)
@@ -64,7 +64,7 @@
   
   //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;
   }
 }
Index: libs/graph/test/all_planar_input_files_test.cpp
===================================================================
--- libs/graph/test/all_planar_input_files_test.cpp	(revision 75419)
+++ libs/graph/test/all_planar_input_files_test.cpp	(working copy)
@@ -137,7 +137,7 @@
   // 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
Index: libs/graph/test/basic_planarity_test.cpp
===================================================================
--- libs/graph/test/basic_planarity_test.cpp	(revision 75419)
+++ libs/graph/test/basic_planarity_test.cpp	(working copy)
@@ -25,7 +25,7 @@
     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++);
   }
 };
Index: libs/graph/test/bellman-test.cpp
===================================================================
--- libs/graph/test/bellman-test.cpp	(revision 75419)
+++ libs/graph/test/bellman-test.cpp	(working copy)
@@ -42,7 +42,7 @@
     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);
Index: libs/graph/test/labeled_graph.cpp
===================================================================
--- libs/graph/test/labeled_graph.cpp	(revision 75419)
+++ libs/graph/test/labeled_graph.cpp	(working copy)
@@ -62,7 +62,7 @@
     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);
     }
 }
Index: libs/graph/test/make_bicon_planar_test.cpp
===================================================================
--- libs/graph/test/make_bicon_planar_test.cpp	(revision 75419)
+++ libs/graph/test/make_bicon_planar_test.cpp	(working copy)
@@ -25,7 +25,7 @@
   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 @@
     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 @@
   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);
Index: libs/graph/test/make_connected_test.cpp
===================================================================
--- libs/graph/test/make_connected_test.cpp	(revision 75419)
+++ libs/graph/test/make_connected_test.cpp	(working copy)
@@ -24,7 +24,7 @@
   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 @@
   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++);
 }
 
Index: libs/graph/test/make_maximal_planar_test.cpp
===================================================================
--- libs/graph/test/make_maximal_planar_test.cpp	(revision 75419)
+++ libs/graph/test/make_maximal_planar_test.cpp	(working copy)
@@ -24,7 +24,7 @@
   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 @@
     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 @@
   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));
Index: libs/graph/test/parallel_edges_loops_test.cpp
===================================================================
--- libs/graph/test/parallel_edges_loops_test.cpp	(revision 75419)
+++ libs/graph/test/parallel_edges_loops_test.cpp	(working copy)
@@ -111,7 +111,7 @@
           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)
                 {
@@ -210,7 +210,7 @@
   // 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
Index: libs/graph/test/test_construction.hpp
===================================================================
--- libs/graph/test/test_construction.hpp	(revision 75419)
+++ libs/graph/test/test_construction.hpp	(working copy)
@@ -93,7 +93,7 @@
 
     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);
     }
Index: libs/graph/test/transitive_closure_test2.cpp
===================================================================
--- libs/graph/test/transitive_closure_test2.cpp	(revision 75419)
+++ libs/graph/test/transitive_closure_test2.cpp	(working copy)
@@ -29,7 +29,7 @@
        << 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;