Index: src/work/marci/augmenting_flow.h
===================================================================
--- src/work/marci/augmenting_flow.h	(revision 970)
+++ src/work/marci/augmenting_flow.h	(revision 986)
@@ -211,5 +211,5 @@
 	OutEdgeIt e;
 	for(g->first(e,w) ; e!=INVALID; ++e) {
-	  Node v=g->head(e);
+	  Node v=g->target(e);
 	  if (!M[v] && (*flow)[e] < (*capacity)[e] ) {
 	    queue.push(v);
@@ -220,5 +220,5 @@
 	InEdgeIt f;
 	for(g->first(f,w) ; f!=INVALID; ++f) {
-	  Node v=g->tail(f);
+	  Node v=g->source(f);
 	  if (!M[v] && (*flow)[f] > 0 ) {
 	    queue.push(v);
@@ -271,6 +271,6 @@
       ResGWEdge e=bfs;
       if (e!=INVALID && bfs.isBNodeNewlyReached()) {
-	Node v=res_graph.tail(e);
-	Node w=res_graph.head(e);
+	Node v=res_graph.source(e);
+	Node w=res_graph.target(e);
 	pred.set(w, e);
 	if (pred[v]!=INVALID) {
@@ -279,5 +279,5 @@
 	  free.set(w, res_cap[e]);
 	}
-	if (res_graph.head(e)==t) { _augment=true; break; }
+	if (res_graph.target(e)==t) { _augment=true; break; }
       }
 
@@ -291,5 +291,5 @@
 	ResGWEdge e=pred[n];
 	res_graph.augment(e, augment_value);
-	n=res_graph.tail(e);
+	n=res_graph.source(e);
       }
     }
@@ -330,6 +330,6 @@
       ResGWEdge e=bfs;
       if (e!=INVALID && bfs.isBNodeNewlyReached()) {
-	Node v=res_graph.tail(e);
-	Node w=res_graph.head(e);
+	Node v=res_graph.source(e);
+	Node w=res_graph.target(e);
 	pred.set(w, e);
 	if (pred[v]!=INVALID) {
@@ -338,5 +338,5 @@
 	  free.set(w, res_cap[e]);
 	}
-	if (res_graph.head(e)==t) { _augment=true; break; }
+	if (res_graph.target(e)==t) { _augment=true; break; }
       }
 
@@ -350,5 +350,5 @@
 	ResGWEdge e=pred[n];
 	res_graph.augment(e, augment_value);
-	n=res_graph.tail(e);
+	n=res_graph.source(e);
       }
     }
