Index: src/hugo/bin_heap.h
===================================================================
--- src/hugo/bin_heap.h	(revision 542)
+++ src/hugo/bin_heap.h	(revision 776)
@@ -34,5 +34,6 @@
  * Ehhez nagyon fontos, hogy az atadott property map inicializalva legyen
  * minden szobajovo kulcs ertekre, -1 -es ertekkel!
- * Es ilyen esetben a kulcsokrol lekerdezheto az allapotuk a state metodussal:
+ * Es ilyen esetben a kulcsokrol lekerdezheto az allapotuk a state
+ metodussal:
  * (nem jart meg a kupacban PRE_HEAP=-1, epp a kupacban van IN_HEAP=0,
  *  mar kikerult a kupacbol POST_HEAP=-2).
Index: src/hugo/dijkstra.h
===================================================================
--- src/hugo/dijkstra.h	(revision 774)
+++ src/hugo/dijkstra.h	(revision 776)
@@ -243,5 +243,4 @@
 	for(OutEdgeIt e(*G,v); e!=INVALID; ++e) {
 	  Node w=G->head(e); 
-	  
 	  switch(heap.state(w)) {
 	  case HeapType::PRE_HEAP:
Index: src/hugo/mincostflows.h
===================================================================
--- src/hugo/mincostflows.h	(revision 758)
+++ src/hugo/mincostflows.h	(revision 776)
@@ -117,10 +117,10 @@
       total_length = 0;
       
-      FOR_EACH_LOC(typename Graph::EdgeIt, e, G){
+      for(typename Graph::EdgeIt e=loopFirst(typename Graph::EdgeIt(), (G)); e!=INVALID; ++e){
 	flow.set(e,0);
       }
 
       //Initialize the potential to zero
-      FOR_EACH_LOC(typename Graph::NodeIt, n, G){
+      for(typename Graph::NodeIt n=loopFirst(typename Graph::NodeIt(), (G)); n!=INVALID; ++n){
 	potential.set(n,0);
       }
@@ -145,5 +145,7 @@
 	
 	//We have to change the potential
-	FOR_EACH_LOC(typename ResGraphType::NodeIt, n, res_graph){
+        //#define FOR_EACH_LOC(Ittype, e, g) for(Ittype e=loopFirst(Ittype(), (g)); (g).valid(e); (g).next(e))
+	//FOR_EACH_LOC(typename ResGraphType::NodeIt, n, res_graph){
+        for(typename ResGraphType::NodeIt n=loopFirst(typename ResGraphType::NodeIt(), (res_graph)); n!=INVALID; ++n){
 	  potential[n] += dijkstra.distMap()[n];
 	}
@@ -196,5 +198,7 @@
       Length mod_pot;
       Length fl_e;
-      FOR_EACH_LOC(typename Graph::EdgeIt, e, G){
+        //#define FOR_EACH_LOC(Ittype, e, g) for(Ittype e=loopFirst(Ittype(), (g)); (g).valid(e); (g).next(e))
+        //FOR_EACH_LOC(typename Graph::EdgeIt, e, G){
+        for(typename Graph::EdgeIt e=loopFirst(typename Graph::EdgeIt(), (G)); e!=INVALID; ++e){
 	//C^{\Pi}_{i,j}
 	mod_pot = length[e]-potential[G.head(e)]+potential[G.tail(e)];
Index: src/hugo/minlengthpaths.h
===================================================================
--- src/hugo/minlengthpaths.h	(revision 759)
+++ src/hugo/minlengthpaths.h	(revision 776)
@@ -84,5 +84,6 @@
       EdgeIntMap reversed(G); 
 
-      FOR_EACH_LOC(typename Graph::EdgeIt, e, G){
+      //FOR_EACH_LOC(typename Graph::EdgeIt, e, G){
+      for(typename Graph::EdgeIt e=loopFirst(typename Graph::EdgeIt(), (G)); e!=INVALID; ++e){
 	reversed[e] = mincost_flow.getFlow()[e];
       }
@@ -101,5 +102,5 @@
 	  
 	  while (!reversed[e]){
-	    G.next(e);
+	    ++e;
 	  }
 	  n = G.head(e);
Index: src/test/dijkstra_heap_test.cc
===================================================================
--- src/test/dijkstra_heap_test.cc	(revision 542)
+++ src/test/dijkstra_heap_test.cc	(revision 776)
@@ -57,5 +57,5 @@
 
   EdgeIt e;
-  for(G.first(e); G.valid(e); G.next(e)) {
+  for(G.first(e); e!=INVALID; ++e) {
     Node u=G.tail(e);
     Node v=G.head(e);
@@ -70,5 +70,5 @@
 
   NodeIt v;
-  for(G.first(v); G.valid(v); G.next(v)) {
+  for(G.first(v); v!=INVALID; ++v) {
     if ( dijkstra_test.reached(v) ) {
       Edge e=dijkstra_test.pred(v);
@@ -106,5 +106,5 @@
   error2=0;
 
-  for(G.first(e); G.valid(e); G.next(e)) {
+  for(G.first(e); e!=INVALID; ++e) {
     Node u=G.tail(e);
     Node v=G.head(e);
@@ -118,5 +118,5 @@
   }
 
-  for(G.first(v); G.valid(v); G.next(v)) {
+  for(G.first(v); v!=INVALID; ++v) {
     if ( dijkstra_test2.reached(v) ) {
       Edge e=dijkstra_test2.pred(v);
Index: src/test/dijkstra_test.cc
===================================================================
--- src/test/dijkstra_test.cc	(revision 774)
+++ src/test/dijkstra_test.cc	(revision 776)
@@ -76,5 +76,5 @@
 
 
-  for(EdgeIt e(G); e==INVALID; ++e) {
+  for(EdgeIt e(G); e!=INVALID; ++e) {
     Node u=G.tail(e);
     Node v=G.head(e);
@@ -87,5 +87,5 @@
 
   ///\bug This works only for integer lengths
-  for(NodeIt v(G); v==INVALID; ++v)
+  for(NodeIt v(G); v!=INVALID; ++v)
     if ( dijkstra_test.reached(v) ) {
       Edge e=dijkstra_test.pred(v);
