Index: src/work/marci/bipartite_graph_wrapper_test.cc
===================================================================
--- src/work/marci/bipartite_graph_wrapper_test.cc	(revision 409)
+++ src/work/marci/bipartite_graph_wrapper_test.cc	(revision 476)
@@ -12,5 +12,5 @@
 #include <graph_wrapper.h>
 #include <maps.h>
-#include <edmonds_karp.h>
+#include <preflow.h>
 
 using namespace hugo;
Index: src/work/marci/bipartite_matching_try.cc
===================================================================
--- src/work/marci/bipartite_matching_try.cc	(revision 465)
+++ src/work/marci/bipartite_matching_try.cc	(revision 476)
@@ -13,5 +13,4 @@
 #include <graph_wrapper.h>
 #include <maps.h>
-#include <edmonds_karp.h>
 #include <preflow.h>
 
@@ -181,5 +180,5 @@
   ts.reset();
   stGW::EdgeMap<int> pre_flow(stgw);
-  Preflow<stGW, int, ConstMap<stGW::Edge, int>, stGW::EdgeMap<int> > 
+  MaxFlow<stGW, int, ConstMap<stGW::Edge, int>, stGW::EdgeMap<int> > 
     pre_flow_test(stgw, stgw.S_NODE, stgw.T_NODE, const1map, pre_flow/*, true*/);
   pre_flow_test.run();
Index: src/work/marci/lg_vs_sg.cc
===================================================================
--- src/work/marci/lg_vs_sg.cc	(revision 465)
+++ src/work/marci/lg_vs_sg.cc	(revision 476)
@@ -7,5 +7,4 @@
 #include <smart_graph.h>
 #include <dimacs.h>
-#include <edmonds_karp.h>
 #include <preflow.h>
 #include <time_measure.h>
@@ -35,8 +34,6 @@
     Timer ts;
     Graph::EdgeMap<int> flow(G); //0 flow
-    Preflow<Graph, int, Graph::EdgeMap<int>, Graph::EdgeMap<int> > 
-      pre_flow_test(G, s, t, cap, flow/*, true*/);
     MaxFlow<Graph, int, Graph::EdgeMap<int>, Graph::EdgeMap<int> > 
-      max_flow_test(G, s, t, cap, flow);
+      max_flow_test(G, s, t, cap, flow/*, true*/);
 
     std::cout << "ListGraph ..." << std::endl;
@@ -45,7 +42,7 @@
       std::cout << "preflow ..." << std::endl;
       ts.reset();
-      pre_flow_test.run();
+      max_flow_test.run();
       std::cout << "elapsed time: " << ts << std::endl;
-      std::cout << "flow value: "<< pre_flow_test.flowValue() << std::endl;
+      std::cout << "flow value: "<< max_flow_test.flowValue() << std::endl;
     }
 
@@ -61,14 +58,14 @@
     }
 