@@ -396,7 +396,7 @@
       if (e!=INVALID) {
 	if (bfs.isBNodeNewlyReached()) {
-	  dist.set(res_graph.head(e), dist[res_graph.tail(e)]+1);
-	  typename MG::Edge f=F.addEdge(res_graph_to_F[res_graph.tail(e)],
-					res_graph_to_F[res_graph.head(e)]);
+	  dist.set(res_graph.target(e), dist[res_graph.source(e)]+1);
+	  typename MG::Edge f=F.addEdge(res_graph_to_F[res_graph.source(e)],
+					res_graph_to_F[res_graph.target(e)]);
 	  //original_edge.update();
 	  original_edge.set(f, e);
@@ -404,7 +404,7 @@
 	  residual_capacity.set(f, res_cap[e]);
 	} else {
-	  if (dist[res_graph.head(e)]==(dist[res_graph.tail(e)]+1)) {
-	    typename MG::Edge f=F.addEdge(res_graph_to_F[res_graph.tail(e)],
-					  res_graph_to_F[res_graph.head(e)]);
+	  if (dist[res_graph.target(e)]==(dist[res_graph.source(e)]+1)) {
+	    typename MG::Edge f=F.addEdge(res_graph_to_F[res_graph.source(e)],
+					  res_graph_to_F[res_graph.target(e)]);
 	    //original_edge.update();
 	    original_edge.set(f, e);
@@ -434,6 +434,6 @@
 	if (typename MG::Edge(dfs)!=INVALID) {
 	  if (dfs.isBNodeNewlyReached()) {
-	    typename MG::Node v=F.tail(dfs);
-	    typename MG::Node w=F.head(dfs);
+	    typename MG::Node v=F.source(dfs);
+	    typename MG::Node w=F.target(dfs);
 	    pred.set(w, dfs);
 	    if (pred[v]!=INVALID) {
@@ -460,5 +460,5 @@
 	  typename MG::Edge e=pred[n];
 	  res_graph.augment(original_edge[e], augment_value);
-	  n=F.tail(e);
+	  n=F.source(e);
 	  if (residual_capacity[e]==augment_value)
 	    F.erase(e);
@@ -499,5 +499,5 @@
       ResGWEdge e=bfs;
       if (e!=INVALID && bfs.isBNodeNewlyReached())
-	potential.set(res_graph.head(e), potential[res_graph.tail(e)]+1);
+	potential.set(res_graph.target(e), potential[res_graph.source(e)]+1);
       ++bfs;
     } 
@@ -554,6 +554,6 @@
 	  if (dfs.isBNodeNewlyReached()) {
 	    
-	    typename ErasingResGW::Node v=erasing_res_graph.tail(dfs);
-	    typename ErasingResGW::Node w=erasing_res_graph.head(dfs);
+	    typename ErasingResGW::Node v=erasing_res_graph.source(dfs);
+	    typename ErasingResGW::Node w=erasing_res_graph.target(dfs);
 
 	    pred.set(w, typename ErasingResGW::Edge(dfs));
@@ -586,5 +586,5 @@
 	  typename ErasingResGW::Edge e=pred[n];
 	  res_graph.augment(e, augment_value);
-	  n=erasing_res_graph.tail(e);
+	  n=erasing_res_graph.source(e);
 	  if (res_cap[e]==0)
 	    erasing_res_graph.erase(e);
Index: src/work/marci/bfs_dfs.h
===================================================================
--- src/work/marci/bfs_dfs.h	(revision 921)
+++ src/work/marci/bfs_dfs.h	(revision 986)
@@ -64,5 +64,5 @@
 	//graph->first(actual_edge, s);
 	if (actual_edge!=INVALID) { 
-	  Node w=graph->head(actual_edge);
+	  Node w=graph->target(actual_edge);
 	  if (!reached[w]) {
 	    bfs_queue.push(w);
@@ -86,5 +86,5 @@
 	//++actual_edge;
 	if (actual_edge!=INVALID) {
-	  Node w=graph->head(actual_edge);
+	  Node w=graph->target(actual_edge);
 	  if (!reached[w]) {
 	    bfs_queue.push(w);
@@ -101,5 +101,5 @@
 	  //graph->first(actual_edge, bfs_queue.front());
 	  if (actual_edge!=INVALID) {
-	    Node w=graph->head(actual_edge);
+	    Node w=graph->target(actual_edge);
 	    if (!reached[w]) {
 	      bfs_queue.push(w);
@@ -125,7 +125,7 @@
     bool isANodeExamined() const { return actual_edge==INVALID; }
     /// Returns a-node of the actual edge, so does if the edge is invalid.
-    Node tail() const { return bfs_queue.front(); }
+    Node source() const { return bfs_queue.front(); }
     /// \pre The actual edge have to be valid.
-    Node head() const { return graph->head(actual_edge); }
+    Node target() const { return graph->target(actual_edge); }
     /// Guess what?
     /// \deprecated 
@@ -187,6 +187,6 @@
       if (this->graph->valid(this->actual_edge) && this->b_node_newly_reached) 
       {
-	pred.set(this->head(), this->actual_edge);
-	dist.set(this->head(), dist[this->tail()]);
+	pred.set(this->target(), this->actual_edge);
+	dist.set(this->target(), dist[this->source()]);
       }
       return *this;
@@ -247,5 +247,5 @@
       actual_edge=dfs_stack.top();
       if (actual_edge!=INVALID/*.valid()*/) { 
-	Node w=graph->head(actual_edge);
+	Node w=graph->target(actual_edge);
 	actual_node=w;
 	if (!reached[w]) {
@@ -256,5 +256,5 @@
 	  b_node_newly_reached=true;
 	} else {
-	  actual_node=graph->tail(actual_edge);
+	  actual_node=graph->source(actual_edge);
 	  ++dfs_stack.top();
 	  b_node_newly_reached=false;
@@ -277,8 +277,8 @@
     bool isANodeExamined() const { return actual_edge==INVALID; }
     /// Returns a-node of the actual edge, so does if the edge is invalid.
-    Node tail() const { return actual_node; /*FIXME*/}
+    Node source() const { return actual_node; /*FIXME*/}
     /// Returns b-node of the actual edge. 
     /// \pre The actual edge have to be valid.
-    Node head() const { return graph->head(actual_edge); }
+    Node target() const { return graph->target(actual_edge); }
     /// Guess what?
     /// \deprecated
@@ -334,5 +334,5 @@
       if (this->graph->valid(this->actual_edge) && this->b_node_newly_reached) 
       {
-	pred.set(this->head(), this->actual_edge);
+	pred.set(this->target(), this->actual_edge);
       }
       return *this;
Index: src/work/marci/bfs_mm.h
===================================================================
--- src/work/marci/bfs_mm.h	(revision 944)
+++ src/work/marci/bfs_mm.h	(revision 986)
@@ -72,5 +72,5 @@
 	//graph->first(actual_edge, s);
 	if (actual_edge!=INVALID) { 
-	  Node w=graph->head(actual_edge);
+	  Node w=graph->target(actual_edge);
 	  if (!(*reached_map)[w]) {
 	    bfs_queue.push(w);
@@ -94,5 +94,5 @@
 	//++actual_edge;
 	if (actual_edge!=INVALID) {
-	  Node w=graph->head(actual_edge);
+	  Node w=graph->target(actual_edge);
 	  if (!(*reached_map)[w]) {
 	    bfs_queue.push(w);
@@ -109,5 +109,5 @@
 	  //graph->first(actual_edge, bfs_queue.front());
 	  if (actual_edge!=INVALID) {
-	    Node w=graph->head(actual_edge);
+	    Node w=graph->target(actual_edge);
 	    if (!(*reached_map)[w]) {
 	      bfs_queue.push(w);
@@ -133,7 +133,7 @@
     bool isANodeExamined() const { return actual_edge==INVALID; }
     /// Returns a-node of the actual edge, so does if the edge is invalid.
-    Node tail() const { return bfs_queue.front(); }
+    Node source() const { return bfs_queue.front(); }
     /// \pre The actual edge have to be valid.
-    Node head() const { return graph->head(actual_edge); }
+    Node target() const { return graph->target(actual_edge); }
     /// Guess what?
     /// \deprecated 
@@ -232,7 +232,7 @@
       if ((this->actual_edge)!=INVALID && this->b_node_newly_reached) 
       {
-	pred_map->set(this->head(), this->actual_edge);
-	pred_node_map->set(this->head(), this->tail());
-	dist_map->set(this->head(), (*dist_map)[this->tail()]);
+	pred_map->set(this->target(), this->actual_edge);
+	pred_node_map->set(this->target(), this->source());
+	dist_map->set(this->target(), (*dist_map)[this->source()]);
       }
       return *this;
@@ -458,5 +458,5 @@
       actual_edge=dfs_stack.top();
       if (actual_edge!=INVALID/*.valid()*/) { 
-	Node w=graph->head(actual_edge);
+	Node w=graph->target(actual_edge);
 	actual_node=w;
 	if (!reached[w]) {
@@ -467,5 +467,5 @@
 	  b_node_newly_reached=true;
 	} else {
-	  actual_node=graph->tail(actual_edge);
+	  actual_node=graph->source(actual_edge);
 	  ++dfs_stack.top();
 	  b_node_newly_reached=false;
@@ -488,8 +488,8 @@
     bool isANodeExamined() const { return actual_edge==INVALID; }
     /// Returns a-node of the actual edge, so does if the edge is invalid.
-    Node tail() const { return actual_node; /*FIXME*/}
+    Node source() const { return actual_node; /*FIXME*/}
     /// Returns b-node of the actual edge. 
     /// \pre The actual edge have to be valid.
-    Node head() const { return graph->head(actual_edge); }
+    Node target() const { return graph->target(actual_edge); }
     /// Guess what?
     /// \deprecated
@@ -545,5 +545,5 @@
       if (this->graph->valid(this->actual_edge) && this->b_node_newly_reached) 
       {
-	pred.set(this->head(), this->actual_edge);
+	pred.set(this->target(), this->actual_edge);
       }
       return *this;
Index: src/work/marci/bfs_mm_test.cc
===================================================================
--- src/work/marci/bfs_mm_test.cc	(revision 959)
+++ src/work/marci/bfs_mm_test.cc	(revision 986)
@@ -92,6 +92,6 @@
 
 //   for(EdgeIt e(G); e==INVALID; ++e) {
-//     Node u=G.tail(e);
-//     Node v=G.head(e);
+//     Node u=G.source(e);
+//     Node v=G.target(e);
 //     check( !bfs_test.reached(u) ||
 // 	   (bfs_test.dist(v) > bfs_test.dist(u)+1),
@@ -103,5 +103,5 @@
 //     if ( bfs_test.pred(v)!=INVALID ) {
 //       Edge e=bfs_test.pred(v);
-//       Node u=G.tail(e);
+//       Node u=G.source(e);
 //       check(u==bfs_test.predNode(v),"Wrong tree.");
 //       check(bfs_test.dist(v) - bfs_test.dist(u) == 1,
Index: src/work/marci/bfsit_vs_byhand.cc
===================================================================
--- src/work/marci/bfsit_vs_byhand.cc	(revision 944)
+++ src/work/marci/bfsit_vs_byhand.cc	(revision 986)
@@ -49,5 +49,5 @@
       bfs_queue.pop();
       for(OutEdgeIt e(g,v); e!=INVALID; ++e) {
-	Node w=g.head(e);
+	Node w=g.target(e);
 	if (!reached[w]) {
 	  bfs_queue.push(w);
@@ -71,5 +71,5 @@
       ++bfs; 
       if (Graph::Edge(bfs)!=INVALID && bfs.isBNodeNewlyReached()) 
-	pred.set(bfs.head(), Graph::Edge(bfs));
+	pred.set(bfs.target(), Graph::Edge(bfs));
     }
   }
Index: src/work/marci/bipartite_graph_wrapper.h
===================================================================
--- src/work/marci/bipartite_graph_wrapper.h	(revision 921)
+++ src/work/marci/bipartite_graph_wrapper.h	(revision 986)
@@ -168,15 +168,15 @@
 //     InEdgeIt& next(InEdgeIt& i) const { this->graph->next(i.e); return i; }
 
-//     Node tail(const Edge& e) { 
-//       if (!(*(this->s_false_t_true_map))[this->graph->tail(e)]) 
-// 	return Node(this->graph->tail(e));
+//     Node source(const Edge& e) { 
+//       if (!(*(this->s_false_t_true_map))[this->graph->source(e)]) 
+// 	return Node(this->graph->source(e));
 //       else
-// 	return Node(this->graph->head(e));	
-//     }
-//     Node head(const Edge& e) { 
-//       if (!(*(this->s_false_t_true_map))[this->graph->tail(e)]) 
-// 	return Node(this->graph->head(e));
+// 	return Node(this->graph->target(e));	
+//     }
+//     Node target(const Edge& e) { 
+//       if (!(*(this->s_false_t_true_map))[this->graph->source(e)]) 
+// 	return Node(this->graph->target(e));
 //       else
-// 	return Node(this->graph->tail(e));	
+// 	return Node(this->graph->source(e));	
 //     }
 
@@ -253,7 +253,7 @@
 
     /// A new edge is inserted.
-    ///\pre \c tail have to be in \c S_Class and \c head in \c T_Class.
-    Edge addEdge(const Node& tail, const Node& head) {
-      return Parent::graph->addEdge(tail, head);
+    ///\pre \c source have to be in \c S_Class and \c target in \c T_Class.
+    Edge addEdge(const Node& source, const Node& target) {
+      return Parent::graph->addEdge(source, target);
     }
 
@@ -696,8 +696,8 @@
     }    
 
-    Node tail(const Edge& e) const { 
+    Node source(const Edge& e) const { 
       switch (e.spec) {
       case 0: 
-	return Node(this->graph->tail(e));
+	return Node(this->graph->source(e));
 	break;
       case 1:
@@ -710,8 +710,8 @@
       }
     }
-    Node head(const Edge& e) const { 
+    Node target(const Edge& e) const { 
       switch (e.spec) {
       case 0: 
-	return Node(this->graph->head(e));
+	return Node(this->graph->target(e));
 	break;
       case 1:
@@ -733,8 +733,8 @@
     }
   
-    Node aNode(const OutEdgeIt& e) const { return tail(e); }
-    Node aNode(const InEdgeIt& e) const { return head(e); }
-    Node bNode(const OutEdgeIt& e) const { return head(e); }
-    Node bNode(const InEdgeIt& e) const { return tail(e); }
+    Node aNode(const OutEdgeIt& e) const { return source(e); }
+    Node aNode(const InEdgeIt& e) const { return target(e); }
+    Node bNode(const OutEdgeIt& e) const { return target(e); }
+    Node bNode(const InEdgeIt& e) const { return source(e); }
 
     void addNode() const { }
@@ -742,6 +742,6 @@
     
 //    Node addNode() const { return Node(this->graph->addNode()); }
-//    Edge addEdge(const Node& tail, const Node& head) const { 
-//      return Edge(this->graph->addEdge(tail, head)); }
+//    Edge addEdge(const Node& source, const Node& target) const { 
+//      return Edge(this->graph->addEdge(source, target)); }
 
 //    void erase(const Node& i) const { this->graph->erase(i); }
Index: src/work/marci/bipartite_graph_wrapper_test.cc
===================================================================
--- src/work/marci/bipartite_graph_wrapper_test.cc	(revision 921)
+++ src/work/marci/bipartite_graph_wrapper_test.cc	(revision 986)
@@ -88,5 +88,5 @@
   cout << "Edges of the bipartite graph:" << endl;
   for (BGW::EdgeIt e(bgw); e!=INVALID; ++e)
-    cout << g.id(bgw.tail(e)) << "->" << g.id(bgw.head(e)) << endl;
+    cout << g.id(bgw.source(e)) << "->" << g.id(bgw.target(e)) << endl;
 
   BGW::NodeMap<int> dbyj(bgw);
Index: src/work/marci/experiment/edmonds_karp.h
===================================================================
--- src/work/marci/experiment/edmonds_karp.h	(revision 921)
+++ src/work/marci/experiment/edmonds_karp.h	(revision 986)
@@ -41,5 +41,5 @@
       //Edge(const Edge& e) : resG(e.resG), sym(e.sym) { }
       Number free() const { 
-	if (resG->G.aNode(sym)==resG->G.tail(sym)) { 
+	if (resG->G.aNode(sym)==resG->G.source(sym)) { 
 	  return (resG->capacity.get(sym)-resG->flow.get(sym)); 
 	} else { 
@@ -49,5 +49,5 @@
       bool valid() const { return sym.valid(); }
       void augment(Number a) const {
-	if (resG->G.aNode(sym)==resG->G.tail(sym)) { 
+	if (resG->G.aNode(sym)==resG->G.source(sym)) { 
 	  resG->flow.set(sym, resG->flow.get(sym)+a);
 	  //resG->flow[sym]+=a;
@@ -97,6 +97,6 @@
     }
 
-    Node tail(Edge e) const { return G.aNode(e.sym); }
-    Node head(Edge e) const { return G.bNode(e.sym); }
+    Node source(Edge e) const { return G.aNode(e.sym); }
+    Node target(Edge e) const { return G.bNode(e.sym); }
 
     Node aNode(OutEdgeIt e) const { return G.aNode(e.sym); }
@@ -224,7 +224,7 @@
     }
 
-    Node tail(Edge e) const { 
+    Node source(Edge e) const { 
       return ((e.out_or_in) ? G.aNode(e.out) : G.aNode(e.in)); }
-    Node head(Edge e) const { 
+    Node target(Edge e) const { 
       return ((e.out_or_in) ? G.bNode(e.out) : G.bNode(e.in)); }
 
@@ -288,6 +288,6 @@
 	ResGWOutEdgeIt e=bfs;
 	if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
-	  Node v=res_graph.tail(e);
-	  Node w=res_graph.head(e);
+	  Node v=res_graph.source(e);
+	  Node w=res_graph.target(e);
 	  pred.set(w, e);
 	  if (res_graph.valid(pred.get(v))) {
@@ -296,5 +296,5 @@
 	    free.set(w, res_graph.resCap(e)); 
 	  }
-	  if (res_graph.head(e)==t) { _augment=true; break; }
+	  if (res_graph.target(e)==t) { _augment=true; break; }
 	}
 	
@@ -308,5 +308,5 @@
 	  ResGWEdge e=pred.get(n);
 	  res_graph.augment(e, augment_value); 
-	  n=res_graph.tail(e);
+	  n=res_graph.source(e);
 	}
       }
@@ -325,5 +325,5 @@
       int get(const typename MapGraphWrapper::Node& n) const { return dist[n]; }
       bool get(const typename MapGraphWrapper::Edge& e) const { 
-	return (dist.get(gw.tail(e))<dist.get(gw.head(e))); 
+	return (dist.get(gw.source(e))<dist.get(gw.target(e))); 
       }
     };
@@ -344,5 +344,5 @@
 	ResGWOutEdgeIt e=bfs;
 	if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
-	  dist.set(res_graph.head(e), dist.get(res_graph.tail(e))+1);
+	  dist.set(res_graph.target(e), dist.get(res_graph.source(e))+1);
 	}
 	++bfs;
@@ -370,6 +370,6 @@
 	typename FilterResGW::EdgeIt e;
 	for(filter_res_graph.first(e); filter_res_graph.valid(e); filter_res_graph.next(e)) {
-	  //if (dist.get(res_graph.head(e))==dist.get(res_graph.tail(e))+1) {
-	  typename MG::Edge f=F.addEdge(res_graph_to_F.get(res_graph.tail(e)), res_graph_to_F.get(res_graph.head(e)));
+	  //if (dist.get(res_graph.target(e))==dist.get(res_graph.source(e))+1) {
+	  typename MG::Edge f=F.addEdge(res_graph_to_F.get(res_graph.source(e)), res_graph_to_F.get(res_graph.target(e)));
 	  original_edge.update();
 	  original_edge.set(f, e);
@@ -424,5 +424,5 @@
 	    typename MG::Edge e=pred.get(n);
 	    res_graph.augment(original_edge.get(e), augment_value); 
-	    n=F.tail(e);
+	    n=F.source(e);
 	    if (residual_capacity.get(e)==augment_value) 
 	      F.erase(e); 
@@ -469,6 +469,6 @@
 	if (res_graph.valid(e)) {
 	  if (bfs.isBNodeNewlyReached()) {
-	    dist.set(res_graph.head(e), dist.get(res_graph.tail(e))+1);
-	    typename MG::Edge f=F.addEdge(res_graph_to_F.get(res_graph.tail(e)), res_graph_to_F.get(res_graph.head(e)));
+	    dist.set(res_graph.target(e), dist.get(res_graph.source(e))+1);
+	    typename MG::Edge f=F.addEdge(res_graph_to_F.get(res_graph.source(e)), res_graph_to_F.get(res_graph.target(e)));
 	    original_edge.update();
 	    original_edge.set(f, e);
@@ -476,6 +476,6 @@
 	    residual_capacity.set(f, res_graph.resCap(e));
 	  } else {
-	    if (dist.get(res_graph.head(e))==(dist.get(res_graph.tail(e))+1)) {
-	      typename MG::Edge f=F.addEdge(res_graph_to_F.get(res_graph.tail(e)), res_graph_to_F.get(res_graph.head(e)));
+	    if (dist.get(res_graph.target(e))==(dist.get(res_graph.source(e))+1)) {
+	      typename MG::Edge f=F.addEdge(res_graph_to_F.get(res_graph.source(e)), res_graph_to_F.get(res_graph.target(e)));
 	      original_edge.update();
 	      original_edge.set(f, e);
@@ -532,5 +532,5 @@
 	    typename MG::Edge e=pred.get(n);
 	    res_graph.augment(original_edge.get(e), augment_value); 
-	    n=F.tail(e);
+	    n=F.source(e);
 	    if (residual_capacity.get(e)==augment_value) 
 	      F.erase(e); 
@@ -558,5 +558,5 @@
  	ResGWOutEdgeIt e=bfs;
  	if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
- 	  dist.set(res_graph.head(e), dist.get(res_graph.tail(e))+1);
+ 	  dist.set(res_graph.target(e), dist.get(res_graph.source(e))+1);
  	}
 	++bfs;
@@ -634,5 +634,5 @@
  	    typename ErasingResGW::OutEdgeIt e=pred.get(n);
  	    res_graph.augment(e, augment_value);
- 	    n=erasing_res_graph.tail(e);
+ 	    n=erasing_res_graph.source(e);
  	    if (res_graph.resCap(e)==0)
  	      erasing_res_graph.erase(e);
@@ -669,5 +669,5 @@
 // 	typename ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::OutEdgeIt e=bfs;
 // 	if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
-// 	  dist.set(res_graph.head(e), dist.get(res_graph.tail(e))+1);
+// 	  dist.set(res_graph.target(e), dist.get(res_graph.source(e))+1);
 // 	}
 // 	++bfs;	
@@ -723,5 +723,5 @@
 // 	    EAugEdge e=pred.get(n);
 // 	    res_graph.augment(e, augment_value);
-// 	    n=res_graph.tail(e);
+// 	    n=res_graph.source(e);
 // 	    if (res_graph.free(e)==0)
 // 	      res_graph.erase(e);
@@ -818,6 +818,6 @@
 // 	AugOutEdgeIt e=bfs;
 // 	if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
-// 	  Node v=res_graph.tail(e);
-// 	  Node w=res_graph.head(e);
+// 	  Node v=res_graph.source(e);
+// 	  Node w=res_graph.target(e);
 // 	  pred.set(w, e);
 // 	  if (res_graph.valid(pred.get(v))) {
@@ -826,5 +826,5 @@
 // 	    free.set(w, res_graph.free(e)); 
 // 	  }
-// 	  n=res_graph.head(e);
+// 	  n=res_graph.target(e);
 // 	  if (T->get(n) && (used.get(n)<1) ) { 
 // 	    //Number u=0;
@@ -848,5 +848,5 @@
 // 	  AugEdge e=pred.get(n);
 // 	  res_graph.augment(e, augment_value); 
-// 	  n=res_graph.tail(e);
+// 	  n=res_graph.source(e);
 // 	}
 // 	used.set(n, 1); //mind2 vegen jav
@@ -889,5 +889,5 @@
 // // 	AugOutEdgeIt e=bfs;
 // // 	if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
-// // 	  dist.set(res_graph.head(e), dist.get(res_graph.tail(e))+1);
+// // 	  dist.set(res_graph.target(e), dist.get(res_graph.source(e))+1);
 // // 	}
 	
@@ -911,6 +911,6 @@
 // //       //which are in some shortest paths
 // //       for(typename AugGraph::EdgeIt e=res_graph.template first<typename AugGraph::EdgeIt>(); res_graph.valid(e); res_graph.next(e)) {
-// // 	if (dist.get(res_graph.head(e))==dist.get(res_graph.tail(e))+1) {
-// // 	  typename MutableGraph::Edge f=F.addEdge(res_graph_to_F.get(res_graph.tail(e)), res_graph_to_F.get(res_graph.head(e)));
+// // 	if (dist.get(res_graph.target(e))==dist.get(res_graph.source(e))+1) {
+// // 	  typename MutableGraph::Edge f=F.addEdge(res_graph_to_F.get(res_graph.source(e)), res_graph_to_F.get(res_graph.target(e)));
 // // 	  original_edge.update();
 // // 	  original_edge.set(f, e);
@@ -964,5 +964,5 @@
 // // 	    typename MutableGraph::Edge e=pred.get(n);
 // // 	    res_graph.augment(original_edge.get(e), augment_value); 
-// // 	    n=F.tail(e);
+// // 	    n=F.source(e);
 // // 	    if (residual_capacity.get(e)==augment_value) 
 // // 	      F.erase(e); 
@@ -1015,5 +1015,5 @@
 // 	typename ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::OutEdgeIt e=bfs;
 // 	if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
-// 	  dist.set(res_graph.head(e), dist.get(res_graph.tail(e))+1);
+// 	  dist.set(res_graph.target(e), dist.get(res_graph.source(e))+1);
 // 	}
 // 	++bfs;	
@@ -1092,5 +1092,5 @@
 // 	    EAugEdge e=pred.get(n);
 // 	    res_graph.augment(e, augment_value);
-// 	    n=res_graph.tail(e);
+// 	    n=res_graph.source(e);
 // 	    if (res_graph.free(e)==0)
 // 	      res_graph.erase(e);
@@ -1185,6 +1185,6 @@
 // // 	AugOutEdgeIt e=/*AugOutEdgeIt*/(bfs);
 // // 	if (e.valid() && bfs.isBNodeNewlyReached()) {
-// // 	  Node v=res_graph.tail(e);
-// // 	  Node w=res_graph.head(e);
+// // 	  Node v=res_graph.source(e);
+// // 	  Node w=res_graph.target(e);
 // // 	  pred.set(w, e);
 // // 	  if (pred.get(v).valid()) {
@@ -1193,7 +1193,7 @@
 // // 	    free.set(w, e.free()); 
 // // 	  }
-// // 	  if (TMap.get(res_graph.head(e))) { 
+// // 	  if (TMap.get(res_graph.target(e))) { 
 // // 	    _augment=true; 
-// // 	    reached_t_node=res_graph.head(e);
+// // 	    reached_t_node=res_graph.target(e);
 // // 	    break; 
 // // 	  }
@@ -1209,5 +1209,5 @@
 // // 	  AugEdge e=pred.get(n);
 // // 	  e.augment(augment_value); 
-// // 	  n=res_graph.tail(e);
+// // 	  n=res_graph.source(e);
 // // 	}
 // //       }
Index: src/work/marci/experiment/edmonds_karp_1.h
===================================================================
--- src/work/marci/experiment/edmonds_karp_1.h	(revision 921)
+++ src/work/marci/experiment/edmonds_karp_1.h	(revision 986)
@@ -42,5 +42,5 @@
       //Edge(const Edge& e) : resG(e.resG), sym(e.sym) { }
       Number free() const { 
-	if (resG->G.aNode(sym)==resG->G.tail(sym)) { 
+	if (resG->G.aNode(sym)==resG->G.source(sym)) { 
 	  return (resG->capacity.get(sym)-resG->flow.get(sym)); 
 	} else { 
@@ -50,5 +50,5 @@
       bool valid() const { return sym.valid(); }
       void augment(Number a) const {
-	if (resG->G.aNode(sym)==resG->G.tail(sym)) { 
+	if (resG->G.aNode(sym)==resG->G.source(sym)) { 
 	  resG->flow.set(sym, resG->flow.get(sym)+a);
 	  //resG->flow[sym]+=a;
@@ -98,6 +98,6 @@
     }
 
-    Node tail(Edge e) const { return G.aNode(e.sym); }
-    Node head(Edge e) const { return G.bNode(e.sym); }
+    Node source(Edge e) const { return G.aNode(e.sym); }
+    Node target(Edge e) const { return G.bNode(e.sym); }
 
     Node aNode(OutEdgeIt e) const { return G.aNode(e.sym); }
@@ -225,7 +225,7 @@
     }
 
-    Node tail(Edge e) const { 
+    Node source(Edge e) const { 
       return ((e.out_or_in) ? G.aNode(e.out) : G.aNode(e.in)); }
-    Node head(Edge e) const { 
+    Node target(Edge e) const { 
       return ((e.out_or_in) ? G.bNode(e.out) : G.bNode(e.in)); }
 
@@ -287,6 +287,6 @@
 	ResGWOutEdgeIt e=bfs;
 	if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
-	  Node v=res_graph.tail(e);
-	  Node w=res_graph.head(e);
+	  Node v=res_graph.source(e);
+	  Node w=res_graph.target(e);
 	  pred.set(w, e);
 	  if (res_graph.valid(pred.get(v))) {
@@ -295,5 +295,5 @@
 	    free.set(w, res_graph.resCap(e)); 
 	  }
-	  if (res_graph.head(e)==t) { _augment=true; break; }
+	  if (res_graph.target(e)==t) { _augment=true; break; }
 	}
 	
@@ -307,5 +307,5 @@
 	  ResGWEdge e=pred.get(n);
 	  res_graph.augment(e, augment_value); 
-	  n=res_graph.tail(e);
+	  n=res_graph.source(e);
 	}
       }
@@ -324,5 +324,5 @@
       int get(const typename MapGraphWrapper::Node& n) const { return dist[n]; }
       bool get(const typename MapGraphWrapper::Edge& e) const { 
-	return (dist.get(g->tail(e))<dist.get(g->head(e))); 
+	return (dist.get(g->source(e))<dist.get(g->target(e))); 
       }
     };
@@ -343,5 +343,5 @@
 	ResGWOutEdgeIt e=bfs;
 	if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
-	  dist.set(res_graph.head(e), dist.get(res_graph.tail(e))+1);
+	  dist.set(res_graph.target(e), dist.get(res_graph.source(e))+1);
 	}
 	++bfs;
@@ -369,6 +369,6 @@
 	typename FilterResGW::EdgeIt e;
 	for(filter_res_graph.first(e); filter_res_graph.valid(e); filter_res_graph.next(e)) {
-	  //if (dist.get(res_graph.head(e))==dist.get(res_graph.tail(e))+1) {
-	  typename MG::Edge f=F.addEdge(res_graph_to_F.get(res_graph.tail(e)), res_graph_to_F.get(res_graph.head(e)));
+	  //if (dist.get(res_graph.target(e))==dist.get(res_graph.source(e))+1) {
+	  typename MG::Edge f=F.addEdge(res_graph_to_F.get(res_graph.source(e)), res_graph_to_F.get(res_graph.target(e)));
 	  original_edge.update();
 	  original_edge.set(f, e);
@@ -423,5 +423,5 @@
 	    typename MG::Edge e=pred.get(n);
 	    res_graph.augment(original_edge.get(e), augment_value); 
-	    n=F.tail(e);
+	    n=F.source(e);
 	    if (residual_capacity.get(e)==augment_value) 
 	      F.erase(e); 
@@ -468,6 +468,6 @@
 	if (res_graph.valid(e)) {
 	  if (bfs.isBNodeNewlyReached()) {
-	    dist.set(res_graph.head(e), dist.get(res_graph.tail(e))+1);
-	    typename MG::Edge f=F.addEdge(res_graph_to_F.get(res_graph.tail(e)), res_graph_to_F.get(res_graph.head(e)));
+	    dist.set(res_graph.target(e), dist.get(res_graph.source(e))+1);
+	    typename MG::Edge f=F.addEdge(res_graph_to_F.get(res_graph.source(e)), res_graph_to_F.get(res_graph.target(e)));
 	    original_edge.update();
 	    original_edge.set(f, e);
@@ -475,6 +475,6 @@
 	    residual_capacity.set(f, res_graph.resCap(e));
 	  } else {
-	    if (dist.get(res_graph.head(e))==(dist.get(res_graph.tail(e))+1)) {
-	      typename MG::Edge f=F.addEdge(res_graph_to_F.get(res_graph.tail(e)), res_graph_to_F.get(res_graph.head(e)));
+	    if (dist.get(res_graph.target(e))==(dist.get(res_graph.source(e))+1)) {
+	      typename MG::Edge f=F.addEdge(res_graph_to_F.get(res_graph.source(e)), res_graph_to_F.get(res_graph.target(e)));
 	      original_edge.update();
 	      original_edge.set(f, e);
@@ -531,5 +531,5 @@
 	    typename MG::Edge e=pred.get(n);
 	    res_graph.augment(original_edge.get(e), augment_value); 
-	    n=F.tail(e);
+	    n=F.source(e);
 	    if (residual_capacity.get(e)==augment_value) 
 	      F.erase(e); 
@@ -557,5 +557,5 @@
  	ResGWOutEdgeIt e=bfs;
  	if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
- 	  dist.set(res_graph.head(e), dist.get(res_graph.tail(e))+1);
+ 	  dist.set(res_graph.target(e), dist.get(res_graph.source(e))+1);
  	}
 	++bfs;
@@ -633,5 +633,5 @@
  	    typename ErasingResGW::OutEdgeIt e=pred.get(n);
  	    res_graph.augment(e, augment_value);
- 	    n=erasing_res_graph.tail(e);
+ 	    n=erasing_res_graph.source(e);
  	    if (res_graph.resCap(e)==0)
  	      erasing_res_graph.erase(e);
@@ -728,6 +728,6 @@
 // 	AugOutEdgeIt e=bfs;
 // 	if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
-// 	  Node v=res_graph.tail(e);
-// 	  Node w=res_graph.head(e);
+// 	  Node v=res_graph.source(e);
+// 	  Node w=res_graph.target(e);
 // 	  pred.set(w, e);
 // 	  if (res_graph.valid(pred.get(v))) {
@@ -736,5 +736,5 @@
 // 	    free.set(w, res_graph.free(e)); 
 // 	  }
-// 	  n=res_graph.head(e);
+// 	  n=res_graph.target(e);
 // 	  if (T->get(n) && (used.get(n)<1) ) { 
 // 	    //Number u=0;
@@ -758,5 +758,5 @@
 // 	  AugEdge e=pred.get(n);
 // 	  res_graph.augment(e, augment_value); 
-// 	  n=res_graph.tail(e);
+// 	  n=res_graph.source(e);
 // 	}
 // 	used.set(n, 1); //mind2 vegen jav
@@ -799,5 +799,5 @@
 // // 	AugOutEdgeIt e=bfs;
 // // 	if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
-// // 	  dist.set(res_graph.head(e), dist.get(res_graph.tail(e))+1);
+// // 	  dist.set(res_graph.target(e), dist.get(res_graph.source(e))+1);
 // // 	}
 	
@@ -821,6 +821,6 @@
 // //       //which are in some shortest paths
 // //       for(typename AugGraph::EdgeIt e=res_graph.template first<typename AugGraph::EdgeIt>(); res_graph.valid(e); res_graph.next(e)) {
-// // 	if (dist.get(res_graph.head(e))==dist.get(res_graph.tail(e))+1) {
-// // 	  typename MutableGraph::Edge f=F.addEdge(res_graph_to_F.get(res_graph.tail(e)), res_graph_to_F.get(res_graph.head(e)));
+// // 	if (dist.get(res_graph.target(e))==dist.get(res_graph.source(e))+1) {
+// // 	  typename MutableGraph::Edge f=F.addEdge(res_graph_to_F.get(res_graph.source(e)), res_graph_to_F.get(res_graph.target(e)));
 // // 	  original_edge.update();
 // // 	  original_edge.set(f, e);
@@ -874,5 +874,5 @@
 // // 	    typename MutableGraph::Edge e=pred.get(n);
 // // 	    res_graph.augment(original_edge.get(e), augment_value); 
-// // 	    n=F.tail(e);
+// // 	    n=F.source(e);
 // // 	    if (residual_capacity.get(e)==augment_value) 
 // // 	      F.erase(e); 
@@ -925,5 +925,5 @@
 // 	typename ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::OutEdgeIt e=bfs;
 // 	if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
-// 	  dist.set(res_graph.head(e), dist.get(res_graph.tail(e))+1);
+// 	  dist.set(res_graph.target(e), dist.get(res_graph.source(e))+1);
 // 	}
 // 	++bfs;	
@@ -1002,5 +1002,5 @@
 // 	    EAugEdge e=pred.get(n);
 // 	    res_graph.augment(e, augment_value);
-// 	    n=res_graph.tail(e);
+// 	    n=res_graph.source(e);
 // 	    if (res_graph.free(e)==0)
 // 	      res_graph.erase(e);
@@ -1095,6 +1095,6 @@
 // // 	AugOutEdgeIt e=/*AugOutEdgeIt*/(bfs);
 // // 	if (e.valid() && bfs.isBNodeNewlyReached()) {
-// // 	  Node v=res_graph.tail(e);
-// // 	  Node w=res_graph.head(e);
+// // 	  Node v=res_graph.source(e);
+// // 	  Node w=res_graph.target(e);
 // // 	  pred.set(w, e);
 // // 	  if (pred.get(v).valid()) {
@@ -1103,7 +1103,7 @@
 // // 	    free.set(w, e.free()); 
 // // 	  }
-// // 	  if (TMap.get(res_graph.head(e))) { 
+// // 	  if (TMap.get(res_graph.target(e))) { 
 // // 	    _augment=true; 
-// // 	    reached_t_node=res_graph.head(e);
+// // 	    reached_t_node=res_graph.target(e);
 // // 	    break; 
 // // 	  }
@@ -1119,5 +1119,5 @@
 // // 	  AugEdge e=pred.get(n);
 // // 	  e.augment(augment_value); 
-// // 	  n=res_graph.tail(e);
+// // 	  n=res_graph.source(e);
 // // 	}
 // //       }
Index: src/work/marci/experiment/edmonds_karp_demo.cc
===================================================================
--- src/work/marci/experiment/edmonds_karp_demo.cc	(revision 921)
+++ src/work/marci/experiment/edmonds_karp_demo.cc	(revision 986)
@@ -105,13 +105,13 @@
     while (max_flow_test.augmentOnBlockingFlow<MutableGraph>()) { 
 //     for(EdgeIt e=G.template first<EdgeIt>(); e.valid(); ++e) { 
-//       std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
-//     }
-//     std::cout<<std::endl;
-      ++i; 
-    }
-
-//   std::cout << "maximum flow: "<< std::endl;
-//   for(EdgeIt e=G.first<EdgeIt>(); e.valid(); ++e) { 
-//     std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
+//       std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
+//     }
+//     std::cout<<std::endl;
+      ++i; 
+    }
+
+//   std::cout << "maximum flow: "<< std::endl;
+//   for(EdgeIt e=G.first<EdgeIt>(); e.valid(); ++e) { 
+//     std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
 //   }
 //   std::cout<<std::endl;
@@ -136,13 +136,13 @@
     while (max_flow_test.augmentOnBlockingFlow1<MutableGraph>()) { 
 //     for(EdgeIt e=G.template first<EdgeIt>(); e.valid(); ++e) { 
-//       std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
-//     }
-//     std::cout<<std::endl;
-      ++i; 
-    }
-
-//   std::cout << "maximum flow: "<< std::endl;
-//   for(EdgeIt e=G.first<EdgeIt>(); e.valid(); ++e) { 
-//     std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
+//       std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
+//     }
+//     std::cout<<std::endl;
+      ++i; 
+    }
+
+//   std::cout << "maximum flow: "<< std::endl;
+//   for(EdgeIt e=G.first<EdgeIt>(); e.valid(); ++e) { 
+//     std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
 //   }
 //   std::cout<<std::endl;
@@ -167,13 +167,13 @@
     while (max_flow_test.augmentOnBlockingFlow2()) { 
 //     for(EdgeIt e=G.template first<EdgeIt>(); e.valid(); ++e) { 
-//       std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
-//     }
-//     std::cout<<std::endl;
-      ++i; 
-    }
-
-//   std::cout << "maximum flow: "<< std::endl;
-//   for(EdgeIt e=G.first<EdgeIt>(); e.valid(); ++e) { 
-//     std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
+//       std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
+//     }
+//     std::cout<<std::endl;
+      ++i; 
+    }
+
+//   std::cout << "maximum flow: "<< std::endl;
+//   for(EdgeIt e=G.first<EdgeIt>(); e.valid(); ++e) { 
+//     std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
 //   }
 //   std::cout<<std::endl;
@@ -198,13 +198,13 @@
     while (max_flow_test.augmentOnShortestPath()) { 
 //     for(EdgeIt e=G.template first<EdgeIt>(); e.valid(); ++e) { 
-//       std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
-//     }
-//     std::cout<<std::endl;
-      ++i; 
-    }
-
-//   std::cout << "maximum flow: "<< std::endl;
-//   for(EdgeIt e=G.first<EdgeIt>(); e.valid(); ++e) { 
-//     std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
+//       std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
+//     }
+//     std::cout<<std::endl;
+      ++i; 
+    }
+
+//   std::cout << "maximum flow: "<< std::endl;
+//   for(EdgeIt e=G.first<EdgeIt>(); e.valid(); ++e) { 
+//     std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
 //   }
 //   std::cout<<std::endl;
Index: src/work/marci/experiment/edmonds_karp_demo_1.cc
===================================================================
--- src/work/marci/experiment/edmonds_karp_demo_1.cc	(revision 921)
+++ src/work/marci/experiment/edmonds_karp_demo_1.cc	(revision 986)
@@ -105,13 +105,13 @@
     while (max_flow_test.augmentOnBlockingFlow<MutableGraph>()) { 
 //     for(EdgeIt e=G.template first<EdgeIt>(); e.valid(); ++e) { 
-//       std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
-//     }
-//     std::cout<<std::endl;
-      ++i; 
-    }
-
-//   std::cout << "maximum flow: "<< std::endl;
-//   for(EdgeIt e=G.first<EdgeIt>(); e.valid(); ++e) { 
-//     std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
+//       std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
+//     }
+//     std::cout<<std::endl;
+      ++i; 
+    }
+
+//   std::cout << "maximum flow: "<< std::endl;
+//   for(EdgeIt e=G.first<EdgeIt>(); e.valid(); ++e) { 
+//     std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
 //   }
 //   std::cout<<std::endl;
@@ -136,13 +136,13 @@
     while (max_flow_test.augmentOnBlockingFlow1<MutableGraph>()) { 
 //     for(EdgeIt e=G.template first<EdgeIt>(); e.valid(); ++e) { 
-//       std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
-//     }
-//     std::cout<<std::endl;
-      ++i; 
-    }
-
-//   std::cout << "maximum flow: "<< std::endl;
-//   for(EdgeIt e=G.first<EdgeIt>(); e.valid(); ++e) { 
-//     std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
+//       std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
+//     }
+//     std::cout<<std::endl;
+      ++i; 
+    }
+
+//   std::cout << "maximum flow: "<< std::endl;
+//   for(EdgeIt e=G.first<EdgeIt>(); e.valid(); ++e) { 
+//     std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
 //   }
 //   std::cout<<std::endl;
@@ -167,13 +167,13 @@
     while (max_flow_test.augmentOnBlockingFlow2()) { 
 //     for(EdgeIt e=G.template first<EdgeIt>(); e.valid(); ++e) { 
-//       std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
-//     }
-//     std::cout<<std::endl;
-      ++i; 
-    }
-
-//   std::cout << "maximum flow: "<< std::endl;
-//   for(EdgeIt e=G.first<EdgeIt>(); e.valid(); ++e) { 
-//     std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
+//       std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
+//     }
+//     std::cout<<std::endl;
+      ++i; 
+    }
+
+//   std::cout << "maximum flow: "<< std::endl;
+//   for(EdgeIt e=G.first<EdgeIt>(); e.valid(); ++e) { 
+//     std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
 //   }
 //   std::cout<<std::endl;
@@ -198,13 +198,13 @@
     while (max_flow_test.augmentOnShortestPath()) { 
 //     for(EdgeIt e=G.template first<EdgeIt>(); e.valid(); ++e) { 
-//       std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
-//     }
-//     std::cout<<std::endl;
-      ++i; 
-    }
-
-//   std::cout << "maximum flow: "<< std::endl;
-//   for(EdgeIt e=G.first<EdgeIt>(); e.valid(); ++e) { 
-//     std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
+//       std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
+//     }
+//     std::cout<<std::endl;
+      ++i; 
+    }
+
+//   std::cout << "maximum flow: "<< std::endl;
+//   for(EdgeIt e=G.first<EdgeIt>(); e.valid(); ++e) { 
+//     std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
 //   }
 //   std::cout<<std::endl;
Index: src/work/marci/experiment/graph_wrapper.h
===================================================================
--- src/work/marci/experiment/graph_wrapper.h	(revision 921)
+++ src/work/marci/experiment/graph_wrapper.h	(revision 986)
@@ -97,6 +97,6 @@
       It e; first(e, v); return e; }
 
-    Node head(const Edge& e) const { return graph->head(e); }
-    Node tail(const Edge& e) const { return graph->tail(e); }
+    Node target(const Edge& e) const { return graph->target(e); }
+    Node source(const Edge& e) const { return graph->source(e); }
 
     template<typename I> bool valid(const I& i) const 
@@ -115,6 +115,6 @@
   
     Node addNode() const { return graph->addNode(); }
-    Edge addEdge(const Node& tail, const Node& head) const { 
-      return graph->addEdge(tail, head); }
+    Edge addEdge(const Node& source, const Node& target) const { 
+      return graph->addEdge(source, target); }
   
     template<typename I> void erase(const I& i) const { graph->erase(i); }
@@ -246,6 +246,6 @@
       It e; this->first(e, v); return e; }
 
-    Node head(const Edge& e) const { return gw.head(e); }
-    Node tail(const Edge& e) const { return gw.tail(e); }
+    Node target(const Edge& e) const { return gw.target(e); }
+    Node source(const Edge& e) const { return gw.source(e); }
 
     template<typename I> bool valid(const I& i) const { return gw.valid(i); }
@@ -261,6 +261,6 @@
   
     Node addNode() const { return gw.addNode(); }
-    Edge addEdge(const Node& tail, const Node& head) const { 
-      return gw.addEdge(tail, head); }
+    Edge addEdge(const Node& source, const Node& target) const { 
+      return gw.addEdge(source, target); }
   
     template<typename I> void erase(const I& i) const { gw.erase(i); }
@@ -323,6 +323,6 @@
 //       It e; first(e, v); return e; }
 
-//     Node head(const Edge& e) const { return graph->tail(e); }
-//     Node tail(const Edge& e) const { return graph->head(e); }
+//     Node target(const Edge& e) const { return graph->source(e); }
+//     Node source(const Edge& e) const { return graph->target(e); }
   
 //     template<typename I> bool valid(const I& i) const 
@@ -338,6 +338,6 @@
 
 //     Node addNode() const { return graph->addNode(); }
-//     Edge addEdge(const Node& tail, const Node& head) const { 
-//       return graph->addEdge(tail, head); }
+//     Edge addEdge(const Node& source, const Node& target) const { 
+//       return graph->addEdge(source, target); }
   
 //     int nodeNum() const { return graph->nodeNum(); }
@@ -404,6 +404,6 @@
 //     //  It e; first(e, v); return e; }
 
-//     //Node head(const Edge& e) const { return graph->tail(e); }
-//     //Node tail(const Edge& e) const { return graph->head(e); }
+//     //Node target(const Edge& e) const { return graph->source(e); }
+//     //Node source(const Edge& e) const { return graph->target(e); }
   
 //     //template<typename I> bool valid(const I& i) const 
@@ -419,6 +419,6 @@
 
 //     //Node addNode() const { return graph->addNode(); }
-//     //Edge addEdge(const Node& tail, const Node& head) const { 
-//     //  return graph->addEdge(tail, head); }
+//     //Edge addEdge(const Node& source, const Node& target) const { 
+//     //  return graph->addEdge(source, target); }
   
 //     //int nodeNum() const { return graph->nodeNum(); }
@@ -468,8 +468,8 @@
       GraphWrapper<GraphWrapper>(_gw) { }  
 
-    Node head(const Edge& e) const 
-      { return GraphWrapper<GraphWrapper>::tail(e); }
-    Node tail(const Edge& e) const 
-      { return GraphWrapper<GraphWrapper>::head(e); }
+    Node target(const Edge& e) const 
+      { return GraphWrapper<GraphWrapper>::source(e); }
+    Node source(const Edge& e) const 
+      { return GraphWrapper<GraphWrapper>::target(e); }
   };
 
@@ -600,5 +600,5 @@
 //     OutEdgeIt& next(OutEdgeIt& e) const {
 //       if (e.out_or_in) {
-// 	Node n=gw.tail(e.out);
+// 	Node n=gw.source(e.out);
 // 	gw.next(e.out);
 // 	if (!gw.valid(e.out)) {
@@ -613,7 +613,7 @@
 
 //     Node aNode(const OutEdgeIt& e) const { 
-//       if (e.out_or_in) return gw.tail(e); else return gw.head(e); }
+//       if (e.out_or_in) return gw.source(e); else return gw.target(e); }
 //     Node bNode(const OutEdgeIt& e) const { 
-//       if (e.out_or_in) return gw.head(e); else return gw.tail(e); }
+//       if (e.out_or_in) return gw.target(e); else return gw.source(e); }
 
 //     typedef OutEdgeIt InEdgeIt; 
@@ -633,6 +633,6 @@
 //       It e; first(e, v); return e; }
 
-//     Node head(const Edge& e) const { return gw.head(e); }
-//     Node tail(const Edge& e) const { return gw.tail(e); }
+//     Node target(const Edge& e) const { return gw.target(e); }
+//     Node source(const Edge& e) const { return gw.source(e); }
 
 //     template<typename I> bool valid(const I& i) const 
@@ -652,6 +652,6 @@
 //     Node addNode() const { return gw.addNode(); }
 // // FIXME: ez igy nem jo, mert nem
-// //    Edge addEdge(const Node& tail, const Node& head) const { 
-// //      return graph->addEdge(tail, head); }
+// //    Edge addEdge(const Node& source, const Node& target) const { 
+// //      return graph->addEdge(source, target); }
   
 //     template<typename I> void erase(const I& i) const { gw.erase(i); }
@@ -799,5 +799,5 @@
     OutEdgeIt& next(OutEdgeIt& e) const {
       if (e.out_or_in) {
-	Node n=gw.tail(e.out);
+	Node n=gw.source(e.out);
 	gw.next(e.out);
 	if (!gw.valid(e.out)) { e.out_or_in=false; gw.first(e.in, n); }
@@ -809,5 +809,5 @@
 
     EdgeIt& next(EdgeIt& e) const {
-      //NodeIt v=tail(e);
+      //NodeIt v=source(e);
       gw.next(e.out);
       while (valid(e.v) && !gw.valid(e.out)) { 
@@ -827,6 +827,6 @@
       It e; first(e, v); return e; }
 
-//    Node head(const Edge& e) const { return gw.head(e); }
-//    Node tail(const Edge& e) const { return gw.tail(e); }
+//    Node target(const Edge& e) const { return gw.target(e); }
+//    Node source(const Edge& e) const { return gw.source(e); }
 
 //    template<typename I> bool valid(const I& i) const 
@@ -842,13 +842,13 @@
 
     Node aNode(const OutEdgeIt& e) const { 
-      if (e.out_or_in) return gw.tail(e); else return gw.head(e); }
+      if (e.out_or_in) return gw.source(e); else return gw.target(e); }
     Node bNode(const OutEdgeIt& e) const { 
-      if (e.out_or_in) return gw.head(e); else return gw.tail(e); }
+      if (e.out_or_in) return gw.target(e); else return gw.source(e); }
   
 //    Node addNode() const { return gw.addNode(); }
 
 // FIXME: ez igy nem jo, mert nem
-//    Edge addEdge(const Node& tail, const Node& head) const { 
-//      return graph->addEdge(tail, head); }
+//    Edge addEdge(const Node& source, const Node& target) const { 
+//      return graph->addEdge(source, target); }
   
 //    template<typename I> void erase(const I& i) const { gw.erase(i); }
@@ -914,6 +914,6 @@
 //       It e; first(e, v); return e; }
 
-//     Node head(const Edge& e) const { return graph->head(e); }
-//     Node tail(const Edge& e) const { return graph->tail(e); }
+//     Node target(const Edge& e) const { return graph->target(e); }
+//     Node source(const Edge& e) const { return graph->source(e); }
   
 //     template<typename I> Node aNode(const I& e) const { 
@@ -929,6 +929,6 @@
   
 //     Node addNode() { return graph->addNode(); }
-//     Edge addEdge(const Node& tail, const Node& head) { 
-//       return graph->addEdge(tail, head); }
+//     Edge addEdge(const Node& source, const Node& target) { 
+//       return graph->addEdge(source, target); }
   
 //     template<typename I> void erase(const I& i) { graph->erase(i); }
@@ -1181,7 +1181,7 @@
     }
 
-    Node tail(Edge e) const { 
+    Node source(Edge e) const { 
       return ((e.out_or_in) ? gw.aNode(e.out) : gw.aNode(e.in)); }
-    Node head(Edge e) const { 
+    Node target(Edge e) const { 
       return ((e.out_or_in) ? gw.bNode(e.out) : gw.bNode(e.in)); }
 
@@ -1312,5 +1312,5 @@
       OutEdgeIt f=e;
       this->next(f);
-      first_out_edges->set(this->tail(e), f);
+      first_out_edges->set(this->source(e), f);
     }
   };
@@ -1382,6 +1382,6 @@
 //       It e; first(e, v); return e; }
 
-//     //Node head(const Edge& e) const { return gw.head(e); }
-//     //Node tail(const Edge& e) const { return gw.tail(e); }
+//     //Node target(const Edge& e) const { return gw.target(e); }
+//     //Node source(const Edge& e) const { return gw.source(e); }
 
 //     //template<typename I> bool valid(const I& i) const 
@@ -1397,14 +1397,14 @@
   
 //     //Node addNode() const { return gw.addNode(); }
-//     //Edge addEdge(const Node& tail, const Node& head) const { 
-//     //  return gw.addEdge(tail, head); }
+//     //Edge addEdge(const Node& source, const Node& target) const { 
+//     //  return gw.addEdge(source, target); }
   
 //     //void erase(const OutEdgeIt& e) {
-//     //  first_out_edge(this->tail(e))=e;
+//     //  first_out_edge(this->source(e))=e;
 //     //}
 //     void erase(const Edge& e) {
 //       OutEdgeIt f(e);
 //       next(f);
-//       first_out_edges.set(this->tail(e), f);
+//       first_out_edges.set(this->source(e), f);
 //     }
 //     //template<typename I> void erase(const I& i) const { gw.erase(i); }
@@ -1460,5 +1460,5 @@
 //     OutEdgeIt& first(OutEdgeIt& e, const Node& n) const {
 //       ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::first(e, n);
-//       while (valid(e) && (dist.get(tail(e))/*+1!=*/>=dist.get(head(e)))) 
+//       while (valid(e) && (dist.get(source(e))/*+1!=*/>=dist.get(target(e)))) 
 // 	ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::next(e);
 //       return e;
@@ -1471,5 +1471,5 @@
 //     OutEdgeIt& next(OutEdgeIt& e) const {
 //       ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::next(e);
-//       while (valid(e) && (dist.get(tail(e))/*+1!*/>=dist.get(head(e)))) 
+//       while (valid(e) && (dist.get(source(e))/*+1!*/>=dist.get(target(e)))) 
 // 	ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::next(e);
 //       return e;
@@ -1483,7 +1483,7 @@
 //       OutEdgeIt f(e);
 //       ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::next(f);
-//       while (valid(f) && (dist.get(tail(f))/*+1!=*/>=dist.get(head(f)))) 
+//       while (valid(f) && (dist.get(source(f))/*+1!=*/>=dist.get(target(f)))) 
 // 	ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::next(f);
-//       first_out_edges.set(this->tail(e), f);
+//       first_out_edges.set(this->source(e), f);
 //     }
 
@@ -1508,6 +1508,6 @@
 //       It e; first(e, v); return e; }
 
-//     //Node head(const Edge& e) const { return gw.head(e); }
-//     //Node tail(const Edge& e) const { return gw.tail(e); }
+//     //Node target(const Edge& e) const { return gw.target(e); }
+//     //Node source(const Edge& e) const { return gw.source(e); }
 
 //     //template<typename I> bool valid(const I& i) const 
@@ -1526,6 +1526,6 @@
   
 //     //Node addNode() const { return gw.addNode(); }
-//     //Edge addEdge(const Node& tail, const Node& head) const { 
-//     //  return gw.addEdge(tail, head); }
+//     //Edge addEdge(const Node& source, const Node& target) const { 
+//     //  return gw.addEdge(source, target); }
   
 //     //template<typename I> void erase(const I& i) const { gw.erase(i); }
@@ -1670,6 +1670,6 @@
 //       It e; first(e, v); return e; }
 
-//     Node head(const Edge& e) const { return gw.head(e); }
-//     Node tail(const Edge& e) const { return gw.tail(e); }
+//     Node target(const Edge& e) const { return gw.target(e); }
+//     Node source(const Edge& e) const { return gw.source(e); }
   
 //     template<typename I> Node aNode(const I& e) const { 
@@ -1685,6 +1685,6 @@
   
 //     Node addNode() { return gw.addNode(); }
-//     Edge addEdge(const Node& tail, const Node& head) { 
-//       return gw.addEdge(tail, head); }
+//     Edge addEdge(const Node& source, const Node& target) { 
+//       return gw.addEdge(source, target); }
   
 //     template<typename I> void erase(const I& i) { gw.erase(i); }
Index: src/work/marci/experiment/graph_wrapper_1.h
===================================================================
--- src/work/marci/experiment/graph_wrapper_1.h	(revision 921)
+++ src/work/marci/experiment/graph_wrapper_1.h	(revision 986)
@@ -91,6 +91,6 @@
       It e; this->first(e, v); return e; }
 
-    Node head(const Edge& e) const { return graph->head(e); }
-    Node tail(const Edge& e) const { return graph->tail(e); }
+    Node target(const Edge& e) const { return graph->target(e); }
+    Node source(const Edge& e) const { return graph->source(e); }
 
     template<typename I> bool valid(const I& i) const { 
@@ -109,6 +109,6 @@
   
     Node addNode() const { return graph->addNode(); }
-    Edge addEdge(const Node& tail, const Node& head) const { 
-      return graph->addEdge(tail, head); }
+    Edge addEdge(const Node& source, const Node& target) const { 
+      return graph->addEdge(source, target); }
   
     template<typename I> void erase(const I& i) const { graph->erase(i); }
@@ -236,6 +236,6 @@
       It e; this->first(e, v); return e; }
 
-    Node head(const Edge& e) const { return graph->head(e); }
-    Node tail(const Edge& e) const { return graph->tail(e); }
+    Node target(const Edge& e) const { return graph->target(e); }
+    Node source(const Edge& e) const { return graph->source(e); }
 
     template<typename I> bool valid(const I& i) const { 
@@ -254,6 +254,6 @@
   
     Node addNode() const { return graph->addNode(); }
-    Edge addEdge(const Node& tail, const Node& head) const { 
-      return graph->addEdge(tail, head); }
+    Edge addEdge(const Node& source, const Node& target) const { 
+      return graph->addEdge(source, target); }
   
     template<typename I> void erase(const I& i) const { graph->erase(i); }
@@ -317,6 +317,6 @@
 //       It e; first(e, v); return e; }
 
-//     Node head(const Edge& e) const { return graph->tail(e); }
-//     Node tail(const Edge& e) const { return graph->head(e); }
+//     Node target(const Edge& e) const { return graph->source(e); }
+//     Node source(const Edge& e) const { return graph->target(e); }
   
 //     template<typename I> bool valid(const I& i) const 
@@ -332,6 +332,6 @@
 
 //     Node addNode() const { return graph->addNode(); }
-//     Edge addEdge(const Node& tail, const Node& head) const { 
-//       return graph->addEdge(tail, head); }
+//     Edge addEdge(const Node& source, const Node& target) const { 
+//       return graph->addEdge(source, target); }
   
 //     int nodeNum() const { return graph->nodeNum(); }
@@ -379,8 +379,8 @@
     RevGraphWrapper(Graph& _graph) : GraphWrapper<Graph>(_graph) { }  
 
-    Node head(const Edge& e) const 
-      { return GraphWrapper<Graph>::tail(e); }
-    Node tail(const Edge& e) const 
-      { return GraphWrapper<Graph>::head(e); }
+    Node target(const Edge& e) const 
+      { return GraphWrapper<Graph>::source(e); }
+    Node source(const Edge& e) const 
+      { return GraphWrapper<Graph>::target(e); }
   };
 
@@ -512,5 +512,5 @@
 //     OutEdgeIt& next(OutEdgeIt& e) const {
 //       if (e.out_or_in) {
-// 	Node n=gw.tail(e.out);
+// 	Node n=gw.source(e.out);
 // 	gw.next(e.out);
 // 	if (!gw.valid(e.out)) {
@@ -525,7 +525,7 @@
 
 //     Node aNode(const OutEdgeIt& e) const { 
-//       if (e.out_or_in) return gw.tail(e); else return gw.head(e); }
+//       if (e.out_or_in) return gw.source(e); else return gw.target(e); }
 //     Node bNode(const OutEdgeIt& e) const { 
-//       if (e.out_or_in) return gw.head(e); else return gw.tail(e); }
+//       if (e.out_or_in) return gw.target(e); else return gw.source(e); }
 
 //     typedef OutEdgeIt InEdgeIt; 
@@ -545,6 +545,6 @@
 //       It e; first(e, v); return e; }
 
-//     Node head(const Edge& e) const { return gw.head(e); }
-//     Node tail(const Edge& e) const { return gw.tail(e); }
+//     Node target(const Edge& e) const { return gw.target(e); }
+//     Node source(const Edge& e) const { return gw.source(e); }
 
 //     template<typename I> bool valid(const I& i) const 
@@ -564,6 +564,6 @@
 //     Node addNode() const { return gw.addNode(); }
 // // FIXME: ez igy nem jo, mert nem
-// //    Edge addEdge(const Node& tail, const Node& head) const { 
-// //      return graph->addEdge(tail, head); }
+// //    Edge addEdge(const Node& source, const Node& target) const { 
+// //      return graph->addEdge(source, target); }
   
 //     template<typename I> void erase(const I& i) const { gw.erase(i); }
@@ -693,5 +693,5 @@
     OutEdgeIt& next(OutEdgeIt& e) const {
       if (e.out_or_in) {
-	Node n=graph->tail(e.out);
+	Node n=graph->source(e.out);
 	graph->next(e.out);
 	if (!graph->valid(e.out)) { e.out_or_in=false; graph->first(e.in, n); }
@@ -703,5 +703,5 @@
 
     EdgeIt& next(EdgeIt& e) const {
-      //NodeIt v=tail(e);
+      //NodeIt v=source(e);
       graph->next(e.out);
       while (valid(e.v) && !graph->valid(e.out)) { 
@@ -721,6 +721,6 @@
       It e; this->first(e, v); return e; }
 
-//    Node head(const Edge& e) const { return gw.head(e); }
-//    Node tail(const Edge& e) const { return gw.tail(e); }
+//    Node target(const Edge& e) const { return gw.target(e); }
+//    Node source(const Edge& e) const { return gw.source(e); }
 
 //    template<typename I> bool valid(const I& i) const 
@@ -736,13 +736,13 @@
 
     Node aNode(const OutEdgeIt& e) const { 
-      if (e.out_or_in) return graph->tail(e); else return graph->head(e); }
+      if (e.out_or_in) return graph->source(e); else return graph->target(e); }
     Node bNode(const OutEdgeIt& e) const { 
-      if (e.out_or_in) return graph->head(e); else return graph->tail(e); }
+      if (e.out_or_in) return graph->target(e); else return graph->source(e); }
   
 //    Node addNode() const { return gw.addNode(); }
 
 // FIXME: ez igy nem jo, mert nem
-//    Edge addEdge(const Node& tail, const Node& head) const { 
-//      return graph->addEdge(tail, head); }
+//    Edge addEdge(const Node& source, const Node& target) const { 
+//      return graph->addEdge(source, target); }
   
 //    template<typename I> void erase(const I& i) const { gw.erase(i); }
@@ -808,6 +808,6 @@
 //       It e; first(e, v); return e; }
 
-//     Node head(const Edge& e) const { return graph->head(e); }
-//     Node tail(const Edge& e) const { return graph->tail(e); }
+//     Node target(const Edge& e) const { return graph->target(e); }
+//     Node source(const Edge& e) const { return graph->source(e); }
   
 //     template<typename I> Node aNode(const I& e) const { 
@@ -823,6 +823,6 @@
   
 //     Node addNode() { return graph->addNode(); }
-//     Edge addEdge(const Node& tail, const Node& head) { 
-//       return graph->addEdge(tail, head); }
+//     Edge addEdge(const Node& source, const Node& target) { 
+//       return graph->addEdge(source, target); }
   
 //     template<typename I> void erase(const I& i) { graph->erase(i); }
@@ -1064,7 +1064,7 @@
     }
 
-    Node tail(Edge e) const { 
+    Node source(Edge e) const { 
       return ((e.out_or_in) ? graph->aNode(e.out) : graph->aNode(e.in)); }
-    Node head(Edge e) const { 
+    Node target(Edge e) const { 
       return ((e.out_or_in) ? graph->bNode(e.out) : graph->bNode(e.in)); }
 
@@ -1193,5 +1193,5 @@
       OutEdgeIt f=e;
       this->next(f);
-      first_out_edges->set(this->tail(e), f);
+      first_out_edges->set(this->source(e), f);
     }
   };
@@ -1311,6 +1311,6 @@
 //       It e; first(e, v); return e; }
 
-//     Node head(const Edge& e) const { return gw.head(e); }
-//     Node tail(const Edge& e) const { return gw.tail(e); }
+//     Node target(const Edge& e) const { return gw.target(e); }
+//     Node source(const Edge& e) const { return gw.source(e); }
   
 //     template<typename I> Node aNode(const I& e) const { 
@@ -1326,6 +1326,6 @@
   
 //     Node addNode() { return gw.addNode(); }
-//     Edge addEdge(const Node& tail, const Node& head) { 
-//       return gw.addEdge(tail, head); }
+//     Edge addEdge(const Node& source, const Node& target) { 
+//       return gw.addEdge(source, target); }
   
 //     template<typename I> void erase(const I& i) { gw.erase(i); }
Index: src/work/marci/experiment/graph_wrapper_st_ostream_op.h
===================================================================
--- src/work/marci/experiment/graph_wrapper_st_ostream_op.h	(revision 921)
+++ src/work/marci/experiment/graph_wrapper_st_ostream_op.h	(revision 986)
@@ -167,8 +167,8 @@
     EdgeIt& next(EdgeIt& i) const { graph->next(i.e); return i; }    
 
-    Node tail(const Edge& e) const { 
-      return Node(graph->tail(static_cast<typename Graph::Edge>(e))); }
-    Node head(const Edge& e) const { 
-      return Node(graph->head(static_cast<typename Graph::Edge>(e))); }
+    Node source(const Edge& e) const { 
+      return Node(graph->source(static_cast<typename Graph::Edge>(e))); }
+    Node target(const Edge& e) const { 
+      return Node(graph->target(static_cast<typename Graph::Edge>(e))); }
 
     bool valid(const Node& n) const { 
@@ -186,6 +186,6 @@
   
     Node addNode() const { return Node(graph->addNode()); }
-    Edge addEdge(const Node& tail, const Node& head) const { 
-      return Edge(graph->addEdge(tail, head)); }
+    Edge addEdge(const Node& source, const Node& target) const { 
+      return Edge(graph->addEdge(source, target)); }
 
     void erase(const Node& i) const { graph->erase(i); }
@@ -273,8 +273,8 @@
       return Node(this->graph->bNode(e.e)); }
 
-    Node tail(const Edge& e) const { 
-      return GraphWrapper<Graph>::head(e); }
-    Node head(const Edge& e) const { 
-      return GraphWrapper<Graph>::tail(e); }
+    Node source(const Edge& e) const { 
+      return GraphWrapper<Graph>::target(e); }
+    Node target(const Edge& e) const { 
+      return GraphWrapper<Graph>::source(e); }
 
   };
@@ -490,5 +490,5 @@
     OutEdgeIt& next(OutEdgeIt& e) const {
       if (e.out_or_in) {
-	typename Graph::Node n=this->graph->tail(e.out);
+	typename Graph::Node n=this->graph->source(e.out);
 	this->graph->next(e.out);
 	if (!this->graph->valid(e.out)) { 
@@ -507,9 +507,9 @@
 
     Node aNode(const OutEdgeIt& e) const { 
-      if (e.out_or_in) return this->graph->tail(e); else 
-	return this->graph->head(e); }
+      if (e.out_or_in) return this->graph->source(e); else 
+	return this->graph->target(e); }
     Node bNode(const OutEdgeIt& e) const { 
-      if (e.out_or_in) return this->graph->head(e); else 
-	return this->graph->tail(e); }
+      if (e.out_or_in) return this->graph->target(e); else 
+	return this->graph->source(e); }
   };
   
@@ -725,8 +725,8 @@
     }
 
-    Node tail(Edge e) const { 
-      return ((e.forward) ? this->graph->tail(e) : this->graph->head(e)); }
-    Node head(Edge e) const { 
-      return ((e.forward) ? this->graph->head(e) : this->graph->tail(e)); }
+    Node source(Edge e) const { 
+      return ((e.forward) ? this->graph->source(e) : this->graph->target(e)); }
+    Node target(Edge e) const { 
+      return ((e.forward) ? this->graph->target(e) : this->graph->source(e)); }
 
     Node aNode(OutEdgeIt e) const { 
@@ -914,5 +914,5 @@
       OutEdgeIt f=e;
       this->next(f);
-      first_out_edges->set(this->tail(e), f.e);
+      first_out_edges->set(this->source(e), f.e);
     }
   };
@@ -1042,15 +1042,15 @@
     InEdgeIt& next(InEdgeIt& i) const { this->graph->next(i.e); return i; }
 
-    Node tail(const Edge& e) { 
-      if (!(*(this->s_false_t_true_map))[this->graph->tail(e)]) 
-	return Node(this->graph->tail(e));
+    Node source(const Edge& e) { 
+      if (!(*(this->s_false_t_true_map))[this->graph->source(e)]) 
+	return Node(this->graph->source(e));
       else
-	return Node(this->graph->head(e));	
-    }
-    Node head(const Edge& e) { 
-      if (!(*(this->s_false_t_true_map))[this->graph->tail(e)]) 
-	return Node(this->graph->head(e));
+	return Node(this->graph->target(e));	
+    }
+    Node target(const Edge& e) { 
+      if (!(*(this->s_false_t_true_map))[this->graph->source(e)]) 
+	return Node(this->graph->target(e));
       else
-	return Node(this->graph->tail(e));	
+	return Node(this->graph->source(e));	
     }
 
@@ -1470,8 +1470,8 @@
     }    
 
-    Node tail(const Edge& e) const { 
+    Node source(const Edge& e) const { 
       switch (e.spec) {
       case 0: 
-	return Node(this->graph->tail(e));
+	return Node(this->graph->source(e));
 	break;
       case 1:
@@ -1484,8 +1484,8 @@
       }
     }
-    Node head(const Edge& e) const { 
+    Node target(const Edge& e) const { 
       switch (e.spec) {
       case 0: 
-	return Node(this->graph->head(e));
+	return Node(this->graph->target(e));
 	break;
       case 1:
@@ -1507,8 +1507,8 @@
     }
   
-    Node aNode(const OutEdgeIt& e) const { return tail(e); }
-    Node aNode(const InEdgeIt& e) const { return head(e); }
-    Node bNode(const OutEdgeIt& e) const { return head(e); }
-    Node bNode(const InEdgeIt& e) const { return tail(e); }
+    Node aNode(const OutEdgeIt& e) const { return source(e); }
+    Node aNode(const InEdgeIt& e) const { return target(e); }
+    Node bNode(const OutEdgeIt& e) const { return target(e); }
+    Node bNode(const InEdgeIt& e) const { return source(e); }
 
     void addNode() const { }
@@ -1516,6 +1516,6 @@
     
 //    Node addNode() const { return Node(this->graph->addNode()); }
-//    Edge addEdge(const Node& tail, const Node& head) const { 
-//      return Edge(this->graph->addEdge(tail, head)); }
+//    Edge addEdge(const Node& source, const Node& target) const { 
+//      return Edge(this->graph->addEdge(source, target)); }
 
 //    void erase(const Node& i) const { this->graph->erase(i); }
Index: src/work/marci/experiment/iterator_bfs_demo.cc
===================================================================
--- src/work/marci/experiment/iterator_bfs_demo.cc	(revision 921)
+++ src/work/marci/experiment/iterator_bfs_demo.cc	(revision 986)
@@ -23,5 +23,5 @@
   string get(typename Graph::Edge e) const { 
     return 
-      (node_name_map.get(graph.tail(e))+"->"+node_name_map.get(graph.head(e)));
+      (node_name_map.get(graph.source(e))+"->"+node_name_map.get(graph.target(e)));
   }
 };
Index: src/work/marci/experiment/iterator_bfs_demo_1.cc
===================================================================
--- src/work/marci/experiment/iterator_bfs_demo_1.cc	(revision 921)
+++ src/work/marci/experiment/iterator_bfs_demo_1.cc	(revision 986)
@@ -23,5 +23,5 @@
   string get(typename Graph::Edge e) const { 
     return 
-      (node_name_map.get(graph.tail(e))+"->"+node_name_map.get(graph.head(e)));
+      (node_name_map.get(graph.source(e))+"->"+node_name_map.get(graph.target(e)));
   }
 };
Index: src/work/marci/experiment/list_graph.h
===================================================================
--- src/work/marci/experiment/list_graph.h	(revision 921)
+++ src/work/marci/experiment/list_graph.h	(revision 986)
@@ -123,6 +123,6 @@
       //ListGraph* G;
       int id;
-      node_item* _tail;
-      node_item* _head;
+      node_item* _source;
+      node_item* _target;
       edge_item* _next_out;
       edge_item* _prev_out;
@@ -150,20 +150,20 @@
     }
 
-    edge_item* _add_edge(node_item* _tail, node_item* _head) {
+    edge_item* _add_edge(node_item* _source, node_item* _target) {
       edge_item* e=new edge_item;
       e->id=edge_id++;
-      e->_tail=_tail;
-      e->_head=_head;
-      
-      e->_prev_out=_tail->_last_out_edge;
-      if (_tail->_last_out_edge) (_tail->_last_out_edge)->_next_out=e;
-      _tail->_last_out_edge=e;
-      if (!_tail->_first_out_edge) _tail->_first_out_edge=e; 
+      e->_source=_source;
+      e->_target=_target;
+      
+      e->_prev_out=_source->_last_out_edge;
+      if (_source->_last_out_edge) (_source->_last_out_edge)->_next_out=e;
+      _source->_last_out_edge=e;
+      if (!_source->_first_out_edge) _source->_first_out_edge=e; 
       e->_next_out=0;
  
-      e->_prev_in=_head->_last_in_edge;
-      if (_head->_last_in_edge) (_head->_last_in_edge)->_next_in=e;
-      _head->_last_in_edge=e;
-      if (!_head->_first_in_edge) { _head->_first_in_edge=e; } 
+      e->_prev_in=_target->_last_in_edge;
+      if (_target->_last_in_edge) (_target->_last_in_edge)->_next_in=e;
+      _target->_last_in_edge=e;
+      if (!_target->_first_in_edge) { _target->_first_in_edge=e; } 
       e->_next_in=0;
 
@@ -185,11 +185,11 @@
     void _delete_edge(edge_item* e) {
       if (e->_next_out) (e->_next_out)->_prev_out=e->_prev_out; else 
-	(e->_tail)->_last_out_edge=e->_prev_out;
+	(e->_source)->_last_out_edge=e->_prev_out;
       if (e->_prev_out) (e->_prev_out)->_next_out=e->_next_out; else 
-	(e->_tail)->_first_out_edge=e->_next_out;
+	(e->_source)->_first_out_edge=e->_next_out;
       if (e->_next_in) (e->_next_in)->_prev_in=e->_prev_in; else 
-	(e->_head)->_last_in_edge=e->_prev_in;
+	(e->_target)->_last_in_edge=e->_prev_in;
       if (e->_prev_in) (e->_prev_in)->_next_in=e->_next_in; else 
-	(e->_head)->_first_in_edge=e->_next_in;
+	(e->_target)->_first_in_edge=e->_next_in;
 
       delete e;
@@ -197,31 +197,31 @@
     }
 
-    void _set_tail(edge_item* e, node_item* _tail) {
+    void _set_source(edge_item* e, node_item* _source) {
       if (e->_next_out) (e->_next_out)->_prev_out=e->_prev_out; else 
-	(e->_tail)->_last_out_edge=e->_prev_out;
+	(e->_source)->_last_out_edge=e->_prev_out;
       if (e->_prev_out) (e->_prev_out)->_next_out=e->_next_out; else 
-	(e->_tail)->_first_out_edge=e->_next_out;
-      
-      e->_tail=_tail;
-      
-      e->_prev_out=_tail->_last_out_edge;
-      if (_tail->_last_out_edge) (_tail->_last_out_edge)->_next_out=e;
-      _tail->_last_out_edge=e;
-      if (!_tail->_first_out_edge) _tail->_first_out_edge=e; 
+	(e->_source)->_first_out_edge=e->_next_out;
+      
+      e->_source=_source;
+      
+      e->_prev_out=_source->_last_out_edge;
+      if (_source->_last_out_edge) (_source->_last_out_edge)->_next_out=e;
+      _source->_last_out_edge=e;
+      if (!_source->_first_out_edge) _source->_first_out_edge=e; 
       e->_next_out=0;
     }
 
-    void _set_head(edge_item* e, node_item* _head) {
+    void _set_target(edge_item* e, node_item* _target) {
       if (e->_next_in) (e->_next_in)->_prev_in=e->_prev_in; else 
-	(e->_head)->_last_in_edge=e->_prev_in;
+	(e->_target)->_last_in_edge=e->_prev_in;
       if (e->_prev_in) (e->_prev_in)->_next_in=e->_next_in; else 
-	(e->_head)->_first_in_edge=e->_next_in;
-      
-      e->_head=_head;
-      
-      e->_prev_in=_head->_last_in_edge;
-      if (_head->_last_in_edge) (_head->_last_in_edge)->_next_in=e;
-      _head->_last_in_edge=e;
-      if (!_head->_first_in_edge) { _head->_first_in_edge=e; } 
+	(e->_target)->_first_in_edge=e->_next_in;
+      
+      e->_target=_target;
+      
+      e->_prev_in=_target->_last_in_edge;
+      if (_target->_last_in_edge) (_target->_last_in_edge)->_next_in=e;
+      _target->_last_in_edge=e;
+      if (!_target->_first_in_edge) { _target->_first_in_edge=e; } 
       e->_next_in=0;
     }
@@ -248,6 +248,6 @@
     //InEdgeIt firstInEdge(const Node v) const { return InEdgeIt(v); }
     //SymEdgeIt firstSymEdge(const Node v) const { return SymEdgeIt(v); }
-    Node tail(Edge e) const { return e.tailNode(); }
-    Node head(Edge e) const { return e.headNode(); }
+    Node source(Edge e) const { return e.sourceNode(); }
+    Node target(Edge e) const { return e.targetNode(); }
 
     Node aNode(const OutEdgeIt& e) const { return e.aNode(); }
@@ -278,6 +278,6 @@
     SymEdgeIt& /*getF*/first(SymEdgeIt& e, Node v) const { 
       e=SymEdgeIt(*this, v); return e; }
-    //void getTail(Node& n, const Edge& e) const { n=tail(e); }
-    //void getHead(Node& n, const Edge& e) const { n=head(e); }
+    //void getSource(Node& n, const Edge& e) const { n=source(e); }
+    //void getTarget(Node& n, const Edge& e) const { n=target(e); }
 
     //void getANode(Node& n, const OutEdgeIt& e) const { n=e.aNode(); }
@@ -346,10 +346,10 @@
     }
 
-    void setTail(Edge e, Node tail) {
-      _set_tail(e.edge, tail.node); 
-    }
-
-    void setHead(Edge e, Node head) {
-      _set_head(e.edge, head.node); 
+    void setSource(Edge e, Node source) {
+      _set_source(e.edge, source.node); 
+    }
+
+    void setTarget(Edge e, Node target) {
+      _set_target(e.edge, target.node); 
     }
 
@@ -360,5 +360,5 @@
     }
     friend std::ostream& operator<<(std::ostream& os, const Edge& i) { 
-      os << "(" << i.edge->_tail->id << "--" << i.edge->id << "->" << i.edge->_head->id << ")"; 
+      os << "(" << i.edge->_source->id << "--" << i.edge->id << "->" << i.edge->_target->id << ")"; 
       return os; 
     }
@@ -427,6 +427,6 @@
       friend bool operator!=(Edge u, Edge v) { return v.edge!=u.edge; } 
     protected:
-      Node tailNode() const { return Node(edge->_tail); }
-      Node headNode() const { return Node(edge->_head); }
+      Node sourceNode() const { return Node(edge->_source); }
+      Node targetNode() const { return Node(edge->_target); }
     public:
       friend std::ostream& operator<<(std::ostream& os, const Edge& i);
@@ -448,5 +448,5 @@
       EdgeIt(edge_item* _e) : Edge(_e) { }
       EdgeIt& operator++() { 
-	node_item* v=edge->_tail;
+	node_item* v=edge->_source;
 	edge=edge->_next_out; 
 	while (v && !edge) { v=v->_next_node; if (v) edge=v->_first_out_edge; }
@@ -468,6 +468,6 @@
       OutEdgeIt& operator++() { edge=edge->_next_out; return *this; }
     protected:
-      Node aNode() const { return Node(edge->_tail); }
-      Node bNode() const { return Node(edge->_head); }
+      Node aNode() const { return Node(edge->_source); }
+      Node bNode() const { return Node(edge->_target); }
     };
     
@@ -485,6 +485,6 @@
       InEdgeIt& operator++() { edge=edge->_next_in; return *this; }
     protected:
-      Node aNode() const { return Node(edge->_head); }
-      Node bNode() const { return Node(edge->_tail); }
+      Node aNode() const { return Node(edge->_target); }
+      Node bNode() const { return Node(edge->_source); }
     };
 
@@ -511,5 +511,5 @@
       SymEdgeIt& operator++() { 
 	if (out_or_in) { 
-	  node_item* v=edge->_tail;
+	  node_item* v=edge->_source;
 	  edge=edge->_next_out; 
 	  if (!edge) { out_or_in=0; edge=v->_first_in_edge; }
@@ -521,7 +521,7 @@
     protected:
       Node aNode() const { 
-	return (out_or_in) ? Node(edge->_tail) : Node(edge->_head); }
+	return (out_or_in) ? Node(edge->_source) : Node(edge->_target); }
       Node bNode() const { 
-	return (out_or_in) ? Node(edge->_head) : Node(edge->_tail); }
+	return (out_or_in) ? Node(edge->_target) : Node(edge->_source); }
     };
 
Index: src/work/marci/graph_concept.h
===================================================================
--- src/work/marci/graph_concept.h	(revision 921)
+++ src/work/marci/graph_concept.h	(revision 986)
@@ -104,8 +104,8 @@
 
 
-    /// Gives back the head node of an edge.
-    Node head(const Edge&) const { return INVALID; }
-    /// Gives back the tail node of an edge.
-    Node tail(const Edge&) const { return INVALID; }
+    /// Gives back the target node of an edge.
+    Node target(const Edge&) const { return INVALID; }
+    /// Gives back the source node of an edge.
+    Node source(const Edge&) const { return INVALID; }
   
     //   Node aNode(SymEdgeIt) const {}
@@ -143,8 +143,8 @@
     /// \brief Add a new edge to the graph.
     ///
-    /// Add a new edge to the graph with tail node \c tail
-    /// and head node \c head.
+    /// Add a new edge to the graph with source node \c source
+    /// and target node \c target.
     /// \return the new edge.
-    Edge addEdge(const Node& tail, const Node& head) { return INVALID; }
+    Edge addEdge(const Node& source, const Node& target) { return INVALID; }
     
     /// \brief Resets the graph.
Index: src/work/marci/iterator_bfs_demo.cc
===================================================================
--- src/work/marci/iterator_bfs_demo.cc	(revision 921)
+++ src/work/marci/iterator_bfs_demo.cc	(revision 986)
@@ -24,5 +24,5 @@
   string operator[](typename Graph::Edge e) const { 
     return 
-      (node_name_map[graph.tail(e)]+"->"+node_name_map[graph.head(e)]);
+      (node_name_map[graph.source(e)]+"->"+node_name_map[graph.target(e)]);
   }
 };
@@ -96,12 +96,12 @@
       if (Graph::Edge(bfs)!=INVALID) {
 	cout << edge_name[bfs] << /*endl*/", " << 
-	  node_name[G.tail(bfs)] << 
-	  (bfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") << 
-	  node_name[G.head(bfs)] << 
+	  node_name[G.source(bfs)] << 
+	  (bfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") << 
+	  node_name[G.target(bfs)] << 
 	  (bfs.isBNodeNewlyReached() ? ": is newly reached." : 
 	   ": is not newly reached.");
       } else { 
 	cout << "invalid" << /*endl*/", " << 
-	  node_name[bfs.tail()] << 
+	  node_name[bfs.source()] << 
 	  (bfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") << 
 	  
@@ -130,12 +130,12 @@
       if (Graph::Edge(dfs)!=INVALID) {
 	cout << edge_name[dfs] << /*endl*/", " << 
-	  node_name[G.tail(dfs)] << 
-	  (dfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") << 
-	  node_name[G.head(dfs)] << 
+	  node_name[G.source(dfs)] << 
+	  (dfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") << 
+	  node_name[G.target(dfs)] << 
 	  (dfs.isBNodeNewlyReached() ? ": is newly reached." : 
 	   ": is not newly reached.");
       } else { 
 	cout << "invalid" << /*endl*/", " << 
-	  node_name[dfs.tail()] << 
+	  node_name[dfs.source()] << 
 	  (dfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") << 
 	  
@@ -172,12 +172,12 @@
       if (GW::Edge(bfs)!=INVALID) {
 	cout << edge_name[GW::Edge(bfs)] << /*endl*/", " << 
-	  node_name[gw.tail(bfs)] << 
-	  (bfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") << 
-	  node_name[gw.head(bfs)] << 
+	  node_name[gw.source(bfs)] << 
+	  (bfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") << 
+	  node_name[gw.target(bfs)] << 
 	  (bfs.isBNodeNewlyReached() ? ": is newly reached." : 
 	   ": is not newly reached.");
       } else { 
 	cout << "invalid" << /*endl*/", " << 
-	  node_name[bfs.tail()] << 
+	  node_name[bfs.source()] << 
 	  (bfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") << 
 	  
@@ -206,12 +206,12 @@
       if (GW::Edge(dfs)!=INVALID) {
 	cout << edge_name[GW::Edge(dfs)] << /*endl*/", " << 
-	  node_name[gw.tail(dfs)] << 
-	  (dfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") << 
-	  node_name[gw.head(dfs)] << 
+	  node_name[gw.source(dfs)] << 
+	  (dfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") << 
+	  node_name[gw.target(dfs)] << 
 	  (dfs.isBNodeNewlyReached() ? ": is newly reached." : 
 	   ": is not newly reached.");
       } else { 
 	cout << "invalid" << /*endl*/", " << 
-	  node_name[dfs.tail()] << 
+	  node_name[dfs.source()] << 
 	  (dfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") << 
 	  
@@ -311,5 +311,5 @@
     cout << "bfs and dfs iterator demo on the bidirected graph" << endl;
 //     for(GW::EdgeIt e(gw); e!=INVALID; ++e) {
-//       cout << node_name[gw.tail(e)] << "->" << node_name[gw.head(e)] << " ";
+//       cout << node_name[gw.source(e)] << "->" << node_name[gw.target(e)] << " ";
 //     } 
     for(GW::NodeIt n(gw); n!=INVALID; ++n) { 
@@ -335,12 +335,12 @@
       if (GW::Edge(bfs)!=INVALID) {
 	cout << edge_name[GW::Edge(bfs)] << /*endl*/", " << 
-	  node_name[gw.tail(bfs)] << 
-	  (bfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") << 
-	  node_name[gw.head(bfs)] << 
+	  node_name[gw.source(bfs)] << 
+	  (bfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") << 
+	  node_name[gw.target(bfs)] << 
 	  (bfs.isBNodeNewlyReached() ? ": is newly reached." : 
 	   ": is not newly reached.");
       } else { 
 	cout << "invalid" << /*endl*/", " << 
-	  node_name[bfs.tail()] << 
+	  node_name[bfs.source()] << 
 	  (bfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") << 
 	  
@@ -369,12 +369,12 @@
       if (GW::Edge(dfs)!=INVALID) {
 	cout << edge_name[GW::Edge(dfs)] << /*endl*/", " << 
-	  node_name[gw.tail(dfs)] << 
-	  (dfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") << 
-	  node_name[gw.head(dfs)] << 
+	  node_name[gw.source(dfs)] << 
+	  (dfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") << 
+	  node_name[gw.target(dfs)] << 
 	  (dfs.isBNodeNewlyReached() ? ": is newly reached." : 
 	   ": is not newly reached.");
       } else { 
 	cout << "invalid" << /*endl*/", " << 
-	  node_name[dfs.tail()] << 
+	  node_name[dfs.source()] << 
 	  (dfs.isANodeExamined() ? ": is examined, " : ": is not examined, ") << 
 	  
Index: src/work/marci/leda/bipartite_matching_comparison.cc
===================================================================
--- src/work/marci/leda/bipartite_matching_comparison.cc	(revision 921)
+++ src/work/marci/leda/bipartite_matching_comparison.cc	(revision 986)
@@ -130,5 +130,5 @@
 
   FOR_EACH_LOC(BGW::EdgeIt, e, bgw) 
-    hg.addEdge(b_s_nodes[bgw.tail(e)], b_t_nodes[bgw.head(e)]);
+    hg.addEdge(b_s_nodes[bgw.source(e)], b_t_nodes[bgw.target(e)]);
 
   ConstMap<SageGraph::Edge, int> cm(1);
Index: src/work/marci/leda/leda_graph_wrapper.h
===================================================================
--- src/work/marci/leda/leda_graph_wrapper.h	(revision 921)
+++ src/work/marci/leda/leda_graph_wrapper.h	(revision 986)
@@ -214,19 +214,19 @@
 //     }
 
-    ///Gives back the head node of an edge.
-    Node head(Edge e) const { 
+    ///Gives back the target node of an edge.
+    Node target(Edge e) const { 
       return Node(l_graph->target(e.l_e)); 
     }
-    ///Gives back the tail node of an edge.
-    Node tail(Edge e) const { 
+    ///Gives back the source node of an edge.
+    Node source(Edge e) const { 
       return Node(l_graph->source(e.l_e)); 
     }
   
-    Node aNode(InEdgeIt e) const { return head(e); }
-    Node aNode(OutEdgeIt e) const { return tail(e); }
+    Node aNode(InEdgeIt e) const { return target(e); }
+    Node aNode(OutEdgeIt e) const { return source(e); }
     //   Node aNode(SymEdgeIt) const {}
 
-    Node bNode(InEdgeIt e) const { return tail(e); }
-    Node bNode(OutEdgeIt e) const { return head(e); }
+    Node bNode(InEdgeIt e) const { return source(e); }
+    Node bNode(OutEdgeIt e) const { return target(e); }
     //   Node bNode(SymEdgeIt) const {}
 
@@ -245,6 +245,6 @@
   
     Node addNode() const { return Node(l_graph->new_node()); }
-    Edge addEdge(Node tail, Node head) const { 
-      return Edge(l_graph->new_edge(tail.l_n, head.l_n));
+    Edge addEdge(Node source, Node target) const { 
+      return Edge(l_graph->new_edge(source.l_n, target.l_n));
     }
     
Index: src/work/marci/leda/max_bipartite_matching_demo.cc
===================================================================
--- src/work/marci/leda/max_bipartite_matching_demo.cc	(revision 921)
+++ src/work/marci/leda/max_bipartite_matching_demo.cc	(revision 986)
@@ -104,8 +104,8 @@
 //     cout << "out edges: ";
 //     for(OutEdgeIt e=G.first<OutEdgeIt>(n); G.valid(e); G.next(e)) 
-//       cout << G.id(G.tail(e)) << "->" << G.id(G.head(e)) << " ";
+//       cout << G.id(G.source(e)) << "->" << G.id(G.target(e)) << " ";
 //     cout << "in edges: ";
 //     for(InEdgeIt e=G.first<InEdgeIt>(n); G.valid(e); G.next(e)) 
-//       cout << G.id(G.tail(e)) << "->" << G.id(G.head(e)) << " ";
+//       cout << G.id(G.source(e)) << "->" << G.id(G.target(e)) << " ";
 //     cout << endl;
 //   }
@@ -124,5 +124,5 @@
     while (max_flow_test.augmentOnShortestPath()) { 
 //       for(EdgeIt e=G.first<EdgeIt>(); G.valid(e); G.next(e))  
-// 	std::cout << G.id(G.tail(e)) << "-" << flow.get(e) << "->" << G.id(G.head(e)) << " ";
+// 	std::cout << G.id(G.source(e)) << "-" << flow.get(e) << "->" << G.id(G.target(e)) << " ";
 //       std::cout<<std::endl;
       ++i; 
@@ -132,10 +132,10 @@
 //     for(EdgeIt e=G.first<EdgeIt>(); G.valid(e); G.next(e))  
 //       if (flow.get(e))
-// 	std::cout << G.id(G.tail(e)) << "-" << flow.get(e) << "->" << G.id(G.head(e)) << " ";
+// 	std::cout << G.id(G.source(e)) << "-" << flow.get(e) << "->" << G.id(G.target(e)) << " ";
 //     std::cout<<std::endl;
 //     std::cout << "edges which are not in this maximum matching: "<< std::endl;
 //     for(EdgeIt e=G.first<EdgeIt>(); G.valid(e); G.next(e))  
 //       if (!flow.get(e))
-// 	std::cout << G.id(G.tail(e)) << "-" << flow.get(e) << "->" << G.id(G.head(e)) << " ";
+// 	std::cout << G.id(G.source(e)) << "-" << flow.get(e) << "->" << G.id(G.target(e)) << " ";
 //     std::cout<<std::endl;
     
@@ -157,5 +157,5 @@
 //     while (max_flow_test.augmentOnBlockingFlow2()) { 
 // //       for(EdgeIt e=G.first<EdgeIt>(); G.valid(e); G.next(e))  
-// // 	std::cout << G.id(G.tail(e)) << "-" << flow.get(e) << "->" << G.id(G.head(e)) << " ";
+// // 	std::cout << G.id(G.source(e)) << "-" << flow.get(e) << "->" << G.id(G.target(e)) << " ";
 // //       std::cout<<std::endl;
 //       ++i; 
@@ -165,10 +165,10 @@
 // //     for(EdgeIt e=G.first<EdgeIt>(); G.valid(e); G.next(e))  
 // //       if (flow.get(e))
-// // 	std::cout << G.id(G.tail(e)) << "-" << flow.get(e) << "->" << G.id(G.head(e)) << " ";
+// // 	std::cout << G.id(G.source(e)) << "-" << flow.get(e) << "->" << G.id(G.target(e)) << " ";
 // //     std::cout<<std::endl;
 // //     std::cout << "edges which are not in this maximum matching: "<< std::endl;
 // //     for(EdgeIt e=G.first<EdgeIt>(); G.valid(e); G.next(e))  
 // //       if (!flow.get(e))
-// // 	std::cout << G.id(G.tail(e)) << "-" << flow.get(e) << "->" << G.id(G.head(e)) << " ";
+// // 	std::cout << G.id(G.source(e)) << "-" << flow.get(e) << "->" << G.id(G.target(e)) << " ";
 // //     std::cout<<std::endl;
     
@@ -199,10 +199,10 @@
 //     for(EdgeIt e=G.first<EdgeIt>(); G.valid(e); G.next(e))  
 //       if (flow.get(e))
-// 	std::cout << G.id(G.tail(e)) << "-" << flow.get(e) << "->" << G.id(G.head(e)) << " ";
+// 	std::cout << G.id(G.source(e)) << "-" << flow.get(e) << "->" << G.id(G.target(e)) << " ";
 //     std::cout<<std::endl;
 //     std::cout << "edges which are not in this maximum matching: "<< std::endl;
 //     for(EdgeIt e=G.first<EdgeIt>(); G.valid(e); G.next(e))  
 //       if (!flow.get(e))
-// 	std::cout << G.id(G.tail(e)) << "-" << flow.get(e) << "->" << G.id(G.head(e)) << " ";
+// 	std::cout << G.id(G.source(e)) << "-" << flow.get(e) << "->" << G.id(G.target(e)) << " ";
 //     std::cout<<std::endl;
     
Index: src/work/marci/leda_bfs_dfs.cc
===================================================================
--- src/work/marci/leda_bfs_dfs.cc	(revision 921)
+++ src/work/marci/leda_bfs_dfs.cc	(revision 986)
@@ -26,5 +26,5 @@
   string get(typename Graph::Edge e) const { 
     return 
-      (node_name_map.get(graph.tail(e))+"->"+node_name_map.get(graph.head(e)));
+      (node_name_map.get(graph.source(e))+"->"+node_name_map.get(graph.target(e)));
   }
 };
Index: src/work/marci/leda_graph_demo.cc
===================================================================
--- src/work/marci/leda_graph_demo.cc	(revision 921)
+++ src/work/marci/leda_graph_demo.cc	(revision 986)
@@ -39,8 +39,8 @@
 //     cout << "out edges: ";
 //     for(OutEdgeIt e=G.first<OutEdgeIt>(n); G.valid(e); G.next(e)) 
-//       cout << G.id(G.tail(e)) << "-" << cap.get(e) << "->" << G.id(G.head(e)) << " ";
+//       cout << G.id(G.source(e)) << "-" << cap.get(e) << "->" << G.id(G.target(e)) << " ";
 //     cout << "in edges: ";
 //     for(InEdgeIt e=G.first<InEdgeIt>(n); G.valid(e); G.next(e)) 
-//       cout << G.id(G.tail(e)) << "-" << cap.get(e) << "->" << G.id(G.head(e)) << " ";
+//       cout << G.id(G.source(e)) << "-" << cap.get(e) << "->" << G.id(G.target(e)) << " ";
 //     cout << endl;
 //   }
@@ -65,5 +65,5 @@
     while (max_flow_test.augmentOnShortestPath()) { 
 //     for(EdgeIt e=G.template first<EdgeIt>(); e.valid(); ++e) { 
-//       std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
+//       std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
 //     }
 //     std::cout<<std::endl;
@@ -73,5 +73,5 @@
 //   std::cout << "maximum flow: "<< std::endl;
 //   for(EdgeIt e=G.first<EdgeIt>(); e.valid(); ++e) { 
-//     std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
+//     std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
 //   }
 //   std::cout<<std::endl;
Index: src/work/marci/lp/max_flow_by_lp.cc
===================================================================
--- src/work/marci/lp/max_flow_by_lp.cc	(revision 921)
+++ src/work/marci/lp/max_flow_by_lp.cc	(revision 986)
@@ -64,7 +64,7 @@
 
     FOR_EACH_LOC(Graph::EdgeIt, e, g) {
-      if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e]) 
-	std::cout << "Slackness does not hold!" << std::endl;
-      if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0) 
+      if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e]) 
+	std::cout << "Slackness does not hold!" << std::endl;
+      if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0) 
 	std::cout << "Slackness does not hold!" << std::endl;
     }
@@ -80,7 +80,7 @@
 
 //     FOR_EACH_LOC(Graph::EdgeIt, e, g) {
-//       if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e]) 
-// 	std::cout << "Slackness does not hold!" << std::endl;
-//       if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0) 
+//       if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e]) 
+// 	std::cout << "Slackness does not hold!" << std::endl;
+//       if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0) 
 // 	std::cout << "Slackness does not hold!" << std::endl;
 //     }
@@ -107,7 +107,7 @@
 
     FOR_EACH_LOC(Graph::EdgeIt, e, g) {
-      if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e]) 
-	std::cout << "Slackness does not hold!" << std::endl;
-      if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0) 
+      if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e]) 
+	std::cout << "Slackness does not hold!" << std::endl;
+      if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0) 
 	std::cout << "Slackness does not hold!" << std::endl;
     }
@@ -136,7 +136,7 @@
 
     FOR_EACH_LOC(Graph::EdgeIt, e, g) {
-      if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e]) 
-	std::cout << "Slackness does not hold!" << std::endl;
-      if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0) 
+      if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e]) 
+	std::cout << "Slackness does not hold!" << std::endl;
+      if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0) 
 	std::cout << "Slackness does not hold!" << std::endl;
     }
@@ -154,7 +154,7 @@
 
 //     FOR_EACH_LOC(Graph::EdgeIt, e, g) {
-//       if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e]) 
-// 	std::cout << "Slackness does not hold!" << std::endl;
-//       if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0) 
+//       if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e]) 
+// 	std::cout << "Slackness does not hold!" << std::endl;
+//       if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0) 
 // 	std::cout << "Slackness does not hold!" << std::endl;
 //     }
@@ -172,7 +172,7 @@
 
 //     FOR_EACH_LOC(Graph::EdgeIt, e, g) {
-//       if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e]) 
-// 	std::cout << "Slackness does not hold!" << std::endl;
-//       if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0) 
+//       if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e]) 
+// 	std::cout << "Slackness does not hold!" << std::endl;
+//       if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0) 
 // 	std::cout << "Slackness does not hold!" << std::endl;
 //     }
Index: src/work/marci/max_flow_demo.cc
===================================================================
--- src/work/marci/max_flow_demo.cc	(revision 921)
+++ src/work/marci/max_flow_demo.cc	(revision 986)
@@ -48,7 +48,7 @@
 
     for(Graph::EdgeIt e(g); e!=INVALID; ++e) {
-      if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e]) 
+      if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e]) 
 	std::cout << "Slackness does not hold!" << std::endl;
-      if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0) 
+      if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0) 
 	std::cout << "Slackness does not hold!" << std::endl;
     }
@@ -64,7 +64,7 @@
 
     for(Graph::EdgeIt e(g); e!=INVALID; ++e) {
-      if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e]) 
+      if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e]) 
 	std::cout << "Slackness does not hold!" << std::endl;
-      if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0) 
+      if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0) 
 	std::cout << "Slackness does not hold!" << std::endl;
     }
@@ -91,7 +91,7 @@
 
     for(Graph::EdgeIt e(g); e!=INVALID; ++e) {
-      if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e]) 
+      if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e]) 
 	std::cout << "Slackness does not hold!" << std::endl;
-      if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0) 
+      if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0) 
 	std::cout << "Slackness does not hold!" << std::endl;
     }
@@ -109,7 +109,7 @@
 
     for(Graph::EdgeIt e(g); e!=INVALID; ++e) {
-      if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e]) 
+      if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e]) 
 	std::cout << "Slackness does not hold!" << std::endl;
-      if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0) 
+      if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0) 
 	std::cout << "Slackness does not hold!" << std::endl;
     }
@@ -127,7 +127,7 @@
 
     for(Graph::EdgeIt e(g); e!=INVALID; ++e) {
-      if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e]) 
+      if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e]) 
 	std::cout << "Slackness does not hold!" << std::endl;
-      if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0) 
+      if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0) 
 	std::cout << "Slackness does not hold!" << std::endl;
     }
@@ -145,7 +145,7 @@
 
     for(Graph::EdgeIt e(g); e!=INVALID; ++e) {
-      if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e]) 
+      if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e]) 
 	std::cout << "Slackness does not hold!" << std::endl;
