}

 	}

       }

       return _augment;

     }

     bool augmentOnBlockingFlow2() {

       bool _augment=false;

       //typedef ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap> EAugGraph;

       typedef FilterGraphWrapper< ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap> > EAugGraph;

       typedef typename EAugGraph::OutEdgeIt EAugOutEdgeIt;

       typedef typename EAugGraph::EdgeIt EAugEdgeIt;

       EAugGraph res_graph(*G, *flow, *capacity);

       //std::cout << "meg jo1" << std::endl;

       //typedef typename EAugGraph::NodeMap<bool> ReachedMap;

       BfsIterator4< 

 	ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>, 

 	ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::OutEdgeIt, 

 	ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::NodeMap<bool> > bfs(res_graph);

       //std::cout << "meg jo2" << std::endl;

       bfs.pushAndSetReached(s);

       //std::cout << "meg jo2.5" << std::endl;

       //typename EAugGraph::NodeMap<int> dist(res_graph); //filled up with 0's

       typename ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::

 	NodeMap<int>& dist=res_graph.dist;

       //std::cout << "meg jo2.6" << std::endl;

       while ( !bfs.finished() ) {

 	ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::OutEdgeIt e=bfs;

 //	EAugOutEdgeIt e=/*AugOutEdgeIt*/(bfs);

  	//if (res_graph.valid(e)) {

  	//    std::cout<<"a:"<<res_graph.tail(e)<<"b:"<<res_graph.head(e)<<std::endl;

  	//}

 	if (res_graph.valid(e) && bfs.isBNodeNewlyReached()) {

 	  dist.set(res_graph.head(e), dist.get(res_graph.tail(e))+1);

 	}

 	++bfs;	

       } //computing distances from s in the residual graph

       //std::cout << "meg jo3" << std::endl;

 //       typedef typename EAugGraph::EachNodeIt EAugEachNodeIt;

 //       for(EAugEachNodeIt n=res_graph.template first<EAugEachNodeIt>(); res_graph.valid(n); res_graph.next(n)) {

 // 	std::cout << "dist: " << dist.get(n) << std::endl;

 //       }

       bool __augment=true;

       while (__augment) {

 //	std::cout << "new iteration"<< std::endl;

 	__augment=false;

 	//computing blocking flow with dfs

 	typedef typename EAugGraph::NodeMap<bool> BlockingReachedMap;

 	DfsIterator4< EAugGraph, EAugOutEdgeIt, BlockingReachedMap > 

 	  dfs(res_graph);

 	typename EAugGraph::NodeMap<EAugEdgeIt> pred(res_graph); //invalid iterators

 	typename EAugGraph::NodeMap<Number> free(res_graph);

 	dfs.pushAndSetReached(s);

 	while (!dfs.finished()) {

 	  ++dfs;

 	  if (res_graph.valid(EAugOutEdgeIt(dfs))) { 

 	    if (dfs.isBNodeNewlyReached()) {

 // 	      std::cout << "OutEdgeIt: " << dfs; 

 // 	      std::cout << " aNode: " << res_graph.aNode(dfs); 

 // 	      std::cout << " res cap: " << EAugOutEdgeIt(dfs).free(); 

 // 	      std::cout << " bNode: " << res_graph.bNode(dfs) << " ";

 	      typename EAugGraph::NodeIt v=res_graph.aNode(dfs);

 	      typename EAugGraph::NodeIt w=res_graph.bNode(dfs);

 	      pred.set(w, EAugOutEdgeIt(dfs));

 	      //std::cout << EAugOutEdgeIt(dfs).free() << std::endl;

 	      if (res_graph.valid(pred.get(v))) {

 		free.set(w, std::min(free.get(v), res_graph.free(/*EAugOutEdgeIt*/(dfs))));

 	      } else {

 		free.set(w, res_graph.free(/*EAugOutEdgeIt*/(dfs))); 

 	      }

 	      if (w==t) { 

 //		std::cout << "t is reached, AUGMENTATION"<<std::endl;

 		__augment=true; 

 		_augment=true;

 		break; 

 	      }

 	    } else {

 //	      std::cout << "<<DELETE ";

 //	      std::cout << " aNode: " << res_graph.aNode(dfs); 

 //	      std::cout << " res cap: " << EAugOutEdgeIt(dfs).free(); 

 //	      std::cout << " bNode: " << res_graph.bNode(dfs) << " ";

 //	      std::cout << "DELETE>> ";

 	      res_graph.erase(dfs);

 	    }

 	  } 

 	}

 	if (__augment) {

 	  typename EAugGraph::NodeIt n=t;

 	  Number augment_value=free.get(t);

 //	  std::cout << "av:" << augment_value << std::endl;

 	  while (res_graph.valid(pred.get(n))) { 

 	    EAugEdgeIt e=pred.get(n);

 	    res_graph.augment(e, augment_value);

 	    //e.augment(augment_value); 

 	    n=res_graph.tail(e);

 	    if (res_graph.free(e)==0)

 	      res_graph.erase(e);