-    {
-      std::cout << "faster physical blocking flow augmentation ..." << std::endl;
-      FOR_EACH_LOC(Graph::EdgeIt, e, G) flow.set(e, 0);
-      ts.reset();
-      int i=0;
-      while (max_flow_test.augmentOnBlockingFlow1<MutableGraph>()) { ++i; }
-      std::cout << "elapsed time: " << ts << std::endl;
-      std::cout << "number of augmentation phases: " << i << std::endl; 
-      std::cout << "flow value: "<< max_flow_test.flowValue() << std::endl;
-    }
+//     {
+//       std::cout << "faster physical blocking flow augmentation ..." << std::endl;
+//       FOR_EACH_LOC(Graph::EdgeIt, e, G) flow.set(e, 0);
+//       ts.reset();
+//       int i=0;
+//       while (max_flow_test.augmentOnBlockingFlow1<MutableGraph>()) { ++i; }
+//       std::cout << "elapsed time: " << ts << std::endl;
+//       std::cout << "number of augmentation phases: " << i << std::endl; 
+//       std::cout << "flow value: "<< max_flow_test.flowValue() << std::endl;
+//     }
 
     {
@@ -109,8 +106,8 @@
     Timer ts;
     Graph::EdgeMap<int> flow(G); //0 flow
-    Preflow<Graph, int, Graph::EdgeMap<int>, Graph::EdgeMap<int> > 
-      pre_flow_test(G, s, t, cap, flow/*, true*/);
     MaxFlow<Graph, int, Graph::EdgeMap<int>, Graph::EdgeMap<int> > 
-      max_flow_test(G, s, t, cap, flow);
+      max_flow_test(G, s, t, cap, flow/*, true*/);
+    //    MaxFlow<Graph, int, Graph::EdgeMap<int>, Graph::EdgeMap<int> > 
+    //  max_flow_test(G, s, t, cap, flow);
 
     std::cout << "SmatrGraph ..." << std::endl;
@@ -120,7 +117,7 @@
       FOR_EACH_LOC(Graph::EdgeIt, e, G) flow.set(e, 0);
       ts.reset();
-      pre_flow_test.run();
+      max_flow_test.run();
       std::cout << "elapsed time: " << ts << std::endl;
-      std::cout << "flow value: "<< pre_flow_test.flowValue() << std::endl;
+      std::cout << "flow value: "<< max_flow_test.flowValue() << std::endl;
     }
 
@@ -136,14 +133,14 @@
     }
 
-    {
-      std::cout << "faster physical blocking flow augmentation ..." << std::endl;
-      FOR_EACH_LOC(Graph::EdgeIt, e, G) flow.set(e, 0);
-      ts.reset();
-      int i=0;
-      while (max_flow_test.augmentOnBlockingFlow1<MutableGraph>()) { ++i; }
-      std::cout << "elapsed time: " << ts << std::endl;
-      std::cout << "number of augmentation phases: " << i << std::endl; 
-      std::cout << "flow value: "<< max_flow_test.flowValue() << std::endl;
-    }
+//     {
+//       std::cout << "faster physical blocking flow augmentation ..." << std::endl;
+//       FOR_EACH_LOC(Graph::EdgeIt, e, G) flow.set(e, 0);
+//       ts.reset();
+//       int i=0;
+//       while (max_flow_test.augmentOnBlockingFlow1<MutableGraph>()) { ++i; }
+//       std::cout << "elapsed time: " << ts << std::endl;
+//       std::cout << "number of augmentation phases: " << i << std::endl; 
+//       std::cout << "flow value: "<< max_flow_test.flowValue() << std::endl;
+//     }
 
     {
Index: src/work/marci/makefile
===================================================================
--- src/work/marci/makefile	(revision 433)
+++ src/work/marci/makefile	(revision 476)
@@ -5,5 +5,5 @@
 
 LEDABINARIES = leda_graph_demo leda_bfs_dfs max_bipartite_matching_demo
-BINARIES = edmonds_karp_demo iterator_bfs_demo macro_test lg_vs_sg bfsit_vs_byhand bipartite_graph_wrapper_test bipartite_matching_try
+BINARIES = max_flow_demo iterator_bfs_demo macro_test lg_vs_sg bfsit_vs_byhand bipartite_graph_wrapper_test bipartite_matching_try
 #gw_vs_not preflow_demo_boost edmonds_karp_demo_boost preflow_demo_jacint preflow_demo_athos edmonds_karp_demo_alpar preflow_demo_leda
 
Index: src/work/marci/max_flow_demo.cc
===================================================================
--- src/work/marci/max_flow_demo.cc	(revision 475)
+++ src/work/marci/max_flow_demo.cc	(revision 476)
@@ -6,5 +6,4 @@
 #include <smart_graph.h>
 #include <dimacs.h>
-//#include <edmonds_karp.h>
 #include <time_measure.h>
 //#include <graph_wrapper.h>
@@ -71,19 +70,13 @@
   Timer ts;
   Graph::EdgeMap<int> flow(G); //0 flow
-  Preflow<Graph, int, Graph::EdgeMap<int>, Graph::EdgeMap<int> > 
-    pre_flow_test(G, s, t, cap, flow/*, true*/);
-  //  Preflow<Graph, int, Graph::EdgeMap<int>, Graph::EdgeMap<int> > 
-  //  pre_flow_ize(G, s, t, cap, flow/*, false*/);
-//   PreflowRes<Graph, int, Graph::EdgeMap<int>, Graph::EdgeMap<int> > 
-//     pre_flow_res(G, s, t, cap, flow/*, true*/);
-  //MaxFlow<Graph, int, Graph::EdgeMap<int>, Graph::EdgeMap<int> > 
-  //  max_flow_test(G, s, t, cap, flow);
+  MaxFlow<Graph, int, Graph::EdgeMap<int>, Graph::EdgeMap<int> > 
+    max_flow_test(G, s, t, cap, flow);
 
   {
     std::cout << "preflow ..." << std::endl;
     ts.reset();
-    pre_flow_test.run();
+    max_flow_test.run();
     std::cout << "elapsed time: " << ts << std::endl;
-    std::cout << "flow value: "<< pre_flow_test.flowValue() << std::endl;
+    std::cout << "flow value: "<< max_flow_test.flowValue() << std::endl;
   }
 
@@ -92,7 +85,7 @@
     FOR_EACH_LOC(Graph::EdgeIt, e, G) flow.set(e, 0);
     ts.reset();
-    pre_flow_test.preflow(Preflow<Graph, int, Graph::EdgeMap<int>, Graph::EdgeMap<int> >::GEN_FLOW);
+    max_flow_test.preflow(MaxFlow<Graph, int, Graph::EdgeMap<int>, Graph::EdgeMap<int> >::GEN_FLOW);
     std::cout << "elapsed time: " << ts << std::endl;
-    std::cout << "flow value: "<< pre_flow_test.flowValue() << std::endl;
+    std::cout << "flow value: "<< max_flow_test.flowValue() << std::endl;
   }
 