-      if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0) 
+      if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0) 
 	std::cout << "Slackness does not hold!" << std::endl;
     }
Index: src/work/marci/oldies/edmonds_karp.h
===================================================================
--- src/work/marci/oldies/edmonds_karp.h	(revision 921)
+++ src/work/marci/oldies/edmonds_karp.h	(revision 986)
@@ -60,6 +60,6 @@
 	ResGWOutEdgeIt e=bfs;
 	if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
-	  Node v=res_graph.tail(e);
-	  Node w=res_graph.head(e);
+	  Node v=res_graph.source(e);
+	  Node w=res_graph.target(e);
 	  pred.set(w, e);
 	  if (res_graph.valid(pred[v])) {
@@ -68,5 +68,5 @@
 	    free.set(w, res_graph.resCap(e)); 
 	  }
-	  if (res_graph.head(e)==t) { _augment=true; break; }
+	  if (res_graph.target(e)==t) { _augment=true; break; }
 	}
 	
@@ -80,5 +80,5 @@
 	  ResGWEdge e=pred[n];
 	  res_graph.augment(e, augment_value); 
-	  n=res_graph.tail(e);
+	  n=res_graph.source(e);
 	}
       }
@@ -102,7 +102,7 @@
 // 	return dist[n]; }
 //       bool get(const typename MapGraphWrapper::Edge& e) const { 
