template<typename Graph, typename Number, typename FlowMap, typename CapacityMap>

   class ResGraphWrapper {

   public:

     typedef typename Graph::NodeIt NodeIt;

     typedef typename Graph::EachNodeIt EachNodeIt;

   private:

     typedef typename Graph::OutEdgeIt OldOutEdgeIt;

     typedef typename Graph::InEdgeIt OldInEdgeIt;

     const Graph* G;

     FlowMap* flow;

     const CapacityMap* capacity;

   public:

     ResGraphWrapper(const Graph& _G, FlowMap& _flow, 

 	     const CapacityMap& _capacity) : 

       G(&_G), flow(&_flow), capacity(&_capacity) { }

 //     ResGraphWrapper(const ResGraphWrapper& res_graph_wrapper) : 

 //       G(res_graph_wrapper.G), flow(res_graph_wrapper.flow), capacity(res_graph_wrapper.capacity) { }

     class EdgeIt; 

     class OutEdgeIt; 

     friend class EdgeIt; 

     friend class OutEdgeIt; 

     class EdgeIt {

       friend class ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>;

     protected:

       //const ResGraph3<Graph, Number, FlowMap, CapacityMap>* resG;

       const Graph* G;

       FlowMap* flow;

       const CapacityMap* capacity;

       //OldSymEdgeIt sym;

       OldOutEdgeIt out;

       OldInEdgeIt in;

       bool out_or_in; //true, iff out

     public:

       EdgeIt() : out_or_in(true) { } 

       EdgeIt(const Graph& _G, FlowMap& _flow, const CapacityMap& _capacity) : 

 	G(&_G), flow(&_flow), capacity(&_capacity), out_or_in(true) { }

       //EdgeIt(const EdgeIt& e) : G(e.G), flow(e.flow), capacity(e.capacity), out(e.out), in(e.in), out_or_in(e.out_or_in) { }

       Number free() const { 

 	if (out_or_in) { 

 	  return (/*resG->*/capacity->get(out)-/*resG->*/flow->get(out)); 

 	} else { 

 	  return (/*resG->*/flow->get(in)); 

 	}

       }

       bool valid() const { 

 	return out_or_in && out.valid() || in.valid(); }

       void augment(Number a) const {

 	if (out_or_in) { 

 	  /*resG->*/flow->set(out, /*resG->*/flow->get(out)+a);

 	} else { 

 	  /*resG->*/flow->set(in, /*resG->*/flow->get(in)-a);

 	}

       }

       void print() { 

 	if (out_or_in) {

 	  std::cout << "out "; 

 	  if (out.valid()) 

 	    std::cout << G->id(G->tail(out)) << "--"<< G->id(out) <<"->"<< G->id(G->head(out)); 

 	  else 

 	    std::cout << "invalid"; 

 	}

 	else {

 	  std::cout << "in "; 

 	  if (in.valid()) 

 	    std::cout << G->id(G->head(in)) << "<-"<< G->id(in) <<"--"<< G->id(G->tail(in)); 

 	  else 

 	    std::cout << "invalid"; 

 	}

 	std::cout << std::endl;

       }

     };

     Number free(OldOutEdgeIt out) const { 

       return (/*resG->*/capacity->get(out)-/*resG->*/flow->get(out)); 

     }

     Number free(OldInEdgeIt in) const { 

       return (/*resG->*/flow->get(in)); 

     }

     class OutEdgeIt : public EdgeIt {

       friend class ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>;

     public:

       OutEdgeIt() { }

     private:

       OutEdgeIt(const Graph& _G, NodeIt v, FlowMap& _flow, const CapacityMap& _capacity) : EdgeIt(_G, _flow, _capacity) { 

 	//out=/*resG->*/G->template first<OldOutEdgeIt>(v);

 	G->getFirst(out, v);

 	while( out.valid() && !(EdgeIt::free()>0) ) { ++out; }

 	if (!out.valid()) {

 	  out_or_in=0;

 	  //in=/*resG->*/G->template first<OldInEdgeIt>(v);

 	  G->getFirst(in, v);

 	  while( in.valid() && !(EdgeIt::free()>0) ) { ++in; }

 	}

       }

     public:

       OutEdgeIt& operator++() { 

 	if (out_or_in) {

 	  NodeIt v=/*resG->*/G->aNode(out);

 	  ++out;

 	  while( out.valid() && !(EdgeIt::free()>0) ) { ++out; }

 	  if (!out.valid()) {

 	    out_or_in=0;

 	    G->getFirst(in, v); //=/*resG->*/G->template first<OldInEdgeIt>(v);

 	    while( in.valid() && !(EdgeIt::free()>0) ) { ++in; }

 	  }

 	} else {

 	  ++in;

 	  while( in.valid() && !(EdgeIt::free()>0) ) { ++in; } 

 	}

 	return *this; 

       }

     };

     class EachEdgeIt : public EdgeIt {

       friend class ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>;

       typename Graph::EachNodeIt v;

     public:

       EachEdgeIt() { }

       //EachEdgeIt(const EachEdgeIt& e) : EdgeIt(e), v(e.v) { }

       EachEdgeIt(const Graph& _G, FlowMap& _flow, const CapacityMap& _capacity) : EdgeIt(_G, _flow, _capacity) { 

 	out_or_in=true;

 	G->getFirst(v);

 	if (v.valid()) G->getFirst(out, v); else out=OldOutEdgeIt();

 	while (out.valid() && !(EdgeIt::free()>0) ) { ++out; }

 	while (v.valid() && !out.valid()) { 

 	  ++v; 

 	  if (v.valid()) G->getFirst(out, v); 

 	  while (out.valid() && !(EdgeIt::free()>0) ) { ++out; }

 	}

 	if (!out.valid()) {

 	  out_or_in=0;

 	  G->getFirst(v);

 	  if (v.valid()) G->getFirst(in, v); else in=OldInEdgeIt();

 	  while (in.valid() && !(EdgeIt::free()>0) ) { ++in; }

 	  while (v.valid() && !in.valid()) { 

 	    ++v; 

 	    if (v.valid()) G->getFirst(in, v); 

 	    while (in.valid() && !(EdgeIt::free()>0) ) { ++in; }

 	  }

 	}

       }

       EachEdgeIt& operator++() { 

 	if (out_or_in) {

 	  ++out;

 	  while (out.valid() && !(EdgeIt::free()>0) ) { ++out; }

 	  while (v.valid() && !out.valid()) { 

 	    ++v; 

 	    if (v.valid()) G->getFirst(out, v); 

 	    while (out.valid() && !(EdgeIt::free()>0) ) { ++out; }

 	  }

 	  if (!out.valid()) {

 	    out_or_in=0;

 	    G->getFirst(v);

 	    if (v.valid()) G->getFirst(in, v); else in=OldInEdgeIt();

 	    while (in.valid() && !(EdgeIt::free()>0) ) { ++in; }

 	    while (v.valid() && !in.valid()) { 

 	      ++v; 

 	      if (v.valid()) G->getFirst(in, v); 

 	      while (in.valid() && !(EdgeIt::free()>0) ) { ++in; }

 	    }  

 	  }

 	} else {

 	  ++in;

 	  while (in.valid() && !(EdgeIt::free()>0) ) { ++in; }

 	  while (v.valid() && !in.valid()) { 

 	    ++v; 

 	    if (v.valid()) G->getFirst(in, v); 

 	    while (in.valid() && !(EdgeIt::free()>0) ) { ++in; }

 	  }

 	}

 	return *this;

       }

     };

     void getFirst(EachNodeIt& v) const { G->getFirst(v); }

     void getFirst(OutEdgeIt& e, NodeIt v) const { 

       e=OutEdgeIt(*G, v, *flow, *capacity); 

     }

     void getFirst(EachEdgeIt& e) const { 

       e=EachEdgeIt(*G, *flow, *capacity); 

     }

     EachNodeIt& next(EachNodeIt& n) const { return G->next(n); }

     OutEdgeIt& next(OutEdgeIt& e) const { 

       if (e.out_or_in) {

 	NodeIt v=G->aNode(e.out);

 	++(e.out);

 	while( G->valid(e.out) && !(e.free()>0) ) { ++(e.out); }

 	if (!G->valid(e.out)) {

 	  e.out_or_in=0;

 	  G->getFirst(e.in, v); //=/*resG->*/G->template first<OldInEdgeIt>(v);

 	  while( G->valid(e.in) && !(e.free()>0) ) { ++(e.in); }

 	}

       } else {

 	++(e.in);

 	while( G->valid(e.in) && !(e.free()>0) ) { ++(e.in); } 

       }

       return e;

     }

     EachEdgeIt& next(EachEdgeIt& e) const { 

       if (e.out_or_in) {

 	++(e.out);

 	while (G->valid(e.out) && !(e.free()>0) ) { ++(e.out); }

 	  while (G->valid(e.v) && !G->valid(e.out)) { 

 	    ++(e.v); 

 	    if (G->valid(e.v)) G->getFirst(e.out, e.v); 

 	    while (G->valid(e.out) && !(e.free()>0) ) { ++(e.out); }

 	  }

 	  if (!G->valid(e.out)) {

 	    e.out_or_in=0;

 	    G->getFirst(e.v);

 	    if (G->valid(e.v)) G->getFirst(e.in, e.v); else e.in=OldInEdgeIt();

 	    while (G->valid(e.in) && !(e.free()>0) ) { ++(e.in); }

 	    while (G->valid(e.v) && !G->valid(e.in)) { 

 	      ++(e.v); 

 	      if (G->valid(e.v)) G->getFirst(e.in, e.v); 

 	      while (G->valid(e.in) && !(e.free()>0) ) { ++(e.in); }

 	    }  

 	  }

 	} else {

 	  ++(e.in);

 	  while (G->valid(e.in) && !(e.free()>0) ) { ++(e.in); }

 	  while (G->valid(e.v) && !G->valid(e.in)) { 

 	    ++(e.v); 

 	    if (G->valid(e.v)) G->getFirst(e.in, e.v); 

 	    while (G->valid(e.in) && !(e.free()>0) ) { ++(e.in); }

 	  }

 	}

 	return e;

       }

     template< typename It >

     It first() const { 

       It e;

       getFirst(e);

       return e; 

     }

     template< typename It >

     It first(NodeIt v) const { 

       It e;

       getFirst(e, v);

       return e; 

     }

     NodeIt tail(EdgeIt e) const { 

       return ((e.out_or_in) ? G->aNode(e.out) : G->aNode(e.in)); }

     NodeIt head(EdgeIt e) const { 

       return ((e.out_or_in) ? G->bNode(e.out) : G->bNode(e.in)); }

     NodeIt aNode(OutEdgeIt e) const { 

       return ((e.out_or_in) ? G->aNode(e.out) : G->aNode(e.in)); }

     NodeIt bNode(OutEdgeIt e) const { 

       return ((e.out_or_in) ? G->bNode(e.out) : G->bNode(e.in)); }

     int id(NodeIt v) const { return G->id(v); }

     bool valid(NodeIt n) const { return G->valid(n); }

     bool valid(EdgeIt e) const { 

       return e.out_or_in ? G->valid(e.out) : G->valid(e.in); }

     template <typename T>

     class NodeMap {

       typename Graph::NodeMap<T> node_map; 

     public:

       NodeMap(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G) : node_map(*(_G.G)) { }

       NodeMap(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G, T a) : node_map(*(_G.G), a) { }

       void set(NodeIt nit, T a) { node_map.set(nit, a); }

       T get(NodeIt nit) const { return node_map.get(nit); }

     };

     template <typename T>

     class EdgeMap {

       typename Graph::EdgeMap<T> forward_map, backward_map; 

     public:

       EdgeMap(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G) : forward_map(*(_G.G)), backward_map(*(_G.G)) { }

       EdgeMap(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& _G, T a) : forward_map(*(_G.G), a), backward_map(*(_G.G), a) { }

       void set(EdgeIt e, T a) { 

 	if (e.out_or_in) 

 	  forward_map.set(e.out, a); 

 	else 

 	  backward_map.set(e.in, a); 

       }

       T get(EdgeIt e) { 

 	if (e.out_or_in) 

 	  return forward_map.get(e.out); 

 	else 

 	  return backward_map.get(e.in); 

       }

     };

   };