@@ -111,8 +104,8 @@
     ts.reset();
     int i=0;
-    while (pre_flow_test.augmentOnBlockingFlow<MutableGraph>()) { ++i; }
+    while (max_flow_test.augmentOnBlockingFlow<MutableGraph>()) { ++i; }
     std::cout << "elapsed time: " << ts << std::endl;
     std::cout << "number of augmentation phases: " << i << std::endl; 
-    std::cout << "flow value: "<< pre_flow_test.flowValue() << std::endl;
+    std::cout << "flow value: "<< max_flow_test.flowValue() << std::endl;
   }
 
@@ -133,8 +126,8 @@
     ts.reset();
     int i=0;
-    while (pre_flow_test.augmentOnBlockingFlow2()) { ++i; }
+    while (max_flow_test.augmentOnBlockingFlow2()) { ++i; }
     std::cout << "elapsed time: " << ts << std::endl;
     std::cout << "number of augmentation phases: " << i << std::endl; 
-    std::cout << "flow value: "<< pre_flow_test.flowValue() << std::endl;
+    std::cout << "flow value: "<< max_flow_test.flowValue() << std::endl;
   }
 
@@ -144,8 +137,8 @@
     ts.reset();
     int i=0;
-    while (pre_flow_test.augmentOnShortestPath()) { ++i; }
+    while (max_flow_test.augmentOnShortestPath()) { ++i; }
     std::cout << "elapsed time: " << ts << std::endl;
     std::cout << "number of augmentation phases: " << i << std::endl; 
-    std::cout << "flow value: "<< pre_flow_test.flowValue() << std::endl;
+    std::cout << "flow value: "<< max_flow_test.flowValue() << std::endl;
   }
 