-// 	return (dist.get(g->tail(e))<dist.get(g->head(e))); }
+// 	return (dist.get(g->source(e))<dist.get(g->target(e))); }
       bool operator[](const typename MapGraphWrapper::Edge& e) const { 
-	return (dist[g->tail(e)]<dist[g->head(e)]); 
+	return (dist[g->source(e)]<dist[g->target(e)]); 
       }
     };
@@ -124,5 +124,5 @@
 	ResGWOutEdgeIt e=bfs;
 	if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
-	  dist.set(res_graph.head(e), dist[res_graph.tail(e)]+1);
+	  dist.set(res_graph.target(e), dist[res_graph.source(e)]+1);
 	}
 	++bfs;
@@ -153,6 +153,6 @@
 	typename FilterResGW::EdgeIt e;
 	for(filter_res_graph.first(e); filter_res_graph.valid(e); filter_res_graph.next(e)) {
-	  //if (dist.get(res_graph.head(e))==dist.get(res_graph.tail(e))+1) {
-	  typename MG::Edge f=F.addEdge(res_graph_to_F[res_graph.tail(e)], res_graph_to_F[res_graph.head(e)]);
+	  //if (dist.get(res_graph.target(e))==dist.get(res_graph.source(e))+1) {
+	  typename MG::Edge f=F.addEdge(res_graph_to_F[res_graph.source(e)], res_graph_to_F[res_graph.target(e)]);
 	  original_edge.update();
 	  original_edge.set(f, e);
@@ -207,5 +207,5 @@
 	    typename MG::Edge e=pred[n];
 	    res_graph.augment(original_edge[e], augment_value); 
-	    n=F.tail(e);
+	    n=F.source(e);
 	    if (residual_capacity[e]==augment_value) 
 	      F.erase(e); 
@@ -255,6 +255,6 @@
 	if (res_graph.valid(e)) {
 	  if (bfs.isBNodeNewlyReached()) {
-	    dist.set(res_graph.head(e), dist[res_graph.tail(e)]+1);
-	    typename MG::Edge f=F.addEdge(res_graph_to_F[res_graph.tail(e)], res_graph_to_F[res_graph.head(e)]);
+	    dist.set(res_graph.target(e), dist[res_graph.source(e)]+1);
+	    typename MG::Edge f=F.addEdge(res_graph_to_F[res_graph.source(e)], res_graph_to_F[res_graph.target(e)]);
 	    original_edge.update();
 	    original_edge.set(f, e);
@@ -262,6 +262,6 @@
 	    residual_capacity.set(f, res_graph.resCap(e));
 	  } else {
-	    if (dist[res_graph.head(e)]==(dist[res_graph.tail(e)]+1)) {
-	      typename MG::Edge f=F.addEdge(res_graph_to_F[res_graph.tail(e)], res_graph_to_F[res_graph.head(e)]);
+	    if (dist[res_graph.target(e)]==(dist[res_graph.source(e)]+1)) {
+	      typename MG::Edge f=F.addEdge(res_graph_to_F[res_graph.source(e)], res_graph_to_F[res_graph.target(e)]);
 	      original_edge.update();
 	      original_edge.set(f, e);
@@ -317,5 +317,5 @@
 	    typename MG::Edge e=pred[n];
 	    res_graph.augment(original_edge[e], augment_value); 
-	    n=F.tail(e);
+	    n=F.source(e);
 	    if (residual_capacity[e]==augment_value) 
 	      F.erase(e); 
@@ -344,5 +344,5 @@
  	ResGWOutEdgeIt e=bfs;
  	if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
- 	  dist.set(res_graph.head(e), dist[res_graph.tail(e)]+1);
+ 	  dist.set(res_graph.target(e), dist[res_graph.source(e)]+1);
  	}
 	++bfs;
@@ -441,5 +441,5 @@
  	    typename ErasingResGW::OutEdgeIt e=pred[n];
  	    res_graph.augment(e, augment_value);
- 	    n=erasing_res_graph.tail(e);
+ 	    n=erasing_res_graph.source(e);
  	    if (res_graph.resCap(e)==0)
  	      erasing_res_graph.erase(e);
@@ -536,6 +536,6 @@
 // 	AugOutEdgeIt e=bfs;
 // 	if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
-// 	  Node v=res_graph.tail(e);
-// 	  Node w=res_graph.head(e);
+// 	  Node v=res_graph.source(e);
+// 	  Node w=res_graph.target(e);
 // 	  pred.set(w, e);
 // 	  if (res_graph.valid(pred.get(v))) {
@@ -544,5 +544,5 @@
 // 	    free.set(w, res_graph.free(e)); 
 // 	  }
-// 	  n=res_graph.head(e);
+// 	  n=res_graph.target(e);
 // 	  if (T->get(n) && (used.get(n)<1) ) { 
 // 	    //Num u=0;
@@ -566,5 +566,5 @@
 // 	  AugEdge e=pred.get(n);
 // 	  res_graph.augment(e, augment_value); 
-// 	  n=res_graph.tail(e);
+// 	  n=res_graph.source(e);
 // 	}
 // 	used.set(n, 1); //mind2 vegen jav
@@ -607,5 +607,5 @@
 // // 	AugOutEdgeIt e=bfs;
 // // 	if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
-// // 	  dist.set(res_graph.head(e), dist.get(res_graph.tail(e))+1);
+// // 	  dist.set(res_graph.target(e), dist.get(res_graph.source(e))+1);
 // // 	}
 	
@@ -629,6 +629,6 @@
 // //       //which are in some shortest paths
 // //       for(typename AugGraph::EdgeIt e=res_graph.template first<typename AugGraph::EdgeIt>(); res_graph.valid(e); res_graph.next(e)) {
-// // 	if (dist.get(res_graph.head(e))==dist.get(res_graph.tail(e))+1) {
-// // 	  typename MutableGraph::Edge f=F.addEdge(res_graph_to_F.get(res_graph.tail(e)), res_graph_to_F.get(res_graph.head(e)));
+// // 	if (dist.get(res_graph.target(e))==dist.get(res_graph.source(e))+1) {
+// // 	  typename MutableGraph::Edge f=F.addEdge(res_graph_to_F.get(res_graph.source(e)), res_graph_to_F.get(res_graph.target(e)));
 // // 	  original_edge.update();
 // // 	  original_edge.set(f, e);
@@ -682,5 +682,5 @@
 // // 	    typename MutableGraph::Edge e=pred.get(n);
 // // 	    res_graph.augment(original_edge.get(e), augment_value); 
-// // 	    n=F.tail(e);
+// // 	    n=F.source(e);
 // // 	    if (residual_capacity.get(e)==augment_value) 
 // // 	      F.erase(e); 
@@ -733,5 +733,5 @@
 // 	typename ErasingResGraphWrapper<Graph, Num, FlowMap, CapMap>::OutEdgeIt e=bfs;
 // 	if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {
-// 	  dist.set(res_graph.head(e), dist.get(res_graph.tail(e))+1);
+// 	  dist.set(res_graph.target(e), dist.get(res_graph.source(e))+1);
 // 	}
 // 	++bfs;	
@@ -810,5 +810,5 @@
 // 	    EAugEdge e=pred.get(n);
 // 	    res_graph.augment(e, augment_value);
-// 	    n=res_graph.tail(e);
+// 	    n=res_graph.source(e);
 // 	    if (res_graph.free(e)==0)
 // 	      res_graph.erase(e);
@@ -903,6 +903,6 @@
 // // 	AugOutEdgeIt e=/*AugOutEdgeIt*/(bfs);
 // // 	if (e.valid() && bfs.isBNodeNewlyReached()) {
-// // 	  Node v=res_graph.tail(e);
-// // 	  Node w=res_graph.head(e);
+// // 	  Node v=res_graph.source(e);
+// // 	  Node w=res_graph.target(e);
 // // 	  pred.set(w, e);
 // // 	  if (pred.get(v).valid()) {
@@ -911,7 +911,7 @@
 // // 	    free.set(w, e.free()); 
 // // 	  }
-// // 	  if (TMap.get(res_graph.head(e))) { 
+// // 	  if (TMap.get(res_graph.target(e))) { 
 // // 	    _augment=true; 
-// // 	    reached_t_node=res_graph.head(e);
+// // 	    reached_t_node=res_graph.target(e);
 // // 	    break; 
 // // 	  }
@@ -927,5 +927,5 @@
 // // 	  AugEdge e=pred.get(n);
 // // 	  e.augment(augment_value); 
-// // 	  n=res_graph.tail(e);
+// // 	  n=res_graph.source(e);
 // // 	}
 // //       }
Index: src/work/marci/oldies/marci_graph_demo.cc
===================================================================
--- src/work/marci/oldies/marci_graph_demo.cc	(revision 921)
+++ src/work/marci/oldies/marci_graph_demo.cc	(revision 986)
@@ -32,5 +32,5 @@
     std::cout << " outdegree (OutEdgeIt): " << count(G.first<OutEdgeIt>(i)) << " "; 
     for(OutEdgeIt j=G.first<OutEdgeIt>(i); G.valid(j); G.next(j)) { 
-      std::cout << "(" << G.id(G.tail(j)) << "--" << G.id(j) << "->" << G.id(G.head(j)) << ") ";
+      std::cout << "(" << G.id(G.source(j)) << "--" << G.id(j) << "->" << G.id(G.target(j)) << ") ";
     }
     std::cout << std::endl; 
@@ -90,7 +90,7 @@
   }
 
-  std::cout << "node and edge property values on the tails and heads of edges..." << std::endl;
+  std::cout << "node and edge property values on the sources and targets of edges..." << std::endl;
   for(EdgeIt j=G.first<EdgeIt>(); G.valid(j); G.next(j)) {
-    std::cout << my_property_vector.get(G.tail(j)) << "--" << my_edge_property.get(j) << "-->" << my_property_vector.get(G.head(j)) << " ";
+    std::cout << my_property_vector.get(G.source(j)) << "--" << my_edge_property.get(j) << "-->" << my_property_vector.get(G.target(j)) << " ";
   }
   std::cout << std::endl;
@@ -159,8 +159,8 @@
     std::cout << "out edges: ";
     for(OutEdgeIt j=flowG.first<OutEdgeIt>(i); flowG.valid(j); flowG.next(j)) 
-      std::cout << node_name.get(flowG.tail(j)) << "-"<< cap.get(j) << "->" << node_name.get(flowG.head(j)) << " ";
+      std::cout << node_name.get(flowG.source(j)) << "-"<< cap.get(j) << "->" << node_name.get(flowG.target(j)) << " ";
     std::cout << "in edges: ";
     for(InEdgeIt j=flowG.first<InEdgeIt>(i); flowG.valid(j); flowG.next(j)) 
-      std::cout << node_name.get(flowG.tail(j)) << "-"<< cap.get(j) << "->" << node_name.get(flowG.head(j)) << " ";
+      std::cout << node_name.get(flowG.source(j)) << "-"<< cap.get(j) << "->" << node_name.get(flowG.target(j)) << " ";
     std::cout << std::endl;
   }
@@ -172,6 +172,6 @@
   
 
-  //flowG.setTail(v3_t, v2);
-  //flowG.setHead(v3_t, s);
+  //flowG.setSource(v3_t, v2);
+  //flowG.setTarget(v3_t, s);
 /*
   for(NodeIt i=flowG.first<NodeIt>(); flowG.valid(i); flowG.next(i)) { 
@@ -179,13 +179,13 @@
     std::cout << "out edges: ";
     for(OutEdgeIt j=flowG.first<OutEdgeIt>(i); flowG.valid(j); flowG.next(j)) 
-      std::cout << node_name.get(flowG.tail(j)) << "-"<< cap.get(j) << "->" << node_name.get(flowG.head(j)) << " ";
+      std::cout << node_name.get(flowG.source(j)) << "-"<< cap.get(j) << "->" << node_name.get(flowG.target(j)) << " ";
     std::cout << "in edges: ";
     for(InEdgeIt j=flowG.first<InEdgeIt>(i); flowG.valid(j); flowG.next(j)) 
-      std::cout << node_name.get(flowG.tail(j)) << "-"<< cap.get(j) << "->" << node_name.get(flowG.head(j)) << " ";
+      std::cout << node_name.get(flowG.source(j)) << "-"<< cap.get(j) << "->" << node_name.get(flowG.target(j)) << " ";
     std::cout << std::endl;
   }
   
   for(EdgeIt e=flowG.first<EdgeIt>(); flowG.valid(e); flowG.next(e)) {
-    std::cout << node_name.get(flowG.tail(e)) << "-"<< cap.get(e) << "->" << node_name.get(flowG.head(e)) << " ";
+    std::cout << node_name.get(flowG.source(e)) << "-"<< cap.get(e) << "->" << node_name.get(flowG.target(e)) << " ";
   }
 */
@@ -197,8 +197,8 @@
       std::cout << "out edges: ";
       for(OutEdgeIt j=flowG.first<OutEdgeIt>(i); flowG.valid(j); flowG.next(j)) 
-	std::cout << node_name.get(flowG.tail(j)) << "-"<< cap.get(j) << "->" << node_name.get(flowG.head(j)) << " ";
+	std::cout << node_name.get(flowG.source(j)) << "-"<< cap.get(j) << "->" << node_name.get(flowG.target(j)) << " ";
       std::cout << "in edges: ";
       for(InEdgeIt j=flowG.first<InEdgeIt>(i); flowG.valid(j); flowG.next(j)) 
-	std::cout << node_name.get(flowG.tail(j)) << "-"<< cap.get(j) << "->" << node_name.get(flowG.head(j)) << " ";
+	std::cout << node_name.get(flowG.source(j)) << "-"<< cap.get(j) << "->" << node_name.get(flowG.target(j)) << " ";
       std::cout << std::endl;
     }
@@ -211,8 +211,8 @@
       std::cout << "out edges: ";
       for(OutEdgeIt j=flowG.first<OutEdgeIt>(i); flowG.valid(j); flowG.next(j)) 
-	std::cout << node_name.get(flowG.tail(j)) << "-"<< cap.get(j) << "->" << node_name.get(flowG.head(j)) << " ";
+	std::cout << node_name.get(flowG.source(j)) << "-"<< cap.get(j) << "->" << node_name.get(flowG.target(j)) << " ";
       std::cout << "in edges: ";
       for(InEdgeIt j=flowG.first<InEdgeIt>(i); flowG.valid(j); flowG.next(j)) 
-	std::cout << node_name.get(flowG.tail(j)) << "-"<< cap.get(j) << "->" << node_name.get(flowG.head(j)) << " ";
+	std::cout << node_name.get(flowG.source(j)) << "-"<< cap.get(j) << "->" << node_name.get(flowG.target(j)) << " ";
       std::cout << std::endl;
     }
