//     template<typename MutableGraph> bool augmentOnBlockingFlow() {      

 //       bool _augment=false;

 //       AugGraph res_graph(*G, *flow, *capacity);

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

 //       BfsIterator5< AugGraph /*, AugOutEdgeIt*/, ReachedMap > bfs(res_graph);

 //       bfs.pushAndSetReached(s);

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

 //       while ( !bfs.finished() ) { 

 // 	AugOutEdgeIt e=bfs;

 // 	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

 //       MutableGraph F;

 //       typename AugGraph::NodeMap<typename MutableGraph::Node> 

 // 	res_graph_to_F(res_graph);

 //       for(typename AugGraph::NodeIt n=res_graph.template first<typename AugGraph::NodeIt>(); res_graph.valid(n); res_graph.next(n)) {

 // 	res_graph_to_F.set(n, F.addNode());

 //       }

 //       typename MutableGraph::Node sF=res_graph_to_F.get(s);

 //       typename MutableGraph::Node tF=res_graph_to_F.get(t);

 //       typename MutableGraph::EdgeMap<AugEdge> original_edge(F);

 //       typename MutableGraph::EdgeMap<Number> residual_capacity(F);

 //       //Making F to the graph containing the edges of the residual graph 

 //       //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)));

 // 	  original_edge.update();

 // 	  original_edge.set(f, e);

 // 	  residual_capacity.update();

 // 	  residual_capacity.set(f, res_graph.free(e));

 // 	} 

 //       }

 //       bool __augment=true;

 //       while (__augment) {

 // 	__augment=false;

 // 	//computing blocking flow with dfs

 // 	typedef typename TrivGraphWrapper<MutableGraph>::NodeMap<bool> BlockingReachedMap;

 // 	DfsIterator5< TrivGraphWrapper<MutableGraph>/*, typename MutableGraph::OutEdgeIt*/, BlockingReachedMap > dfs(F);

 // 	typename MutableGraph::NodeMap<typename MutableGraph::Edge> pred(F);

 // 	pred.set(sF, typename MutableGraph::Edge(INVALID));

 // 	//invalid iterators for sources

 // 	typename MutableGraph::NodeMap<Number> free(F);

 // 	dfs.pushAndSetReached(sF);      

 // 	while (!dfs.finished()) {

 // 	  ++dfs;

 // 	  if (F.valid(typename MutableGraph::OutEdgeIt(dfs))) {

 // 	    if (dfs.isBNodeNewlyReached()) {

 // 	      typename MutableGraph::Node v=F.aNode(dfs);

 // 	      typename MutableGraph::Node w=F.bNode(dfs);

 // 	      pred.set(w, dfs);

 // 	      if (F.valid(pred.get(v))) {

 // 		free.set(w, std::min(free.get(v), residual_capacity.get(dfs)));

 // 	      } else {

 // 		free.set(w, residual_capacity.get(dfs)); 

 // 	      }

 // 	      if (w==tF) { 

 // 		__augment=true; 

 // 		_augment=true;

 // 		break; 

 // 	      }

 // 	    } else {

 // 	      F.erase(typename MutableGraph::OutEdgeIt(dfs));

 // 	    }

 // 	  } 

 // 	}

 // 	if (__augment) {

 // 	  typename MutableGraph::Node n=tF;

 // 	  Number augment_value=free.get(tF);

 // 	  while (F.valid(pred.get(n))) { 

 // 	    typename MutableGraph::Edge e=pred.get(n);

 // 	    res_graph.augment(original_edge.get(e), augment_value); 

 // 	    n=F.tail(e);

 // 	    if (residual_capacity.get(e)==augment_value) 

 // 	      F.erase(e); 

 // 	    else 

 // 	      residual_capacity.set(e, residual_capacity.get(e)-augment_value);

 // 	  }

 // 	}

 //       }

 //       return _augment;

 //     }

     template<typename GraphWrapper> 

     class DistanceMap {

     protected:

       GraphWrapper gw;

       typename GraphWrapper::NodeMap<int> dist; 

     public:

       DistanceMap(GraphWrapper& _gw) : gw(_gw), dist(_gw, _gw.nodeNum()) { }

       //NodeMap(const ListGraph& _G, T a) : 

       //G(_G), container(G.node_id, a) { }

       void set(const typename GraphWrapper::Node& n, int a) { dist[n]=a; }

       int get(const typename GraphWrapper::Node& n) const { return dist[n]; }

       bool get(const typename GraphWrapper::Edge& e) const { 

 	return (dist.get(gw.tail(e))<dist.get(gw.head(e))); 

       }

       //typename std::vector<T>::reference operator[](Node n) { 

       //return container[/*G.id(n)*/n.node->id]; }

       //typename std::vector<T>::const_reference operator[](Node n) const { 

       //return container[/*G.id(n)*/n.node->id]; 

     };

 //       MutableGraph F;

 //       typename AugGraph::NodeMap<typename MutableGraph::Node> 

 // 	res_graph_to_F(res_graph);

 //       for(typename AugGraph::NodeIt n=res_graph.template first<typename AugGraph::NodeIt>(); res_graph.valid(n); res_graph.next(n)) {

 // 	res_graph_to_F.set(n, F.addNode());

 //       }

 //       typename MutableGraph::Node sF=res_graph_to_F.get(s);

 //       typename MutableGraph::Node tF=res_graph_to_F.get(t);

 //       typename MutableGraph::EdgeMap<AugEdge> original_edge(F);

 //       typename MutableGraph::EdgeMap<Number> residual_capacity(F);

 //       //Making F to the graph containing the edges of the residual graph 

 //       //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)));

 // 	  original_edge.update();

 // 	  original_edge.set(f, e);

 // 	  residual_capacity.update();

 // 	  residual_capacity.set(f, res_graph.free(e));

 // 	} 

 //       }

       typedef SubGraphWrapper<AugGraph, DistanceMap<AugGraph> > FilterResGraph;

       FilterResGraph filter_res_graph(res_graph, dist);