diff -r d72e56f1730d -r cd40ecf4d2a9 src/work/jacint/preflow.h
--- a/src/work/jacint/preflow.h	Thu Apr 29 09:08:14 2004 +0000
+++ b/src/work/jacint/preflow.h	Thu Apr 29 10:16:46 2004 +0000
@@ -59,7 +59,7 @@
     typedef typename Graph::template NodeMap<Node> NNMap;
     typedef typename std::vector<Node> VecNode;
 
-    const Graph& G;
+    const Graph* g;
     Node s;
     Node t;
     const CapMap* capacity;  
@@ -79,7 +79,7 @@
 
     Preflow(const Graph& _G, Node _s, Node _t, const CapMap& _capacity, 
 	    FlowMap& _flow) :
-      G(_G), s(_s), t(_t), capacity(&_capacity), 
+      g(&_G), s(_s), t(_t), capacity(&_capacity), 
       flow(&_flow), n(_G.nodeNum()), level(_G), excess(_G,0) {}
 
     void run() {
@@ -109,13 +109,13 @@
       
       VecStack active(n);
       
-      NNMap left(G,INVALID);
-      NNMap right(G,INVALID);
+      NNMap left(*g, INVALID);
+      NNMap right(*g, INVALID);
       VecNode level_list(n,INVALID);
       //List of the nodes in level i<n, set to n.
 
       NodeIt v;
-      for(G.first(v); G.valid(v); G.next(v)) level.set(v,n);
+      for(g->first(v); g->valid(v); g->next(v)) level.set(v,n);
       //setting each node to level n
       
       switch ( fe ) {
@@ -123,13 +123,13 @@
 	{
 	  //counting the excess
 	  NodeIt v;
-	  for(G.first(v); G.valid(v); G.next(v)) {
+	  for(g->first(v); g->valid(v); g->next(v)) {
 	    T exc=0;
 	  
 	    InEdgeIt e;
-	    for(G.first(e,v); G.valid(e); G.next(e)) exc+=(*flow)[e];
+	    for(g->first(e,v); g->valid(e); g->next(e)) exc+=(*flow)[e];
 	    OutEdgeIt f;
-	    for(G.first(f,v); G.valid(f); G.next(f)) exc-=(*flow)[f];
+	    for(g->first(f,v); g->valid(f); g->next(f)) exc-=(*flow)[f];
 	    
 	    excess.set(v,exc);	  
 	    
@@ -145,9 +145,9 @@
 	  T exc=0;
 	  
 	  InEdgeIt e;
-	  for(G.first(e,t); G.valid(e); G.next(e)) exc+=(*flow)[e];
+	  for(g->first(e,t); g->valid(e); g->next(e)) exc+=(*flow)[e];
 	  OutEdgeIt f;
-	  for(G.first(f,t); G.valid(f); G.next(f)) exc-=(*flow)[f];
+	  for(g->first(f,t); g->valid(f); g->next(f)) exc-=(*flow)[f];
 	  
 	  excess.set(t,exc);	
 	  
@@ -216,9 +216,9 @@
 	int l=level[v]+1;
 	      
 	InEdgeIt e;
-	for(G.first(e,v); G.valid(e); G.next(e)) {
+	for(g->first(e,v); g->valid(e); g->next(e)) {
 	  if ( (*capacity)[e] == (*flow)[e] ) continue;
-	  Node u=G.tail(e);
+	  Node u=g->tail(e);
 	  if ( level[u] >= n ) { 
 	    bfs_queue.push(u);
 	    level.set(u, l);
@@ -227,9 +227,9 @@
 	}
 	
 	OutEdgeIt f;
-	for(G.first(f,v); G.valid(f); G.next(f)) {
+	for(g->first(f,v); g->valid(f); g->next(f)) {
 	  if ( 0 == (*flow)[f] ) continue;
-	  Node u=G.head(f);
+	  Node u=g->head(f);
 	  if ( level[u] >= n ) { 
 	    bfs_queue.push(u);
 	    level.set(u, l);
@@ -269,9 +269,12 @@
     template<typename _CutMap>
     void actMinCut(_CutMap& M) {
       NodeIt v;
-      for(G.first(v); G.valid(v); G.next(v)) 
-	if ( level[v] < n ) M.set(v,false);
-	else M.set(v,true);
+      for(g->first(v); g->valid(v); g->next(v)) 
+      if ( level[v] < n ) {
+	M.set(v,false);
+      } else {
+	M.set(v,true);
+      }
     }
 
 
@@ -292,8 +295,8 @@
 	queue.pop();
 
 	OutEdgeIt e;
-	for(G.first(e,w) ; G.valid(e); G.next(e)) {
-	  Node v=G.head(e);
+	for(g->first(e,w) ; g->valid(e); g->next(e)) {
+	  Node v=g->head(e);
 	  if (!M[v] && (*flow)[e] < (*capacity)[e] ) {
 	    queue.push(v);
 	    M.set(v, true);
@@ -301,8 +304,8 @@
 	} 
 
 	InEdgeIt f;
-	for(G.first(f,w) ; G.valid(f); G.next(f)) {
-	  Node v=G.tail(f);
+	for(g->first(f,w) ; g->valid(f); g->next(f)) {
+	  Node v=g->tail(f);
 	  if (!M[v] && (*flow)[f] > 0 ) {
 	    queue.push(v);
 	    M.set(v, true);
@@ -322,7 +325,7 @@
     void maxMinCut(_CutMap& M) {
 
       NodeIt v;
-      for(G.first(v) ; G.valid(v); G.next(v)) {
+      for(g->first(v) ; g->valid(v); g->next(v)) {
 	M.set(v, true);
       }
 
@@ -337,8 +340,8 @@
 
 
 	InEdgeIt e;
-	for(G.first(e,w) ; G.valid(e); G.next(e)) {
-	  Node v=G.tail(e);
+	for(g->first(e,w) ; g->valid(e); g->next(e)) {
+	  Node v=g->tail(e);
 	  if (M[v] && (*flow)[e] < (*capacity)[e] ) {
 	    queue.push(v);
 	    M.set(v, false);
@@ -346,8 +349,8 @@
 	}
 	
 	OutEdgeIt f;
-	for(G.first(f,w) ; G.valid(f); G.next(f)) {
-	  Node v=G.head(f);
+	for(g->first(f,w) ; g->valid(f); g->next(f)) {
+	  Node v=g->head(f);
 	  if (M[v] && (*flow)[f] > 0 ) {
 	    queue.push(v);
 	    M.set(v, false);
@@ -385,10 +388,10 @@
       int newlevel=n;       //bound on the next level of w
 	  
       OutEdgeIt e;
-      for(G.first(e,w); G.valid(e); G.next(e)) {
+      for(g->first(e,w); g->valid(e); g->next(e)) {
 	    
 	if ( (*flow)[e] == (*capacity)[e] ) continue; 
-	Node v=G.head(e);            
+	Node v=g->head(e);            
 	    
 	if( lev > level[v] ) { //Push is allowed now
 	  
@@ -418,10 +421,10 @@
       
       if ( exc > 0 ) {	
 	InEdgeIt e;
-	for(G.first(e,w); G.valid(e); G.next(e)) {
+	for(g->first(e,w); g->valid(e); g->next(e)) {
 	  
 	  if( (*flow)[e] == 0 ) continue; 
-	  Node v=G.tail(e); 
+	  Node v=g->tail(e); 
 	  
 	  if( lev > level[v] ) { //Push is allowed now
 	    
@@ -474,12 +477,12 @@
 	    int l=level[v]+1;
 	    
 	    InEdgeIt e;
-	    for(G.first(e,v); G.valid(e); G.next(e)) {
-	      Node w=G.tail(e);
+	    for(g->first(e,v); g->valid(e); g->next(e)) {
+	      Node w=g->tail(e);
 	      if ( level[w] == n && w != s ) {
 		bfs_queue.push(w);
 		Node first=level_list[l];
-		if ( G.valid(first) ) left.set(first,w);
+		if ( g->valid(first) ) left.set(first,w);
 		right.set(w,first);
 		level_list[l]=w;
 		level.set(w, l);
@@ -489,11 +492,11 @@
 	  
 	  //the starting flow
 	  OutEdgeIt e;
-	  for(G.first(e,s); G.valid(e); G.next(e)) 
+	  for(g->first(e,s); g->valid(e); g->next(e)) 
 	    {
 	      T c=(*capacity)[e];
 	      if ( c == 0 ) continue;
-	      Node w=G.head(e);
+	      Node w=g->head(e);
 	      if ( level[w] < n ) {	  
 		if ( excess[w] == 0 && w!=t ) active[level[w]].push(w);
 		flow->set(e, c); 
@@ -518,13 +521,13 @@
 	    int l=level[v]+1;
 	    
 	    InEdgeIt e;
-	    for(G.first(e,v); G.valid(e); G.next(e)) {
+	    for(g->first(e,v); g->valid(e); g->next(e)) {
 	      if ( (*capacity)[e] == (*flow)[e] ) continue;
-	      Node w=G.tail(e);
+	      Node w=g->tail(e);
 	      if ( level[w] == n && w != s ) {
 		bfs_queue.push(w);
 		Node first=level_list[l];
-		if ( G.valid(first) ) left.set(first,w);
+		if ( g->valid(first) ) left.set(first,w);
 		right.set(w,first);
 		level_list[l]=w;
 		level.set(w, l);
@@ -532,13 +535,13 @@
 	    }
 	    
 	    OutEdgeIt f;
-	    for(G.first(f,v); G.valid(f); G.next(f)) {
+	    for(g->first(f,v); g->valid(f); g->next(f)) {
 	      if ( 0 == (*flow)[f] ) continue;
-	      Node w=G.head(f);
+	      Node w=g->head(f);
 	      if ( level[w] == n && w != s ) {
 		bfs_queue.push(w);
 		Node first=level_list[l];
-		if ( G.valid(first) ) left.set(first,w);
+		if ( g->valid(first) ) left.set(first,w);
 		right.set(w,first);
 		level_list[l]=w;
 		level.set(w, l);
@@ -549,11 +552,11 @@
 	  
 	  //the starting flow
 	  OutEdgeIt e;
-	  for(G.first(e,s); G.valid(e); G.next(e)) 
+	  for(g->first(e,s); g->valid(e); g->next(e)) 
 	    {
 	      T rem=(*capacity)[e]-(*flow)[e];
 	      if ( rem == 0 ) continue;
-	      Node w=G.head(e);
+	      Node w=g->head(e);
 	      if ( level[w] < n ) {	  
 		if ( excess[w] == 0 && w!=t ) active[level[w]].push(w);
 		flow->set(e, (*capacity)[e]); 
@@ -562,10 +565,10 @@
 	    }
 	  
 	  InEdgeIt f;
-	  for(G.first(f,s); G.valid(f); G.next(f)) 
+	  for(g->first(f,s); g->valid(f); g->next(f)) 
 	    {
 	      if ( (*flow)[f] == 0 ) continue;
-	      Node w=G.tail(f);
+	      Node w=g->tail(f);
 	      if ( level[w] < n ) {	  
 		if ( excess[w] == 0 && w!=t ) active[level[w]].push(w);
 		excess.set(w, excess[w]+(*flow)[f]);
@@ -589,8 +592,8 @@
       Node left_n=left[w];
       
       //unlacing starts
-      if ( G.valid(right_n) ) {
-	if ( G.valid(left_n) ) {
+      if ( g->valid(right_n) ) {
+	if ( g->valid(left_n) ) {
 	  right.set(left_n, right_n);
 	  left.set(right_n, left_n);
 	} else {
@@ -598,7 +601,7 @@
 	  left.set(right_n, INVALID);
 	} 
       } else {
-	if ( G.valid(left_n) ) {
+	if ( g->valid(left_n) ) {
 	  right.set(left_n, INVALID);
 	} else { 
 	  level_list[lev]=INVALID;   
@@ -606,12 +609,12 @@
       } 
       //unlacing ends
 		
-      if ( !G.valid(level_list[lev]) ) {
+      if ( !g->valid(level_list[lev]) ) {
 	      
 	//gapping starts
 	for (int i=lev; i!=k ; ) {
 	  Node v=level_list[++i];
-	  while ( G.valid(v) ) {
+	  while ( g->valid(v) ) {
 	    level.set(v,n);
 	    v=right[v];
 	  }
@@ -637,7 +640,7 @@
 	  if ( what_heur ) b=newlevel;
 	  if ( k < newlevel ) ++k;      //now k=newlevel
 	  Node first=level_list[newlevel];
-	  if ( G.valid(first) ) left.set(first,w);
+	  if ( g->valid(first) ) left.set(first,w);
 	  right.set(w,first);
 	  left.set(w,INVALID);
 	  level_list[newlevel]=w;