@@ -229,10 +229,10 @@
     max_flow_test.augmentOnBlockingFlow<ListGraph>();
     for(EdgeIt e=flowG.template first<EdgeIt>(); flowG.valid(e); flowG.next(e)) { 
-      std::cout<<"("<<flowG.tail(e)<< "-"<<flow.get(e)<<"->"<<flowG.head(e)<<") ";
+      std::cout<<"("<<flowG.source(e)<< "-"<<flow.get(e)<<"->"<<flowG.target(e)<<") ";
     }
     std::cout<<std::endl;
     max_flow_test.augmentOnBlockingFlow<ListGraph>();
     for(EdgeIt e=flowG.template first<EdgeIt>(); flowG.valid(e); flowG.next(e)) { 
-      std::cout<<"("<<flowG.tail(e)<< "-"<<flow.get(e)<<"->"<<flowG.head(e)<<") ";
+      std::cout<<"("<<flowG.source(e)<< "-"<<flow.get(e)<<"->"<<flowG.target(e)<<") ";
     }
     std::cout<<std::endl;*/
@@ -242,5 +242,5 @@
     while (max_flow_test.augmentOnShortestPath()) {
       for(EdgeIt e=flowG.template first<EdgeIt>(); flowG.valid(e); flowG.next(e)) { 
-	std::cout<<"("<<flowG.tail(e)<< "-"<<flow.get(e)<<"->"<<flowG.head(e)<<") ";
+	std::cout<<"("<<flowG.source(e)<< "-"<<flow.get(e)<<"->"<<flowG.target(e)<<") ";
       }
       std::cout<<std::endl;
@@ -261,5 +261,5 @@
     std::cout << "maximum flow: "<< std::endl;
     for(EdgeIt e=flowG.template first<EdgeIt>(); flowG.valid(e); flowG.next(e)) { 
-      std::cout<<"("<<flowG.tail(e)<< "-"<<flow.get(e)<<"->"<<flowG.head(e)<<") ";
+      std::cout<<"("<<flowG.source(e)<< "-"<<flow.get(e)<<"->"<<flowG.target(e)<<") ";
     }
     std::cout<<std::endl;
Index: src/work/marci/preflow_bug.cc
===================================================================
--- src/work/marci/preflow_bug.cc	(revision 921)
+++ src/work/marci/preflow_bug.cc	(revision 986)
@@ -46,5 +46,5 @@
     Graph::EdgeIt e;
     for (g.first(e); g.valid(e); g.next(e))
-      cout << 1+g.id(g.tail(e)) << "->" << 1+g.id(g.head(e)) << " cap: " << cap[e] << " preflow: " << flow[e] << endl;
+      cout << 1+g.id(g.source(e)) << "->" << 1+g.id(g.target(e)) << " cap: " << cap[e] << " preflow: " << flow[e] << endl;
   }
   {
@@ -76,6 +76,6 @@
     Graph::EdgeIt e;
     for (g.first(e); g.valid(e); g.next(e)) {
-      if (cut[g.tail(e)] && !cut[g.head(e)]) {
-	cout << 1+g.id(g.tail(e)) << "->" << 1+g.id(g.head(e)) 
+      if (cut[g.source(e)] && !cut[g.target(e)]) {
+	cout << 1+g.id(g.source(e)) << "->" << 1+g.id(g.target(e)) 
 	     << "(forward edge) flow: " << flow[e] 
 	     << " cap: " << cap[e]<< endl;
@@ -83,6 +83,6 @@
 	std::cout << "Slackness does not hold!" << std::endl;
       }
-      if (!cut[g.tail(e)] && cut[g.head(e)]) {
-	cout << 1+g.id(g.tail(e)) << "->" << 1+g.id(g.head(e)) 
+      if (!cut[g.source(e)] && cut[g.target(e)]) {
+	cout << 1+g.id(g.source(e)) << "->" << 1+g.id(g.target(e)) 
 	     << "(backward edge) flow: " << flow[e] << endl;
 	if (flow[e]!=0) 
@@ -106,7 +106,7 @@
 
 //     FOR_EACH_LOC(Graph::EdgeIt, e, g) {
-//       if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e]) 
-// 	std::cout << "Slackness does not hold!" << std::endl;
-//       if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0) 
+//       if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e]) 
+// 	std::cout << "Slackness does not hold!" << std::endl;
+//       if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0) 
 // 	std::cout << "Slackness does not hold!" << std::endl;
 //     }
@@ -122,7 +122,7 @@
 
 //     FOR_EACH_LOC(Graph::EdgeIt, e, g) {
-//       if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e]) 
-// 	std::cout << "Slackness does not hold!" << std::endl;
-//       if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0) 
+//       if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e]) 
+// 	std::cout << "Slackness does not hold!" << std::endl;
+//       if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0) 
 // 	std::cout << "Slackness does not hold!" << std::endl;
 //     }
@@ -149,7 +149,7 @@
 
 //     FOR_EACH_LOC(Graph::EdgeIt, e, g) {
-//       if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e]) 
-// 	std::cout << "Slackness does not hold!" << std::endl;
-//       if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0) 
+//       if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e]) 
+// 	std::cout << "Slackness does not hold!" << std::endl;
+//       if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0) 
 // 	std::cout << "Slackness does not hold!" << std::endl;
 //     }
@@ -178,7 +178,7 @@
 
 //     FOR_EACH_LOC(Graph::EdgeIt, e, g) {
-//       if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e]) 
-// 	std::cout << "Slackness does not hold!" << std::endl;
-//       if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0) 
+//       if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e]) 
+// 	std::cout << "Slackness does not hold!" << std::endl;
+//       if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0) 
 // 	std::cout << "Slackness does not hold!" << std::endl;
 //     }
@@ -196,7 +196,7 @@
 
 //     FOR_EACH_LOC(Graph::EdgeIt, e, g) {
-//       if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e]) 
-// 	std::cout << "Slackness does not hold!" << std::endl;
-//       if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0) 
+//       if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e]) 
+// 	std::cout << "Slackness does not hold!" << std::endl;
+//       if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0) 
 // 	std::cout << "Slackness does not hold!" << std::endl;
 //     }
@@ -214,7 +214,7 @@
 
 //     FOR_EACH_LOC(Graph::EdgeIt, e, g) {
-//       if (cut[g.tail(e)] && !cut[g.head(e)] && !flow[e]==cap[e]) 
-// 	std::cout << "Slackness does not hold!" << std::endl;
-//       if (!cut[g.tail(e)] && cut[g.head(e)] && flow[e]>0) 
+//       if (cut[g.source(e)] && !cut[g.target(e)] && !flow[e]==cap[e]) 
+// 	std::cout << "Slackness does not hold!" << std::endl;
+//       if (!cut[g.source(e)] && cut[g.target(e)] && flow[e]>0) 
 // 	std::cout << "Slackness does not hold!" << std::endl;
 //     }
Index: src/work/marci/preflow_demo_athos.cc
===================================================================
--- src/work/marci/preflow_demo_athos.cc	(revision 921)
+++ src/work/marci/preflow_demo_athos.cc	(revision 986)
@@ -29,10 +29,10 @@
   //int cut_value=0;
   //for(EachEdgeIt e=G.first<EachEdgeIt>(); e.valid(); ++e) {
-  //  if (cut.get(G.tail(e)) && !cut.get(G.head(e))) cut_value+=cap.get(e);
+  //  if (cut.get(G.source(e)) && !cut.get(G.target(e))) cut_value+=cap.get(e);
   //}
   double post_time=currTime();
   //std::cout << "maximum flow: "<< std::endl;
   //for(EachEdgeIt e=G.first<EachEdgeIt>(); e.valid(); ++e) { 
-  //  std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
+  //  std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
   //}
   //std::cout<<std::endl;
Index: src/work/marci/preflow_demo_jacint.cc
===================================================================
--- src/work/marci/preflow_demo_jacint.cc	(revision 921)
+++ src/work/marci/preflow_demo_jacint.cc	(revision 986)
@@ -32,10 +32,10 @@
   int cut_value=0;
   for(EachEdgeIt e=G.first<EachEdgeIt>(); e.valid(); ++e) {
-    if (cut.get(G.tail(e)) && !cut.get(G.head(e))) cut_value+=cap.get(e);
+    if (cut.get(G.source(e)) && !cut.get(G.target(e))) cut_value+=cap.get(e);
   }
   double post_time=currTime();
   //std::cout << "maximum flow: "<< std::endl;
   //for(EachEdgeIt e=G.first<EachEdgeIt>(); e.valid(); ++e) { 
-  //  std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
+  //  std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
   //}
   //std::cout<<std::endl;
@@ -56,10 +56,10 @@
   int cut_value=0;
   for(EachEdgeIt e=G.first<EachEdgeIt>(); e.valid(); ++e) {
-    if (cut.get(G.tail(e)) && !cut.get(G.head(e))) cut_value+=cap.get(e);
+    if (cut.get(G.source(e)) && !cut.get(G.target(e))) cut_value+=cap.get(e);
   }
   double post_time=currTime();
   //std::cout << "maximum flow: "<< std::endl;
   //for(EachEdgeIt e=G.first<EachEdgeIt>(); e.valid(); ++e) { 
-  //  std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
+  //  std::cout<<"("<<G.source(e)<< "-"<<flow.get(e)<<"->"<<G.target(e)<<") ";
   //}
   //std::cout<<std::endl;
