Index: src/work/athos/bfs_test.cc
===================================================================
--- src/work/athos/bfs_test.cc	(revision 921)
+++ src/work/athos/bfs_test.cc	(revision 986)
@@ -42,5 +42,5 @@
       OutEdgeIt e;
       for(g.first(e,v); g.valid(e); g.next(e)) {
-	Node w=g.head(e);
+	Node w=g.target(e);
 	if (!reached[w]) {
 	  bfs_queue.push(w);
Index: src/work/athos/dijkstra_demo.cc
===================================================================
--- src/work/athos/dijkstra_demo.cc	(revision 921)
+++ src/work/athos/dijkstra_demo.cc	(revision 986)
@@ -130,8 +130,8 @@
     std::cout << "out edges: ";
     for(out_edge_iterator j=flow_test.first_out_edge(i); j.valid(); ++j) 
-      std::cout << node_name.get(flow_test.tail(j)) << "-"<< cap.get(j) << "->" << node_name.get(flow_test.head(j)) << " ";
+      std::cout << node_name.get(flow_test.source(j)) << "-"<< cap.get(j) << "->" << node_name.get(flow_test.target(j)) << " ";
     std::cout << "in edges: ";
     for(in_edge_iterator j=flow_test.first_in_edge(i); j.valid(); ++j) 
-      std::cout << node_name.get(flow_test.tail(j)) << "-"<< cap.get(j) << "->" << node_name.get(flow_test.head(j)) << " ";
+      std::cout << node_name.get(flow_test.source(j)) << "-"<< cap.get(j) << "->" << node_name.get(flow_test.target(j)) << " ";
     std::cout << std::endl;
   }
Index: src/work/athos/mincostflow.h
===================================================================
--- src/work/athos/mincostflow.h	(revision 921)
+++ src/work/athos/mincostflow.h	(revision 986)
@@ -74,7 +74,7 @@
       ValueType operator[](typename ResGraph::Edge e) const {     
 	if (res_graph.forward(e))
-	  return  ol[e]-(pot[res_graph.head(e)]-pot[res_graph.tail(e)]);   
+	  return  ol[e]-(pot[res_graph.target(e)]-pot[res_graph.source(e)]);   
 	else
-	  return -ol[e]-(pot[res_graph.head(e)]-pot[res_graph.tail(e)]);   
+	  return -ol[e]-(pot[res_graph.target(e)]-pot[res_graph.source(e)]);   
       }     
 	
@@ -259,6 +259,6 @@
 	  while ( i != nonabundant_arcs.end() ){
 	    if (flow[*i]>=buf){
-	      Node a = abundant_components.find(res_graph.head(*i));
-	      Node b = abundant_components.find(res_graph.tail(*i));
+	      Node a = abundant_components.find(res_graph.target(*i));
+	      Node b = abundant_components.find(res_graph.source(*i));
 	      //Merge
 	      if (a != b){
@@ -285,5 +285,5 @@
 		  while (n!=non_root){
 		    e = bfs_pred[n];
-		    n = res_graph.tail(e);
+		    n = res_graph.source(e);
 		    res_graph.augment(e,qty_to_augment);
 		  }
@@ -455,5 +455,5 @@
       FOR_EACH_LOC(typename Graph::EdgeIt, e, graph){
 	//C^{\Pi}_{i,j}
-	mod_pot = cost[e]-potential[graph.head(e)]+potential[graph.tail(e)];
+	mod_pot = cost[e]-potential[graph.target(e)]+potential[graph.source(e)];
 	fl_e = flow[e];
 	//	std::cout << fl_e << std::endl;
@@ -484,6 +484,6 @@
 	  return false;
 	}
-	supdem[graph.tail(e)] += flow[e];
-	supdem[graph.head(e)] -= flow[e];
+	supdem[graph.source(e)] += flow[e];
+	supdem[graph.target(e)] -= flow[e];
       }
       //write_property_vector(supdem, "supdem");
Index: src/work/athos/old/minlengthpaths.h
===================================================================
--- src/work/athos/old/minlengthpaths.h	(revision 921)
+++ src/work/athos/old/minlengthpaths.h	(revision 986)
@@ -54,8 +54,8 @@
 	
       ValueType operator[](typename ResGraphType::Edge e) const {     
-	//if ( (1-2*rev[e])*ol[e]-(pot[G.head(e)]-pot[G.tail(e)] ) <0 ){
+	//if ( (1-2*rev[e])*ol[e]-(pot[G.target(e)]-pot[G.source(e)] ) <0 ){
 	//  std::cout<<"Negative length!!"<<std::endl;
 	//}
-	return (1-2*rev[e])*ol[e]-(pot[G.head(e)]-pot[G.tail(e)]);   
+	return (1-2*rev[e])*ol[e]-(pot[G.target(e)]-pot[G.source(e)]);   
       }     
 	
@@ -162,5 +162,5 @@
 	    G.next(e);
 	  }
-	  n = G.head(e);
+	  n = G.target(e);
 	  paths[j].push_back(e);
 	  total_length += length[e];
Index: src/work/athos/preflow_push_wogw.h
===================================================================
--- src/work/athos/preflow_push_wogw.h	(revision 921)
+++ src/work/athos/preflow_push_wogw.h	(revision 986)
@@ -140,5 +140,5 @@
     //This private procedure is supposed to modify the preflow on edge j
     //by value v (which can be positive or negative as well) 
-    //and maintain the excess on the head and tail
+    //and maintain the excess on the target and source
     //Here we do not check whether this is possible or not
     void modify_preflow(Edge j, const T& v){
@@ -148,9 +148,9 @@
 
 
-      //Modifiyng the head
-      modify_excess(G.head(j),v);
-	
-      //Modifiyng the tail
-      modify_excess(G.tail(j),-v);
+      //Modifiyng the target
+      modify_excess(G.target(j),v);
+	
+      //Modifiyng the source
+      modify_excess(G.source(j),-v);
 
     }
@@ -273,5 +273,5 @@
 	InEdgeIt e;
 	for(G.first(e,v); G.valid(e); G.next(e)) {
-	  Node w=G.tail(e);
+	  Node w=G.source(e);
 	  if ( level[w] == number_of_nodes && w != s ) {
 	    bfs_queue.push(w);
@@ -311,6 +311,6 @@
       for(OutEdgeIt j=G.template first<OutEdgeIt>(s); G.valid(j); G.next(j)){ 
 	modify_preflow(j,capacity[j] );
-	make_active(G.head(j));
-	int lev=level[G.head(j)];
+	make_active(G.target(j));
+	int lev=level[G.target(j)];
 	if(highest_active<lev){
 	  highest_active=lev;
@@ -326,10 +326,10 @@
 
       if (capacity[j]>preflow[j]){
-	if(level[G.tail(j)]==level[G.head(j)]+1){
+	if(level[G.source(j)]==level[G.target(j)]+1){
 	  return true;
 	}
 	else{
-	  if (level[G.head(j)] < new_level)
-	    new_level=level[G.head(j)];
+	  if (level[G.target(j)] < new_level)
+	    new_level=level[G.target(j)];
 	}
       }
@@ -342,11 +342,11 @@
       
       if (0<preflow[j]){
-	if(level[G.tail(j)]==level[G.head(j)]-1){
+	if(level[G.source(j)]==level[G.target(j)]-1){
 	 
 	  return true;
 	}
 	else{
-	  if (level[G.tail(j)] < new_level)
-	    new_level=level[G.tail(j)];
+	  if (level[G.source(j)] < new_level)
+	    new_level=level[G.source(j)];
 	}
 	
@@ -389,6 +389,6 @@
 	      e -= v;
 	      //New node might become active
-	      if (excess[G.head(j)]==0){
-		make_active(G.head(j));
+	      if (excess[G.target(j)]==0){
+		make_active(G.target(j));
 	      }
 	      modify_preflow(j,v);
@@ -405,6 +405,6 @@
 	      e -= v;
 	      //New node might become active
-	      if (excess[G.tail(j)]==0){
-		make_active(G.tail(j));
+	      if (excess[G.source(j)]==0){
+		make_active(G.source(j));
 	      }
 	      modify_preflow(j,-v);
