Index: src/work/list_graph.h
===================================================================
--- src/work/list_graph.h	(revision 208)
+++ src/work/list_graph.h	(revision 212)
@@ -429,5 +429,5 @@
       //protected: 
     public: //for alpar
-      EdgeIt(const ListGraph&) {
+      EdgeIt(const ListGraph& G) {
 	node_item* v=G._first_node;
 	if (v) edge=v->_first_out_edge; else edge=0;
Index: src/work/marci/graph_wrapper.h
===================================================================
--- src/work/marci/graph_wrapper.h	(revision 199)
+++ src/work/marci/graph_wrapper.h	(revision 212)
@@ -30,7 +30,7 @@
     Graph& getGraph() const { return (*graph); }
     
-    template<typename I> I& /*getF*/first(I& i) const { return graph->/*getF*/first(i); }
-    template<typename I, typename P> I& /*getF*/first(I& i, const P& p) const { 
-      return graph->/*getF*/first(i, p); }
+    template<typename I> I& first(I& i) const { return graph->first(i); }
+    template<typename I, typename P> I& first(I& i, const P& p) const { 
+      return graph->first(i, p); }
     
     template<typename I> I getNext(const I& i) const { 
@@ -39,8 +39,8 @@
 
     template< typename It > It first() const { 
-      It e; /*getF*/first(e); return e; }
+      It e; first(e); return e; }
 
     template< typename It > It first(const Node& v) const { 
-      It e; /*getF*/first(e, v); return e; }
+      It e; first(e, v); return e; }
 
     Node head(const Edge& e) const { return graph->head(e); }
@@ -83,4 +83,79 @@
       EdgeMap(const TrivGraphWrapper<Graph>& _G, T a) : 
 	Graph::EdgeMap<T>(_G.getGraph(), a) { }
+    };
+  };
+
+  template<typename GraphWrapper>
+  class GraphWrapperSkeleton {
+  protected:
+    GraphWrapper gw;
+  
+  public:
+    typedef typename GraphWrapper::BaseGraph BaseGraph;
+
+    typedef typename GraphWrapper::Node Node;
+    typedef typename GraphWrapper::NodeIt NodeIt;
+
+    typedef typename GraphWrapper::Edge Edge;
+    typedef typename GraphWrapper::OutEdgeIt OutEdgeIt;
+    typedef typename GraphWrapper::InEdgeIt InEdgeIt;
+    //typedef typename GraphWrapper::SymEdgeIt SymEdgeIt;
+    typedef typename GraphWrapper::EdgeIt EdgeIt;
+
+    //GraphWrapperSkeleton() : gw() { }
+    GraphWrapperSkeleton(GraphWrapper& _gw) : gw(_gw) { }
+
+    void setGraph(BaseGraph& _graph) { gw.setGraph(_graph); }
+    BaseGraph& getGraph() const { return gw.getGraph(); }
+    
+    template<typename I> I& first(I& i) const { return gw.first(i); }
+    template<typename I, typename P> I& first(I& i, const P& p) const { 
+      return gw.first(i, p); }
+    
+    template<typename I> I getNext(const I& i) const { return gw.getNext(i); }
+    template<typename I> I& next(I &i) const { return gw.next(i); }    
+
+    template< typename It > It first() const { 
+      It e; this->first(e); return e; }
+
+    template< typename It > It first(const Node& v) const { 
+      It e; this->first(e, v); return e; }
+
+    Node head(const Edge& e) const { return gw.head(e); }
+    Node tail(const Edge& e) const { return gw.tail(e); }
+
+    template<typename I> bool valid(const I& i) const { return gw.valid(i); }
+  
+    //template<typename I> void setInvalid(const I &i);
+    //{ return graph->setInvalid(i); }
+
+    int nodeNum() const { return gw.nodeNum(); }
+    int edgeNum() const { return gw.edgeNum(); }
+  
+    template<typename I> Node aNode(const I& e) const { return gw.aNode(e); }
+    template<typename I> Node bNode(const I& e) const { return gw.bNode(e); }
+  
+    Node addNode() const { return gw.addNode(); }
+    Edge addEdge(const Node& tail, const Node& head) const { 
+      return gw.addEdge(tail, head); }
+  
+    template<typename I> void erase(const I& i) const { gw.erase(i); }
+  
+    void clear() const { gw.clear(); }
+    
+    template<typename T> class NodeMap : public GraphWrapper::NodeMap<T> { 
+    public:
+      NodeMap(const GraphWrapperSkeleton<GraphWrapper>& _G) : 
+	GraphWrapper::NodeMap<T>(_G.gw) { }
+      NodeMap(const GraphWrapperSkeleton<GraphWrapper>& _G, T a) : 
+	GraphWrapper::NodeMap<T>(_G.gw, a) { }
+    };
+
+    template<typename T> class EdgeMap : public GraphWrapper::EdgeMap<T> { 
+    public:
+      EdgeMap(const GraphWrapperSkeleton<GraphWrapper>& _G) : 
+	GraphWrapper::EdgeMap<T>(_G.gw) { }
+      EdgeMap(const GraphWrapperSkeleton<GraphWrapper>& _G, T a) : 
+	GraphWrapper::EdgeMap<T>(_G.gw, a) { }
     };
   };
@@ -110,7 +185,7 @@
     Graph& getGraph() const { return (*graph); }
     
-    template<typename I> I& /*getF*/first(I& i) const { return graph->/*getF*/first(i); }
-    template<typename I, typename P> I& /*getF*/first(I& i, const P& p) const { 
-      return graph->/*getF*/first(i, p); }
+    template<typename I> I& first(I& i) const { return graph->first(i); }
+    template<typename I, typename P> I& first(I& i, const P& p) const { 
+      return graph->first(i, p); }
 
     template<typename I> I getNext(const I& i) const { 
@@ -119,8 +194,8 @@
 
     template< typename It > It first() const { 
-      It e; /*getF*/first(e); return e; }
+      It e; first(e); return e; }
 
     template< typename It > It first(const Node& v) const { 
-      It e; /*getF*/first(e, v); return e; }
+      It e; first(e, v); return e; }
 
     Node head(const Edge& e) const { return graph->tail(e); }
@@ -228,18 +303,18 @@
       OutEdgeIt(const UndirGraphWrapper& _G, const Node& n) : Edge() { 
 	out_or_in=true;
-	_G.graph->/*getF*/first(out, n);
+	_G.graph->first(out, n);
 	if (!(_G.graph->valid(out))) {
 	  out_or_in=false;
-	  _G.graph->/*getF*/first(in, n);
+	  _G.graph->first(in, n);
 	}
       }
     };
 
-    OutEdgeIt& /*getF*/first(OutEdgeIt& e, const Node& n) const {
+    OutEdgeIt& first(OutEdgeIt& e, const Node& n) const {
       e.out_or_in=true;
-      graph->/*getF*/first(e.out, n);
+      graph->first(e.out, n);
       if (!(graph->valid(e.out))) {
 	e.out_or_in=false;
-	graph->/*getF*/first(e.in, n);
+	graph->first(e.in, n);
       }
       return e;
@@ -252,5 +327,5 @@
 	if (!graph->valid(e.out)) {
 	  e.out_or_in=false;
-	  graph->/*getF*/first(e.in, n);
+	  graph->first(e.in, n);
 	}
       } else {
@@ -267,7 +342,7 @@
     typedef OutEdgeIt InEdgeIt; 
 
-    template<typename I> I& /*getF*/first(I& i) const { return graph->/*getF*/first(i); }
-//     template<typename I, typename P> I& /*getF*/first(I& i, const P& p) const { 
-//       return graph->/*getF*/first(i, p); }
+    template<typename I> I& first(I& i) const { return graph->first(i); }
+//     template<typename I, typename P> I& first(I& i, const P& p) const { 
+//       return graph->first(i, p); }
     
     template<typename I> I getNext(const I& i) const { 
@@ -276,8 +351,8 @@
 
     template< typename It > It first() const { 
-      It e; /*getF*/first(e); return e; }
+      It e; first(e); return e; }
 
     template< typename It > It first(const Node& v) const { 
-      It e; /*getF*/first(e, v); return e; }
+      It e; first(e, v); return e; }
 
     Node head(const Edge& e) const { return graph->head(e); }
@@ -349,15 +424,15 @@
 //     int edgeNum() const { return graph->edgeNum(); }
     
-//     template<typename I> I& /*getF*/first(I& i) const { return graph->/*getF*/first(i); }
-//     template<typename I, typename P> I& /*getF*/first(I& i, const P& p) const { 
-//       return graph->/*getF*/first(i, p); }
+//     template<typename I> I& first(I& i) const { return graph->first(i); }
+//     template<typename I, typename P> I& first(I& i, const P& p) const { 
+//       return graph->first(i, p); }
 //     //template<typename I> I next(const I i); { return graph->goNext(i); }
 //     //template<typename I> I &goNext(I &i); { return graph->goNext(i); }
 
 //     template< typename It > It first() const { 
-//       It e; /*getF*/first(e); return e; }
+//       It e; first(e); return e; }
 
 //     template< typename It > It first(Node v) const { 
-//       It e; /*getF*/first(e, v); return e; }
+//       It e; first(e, v); return e; }
 
 //     Node head(const Edge& e) const { return graph->head(e); }
@@ -456,9 +531,9 @@
     private:
       OutEdgeIt(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& resG, Node v) : Edge() { 
-	resG.graph->/*getF*/first(out, v);
+	resG.graph->first(out, v);
 	while( resG.graph->valid(out) && !(resG.free(out)>0) ) { resG.graph->next(out); }
 	if (!resG.graph->valid(out)) {
 	  out_or_in=0;
-	  resG.graph->/*getF*/first(in, v);
+	  resG.graph->first(in, v);
 	  while( resG.graph->valid(in) && !(resG.free(in)>0) ) { resG.graph->next(in); }
 	}
@@ -472,5 +547,5 @@
 // 	  if (!out.valid()) {
 // 	    out_or_in=0;
-// 	    G->/*getF*/first(in, v); 
+// 	    G->first(in, v); 
 // 	    while( in.valid() && !(Edge::free()>0) ) { ++in; }
 // 	  }
@@ -491,20 +566,20 @@
       EdgeIt(const Invalid& i) : Edge(i) { }
       EdgeIt(const ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>& resG) : Edge() { 
-	resG.graph->/*getF*/first(v);
-	if (resG.graph->valid(v)) resG.graph->/*getF*/first(out, v); else out=OldOutEdgeIt(INVALID);
+	resG.graph->first(v);
+	if (resG.graph->valid(v)) resG.graph->first(out, v); else out=OldOutEdgeIt(INVALID);
 	while (resG.graph->valid(out) && !(resG.free(out)>0) ) { resG.graph->next(out); }
 	while (resG.graph->valid(v) && !resG.graph->valid(out)) { 
 	  resG.graph->next(v); 
-	  if (resG.graph->valid(v)) resG.graph->/*getF*/first(out, v); 
+	  if (resG.graph->valid(v)) resG.graph->first(out, v); 
 	  while (resG.graph->valid(out) && !(resG.free(out)>0) ) { resG.graph->next(out); }
 	}
 	if (!resG.graph->valid(out)) {
 	  out_or_in=0;
-	  resG.graph->/*getF*/first(v);
-	  if (resG.graph->valid(v)) resG.graph->/*getF*/first(in, v); else in=OldInEdgeIt(INVALID);
+	  resG.graph->first(v);
+	  if (resG.graph->valid(v)) resG.graph->first(in, v); else in=OldInEdgeIt(INVALID);
 	  while (resG.graph->valid(in) && !(resG.free(in)>0) ) { resG.graph->next(in); }
 	  while (resG.graph->valid(v) && !resG.graph->valid(in)) { 
 	    resG.graph->next(v); 
-	    if (resG.graph->valid(v)) resG.graph->/*getF*/first(in, v); 
+	    if (resG.graph->valid(v)) resG.graph->first(in, v); 
 	    while (resG.graph->valid(in) && !(resG.free(in)>0) ) { resG.graph->next(in); }
 	  }
@@ -517,15 +592,15 @@
 // 	  while (v.valid() && !out.valid()) { 
 // 	    ++v; 
-// 	    if (v.valid()) G->/*getF*/first(out, v); 
+// 	    if (v.valid()) G->first(out, v); 
 // 	    while (out.valid() && !(Edge::free()>0) ) { ++out; }
 // 	  }
 // 	  if (!out.valid()) {
 // 	    out_or_in=0;
-// 	    G->/*getF*/first(v);
-// 	    if (v.valid()) G->/*getF*/first(in, v); else in=OldInEdgeIt();
+// 	    G->first(v);
+// 	    if (v.valid()) G->first(in, v); else in=OldInEdgeIt();
 // 	    while (in.valid() && !(Edge::free()>0) ) { ++in; }
 // 	    while (v.valid() && !in.valid()) { 
 // 	      ++v; 
-// 	      if (v.valid()) G->/*getF*/first(in, v); 
+// 	      if (v.valid()) G->first(in, v); 
 // 	      while (in.valid() && !(Edge::free()>0) ) { ++in; }
 // 	    }  
@@ -536,5 +611,5 @@
 // 	  while (v.valid() && !in.valid()) { 
 // 	    ++v; 
-// 	    if (v.valid()) G->/*getF*/first(in, v); 
+// 	    if (v.valid()) G->first(in, v); 
 // 	    while (in.valid() && !(Edge::free()>0) ) { ++in; }
 // 	  }
@@ -544,10 +619,10 @@
     };
 
-    NodeIt& /*getF*/first(NodeIt& v) const { return graph->/*getF*/first(v); }
-    OutEdgeIt& /*getF*/first(OutEdgeIt& e, Node v) const { 
+    NodeIt& first(NodeIt& v) const { return graph->first(v); }
+    OutEdgeIt& first(OutEdgeIt& e, Node v) const { 
       e=OutEdgeIt(*this, v); 
       return e;
     }
-    EdgeIt& /*getF*/first(EdgeIt& e) const { 
+    EdgeIt& first(EdgeIt& e) const { 
       e=EdgeIt(*this); 
       return e;
@@ -563,5 +638,5 @@
 	if (!graph->valid(e.out)) {
 	  e.out_or_in=0;
-	  graph->/*getF*/first(e.in, v); 
+	  graph->first(e.in, v); 
 	  while( graph->valid(e.in) && !(free(e.in)>0) ) { graph->next(e.in); }
 	}
@@ -579,15 +654,15 @@
 	  while (graph->valid(e.v) && !graph->valid(e.out)) { 
 	    graph->next(e.v); 
-	    if (graph->valid(e.v)) graph->/*getF*/first(e.out, e.v); 
+	    if (graph->valid(e.v)) graph->first(e.out, e.v); 
 	    while (graph->valid(e.out) && !(free(e.out)>0) ) { graph->next(e.out); }
 	  }
 	  if (!graph->valid(e.out)) {
 	    e.out_or_in=0;
-	    graph->/*getF*/first(e.v);
-	    if (graph->valid(e.v)) graph->/*getF*/first(e.in, e.v); else e.in=OldInEdgeIt(INVALID);
+	    graph->first(e.v);
+	    if (graph->valid(e.v)) graph->first(e.in, e.v); else e.in=OldInEdgeIt(INVALID);
 	    while (graph->valid(e.in) && !(free(e.in)>0) ) { graph->next(e.in); }
 	    while (graph->valid(e.v) && !graph->valid(e.in)) { 
 	      graph->next(e.v); 
-	      if (graph->valid(e.v)) graph->/*getF*/first(e.in, e.v); 
+	      if (graph->valid(e.v)) graph->first(e.in, e.v); 
 	      while (graph->valid(e.in) && !(free(e.in)>0) ) { graph->next(e.in); }
 	    }  
@@ -598,5 +673,5 @@
 	  while (graph->valid(e.v) && !graph->valid(e.in)) { 
 	    graph->next(e.v); 
-	    if (graph->valid(e.v)) graph->/*getF*/first(e.in, e.v); 
+	    if (graph->valid(e.v)) graph->first(e.in, e.v); 
 	    while (graph->valid(e.in) && !(free(e.in)>0) ) { graph->next(e.in); }
 	  }
@@ -609,5 +684,5 @@
     It first() const { 
       It e;
-      /*getF*/first(e);
+      first(e);
       return e; 
     }
@@ -616,5 +691,5 @@
     It first(Node v) const { 
       It e;
-      /*getF*/first(e, v);
+      first(e, v);
       return e; 
     }
@@ -709,5 +784,5 @@
       for(NodeIt n=this->template first<NodeIt>(); this->valid(n); this->next(n)) {
 	OutEdgeIt e;
-	ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::/*getF*/first(e, n);
+	ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::first(e, n);
 	first_out_edges.set(n, e);
       }
@@ -740,16 +815,16 @@
     //typedef typename ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::EdgeIt EdgeIt;
 
-    NodeIt& /*getF*/first(NodeIt& n) const { 
-      return ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::/*getF*/first(n);
-    }
-
-    OutEdgeIt& /*getF*/first(OutEdgeIt& e, const Node& n) const { 
+    NodeIt& first(NodeIt& n) const { 
+      return ResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::first(n);
+    }
+
+    OutEdgeIt& first(OutEdgeIt& e, const Node& n) const { 
       e=first_out_edges.get(n);
       return e;
     }
     
-    //ROSSZ template<typename I> I& /*getF*/first(I& i) const { return /*getF*/first(i); }
-    //ROSSZ template<typename I, typename P> I& /*getF*/first(I& i, const P& p) const { 
-    //  return /*getF*/first(i, p); }
+    //ROSSZ template<typename I> I& first(I& i) const { return first(i); }
+    //ROSSZ template<typename I, typename P> I& first(I& i, const P& p) const { 
+    //  return first(i, p); }
     
     //template<typename I> I getNext(const I& i) const { 
@@ -758,8 +833,8 @@
 
     template< typename It > It first() const { 
-      It e; /*getF*/first(e); return e; }
+      It e; first(e); return e; }
 
     template< typename It > It first(const Node& v) const { 
-      It e; /*getF*/first(e, v); return e; }
+      It e; first(e, v); return e; }
 
     //Node head(const Edge& e) const { return graph->head(e); }
@@ -839,6 +914,6 @@
     }
 
-    OutEdgeIt& /*getF*/first(OutEdgeIt& e, const Node& n) const {
-      ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::/*getF*/first(e, n);
+    OutEdgeIt& first(OutEdgeIt& e, const Node& n) const {
+      ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::first(e, n);
       while (valid(e) && (dist.get(tail(e))/*+1!=*/>=dist.get(head(e)))) 
 	ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::next(e);
@@ -857,6 +932,6 @@
     }
 
-    NodeIt& /*getF*/first(NodeIt& n) const {
-      return ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::/*getF*/first(n);
+    NodeIt& first(NodeIt& n) const {
+      return ErasingResGraphWrapper<Graph, Number, FlowMap, CapacityMap>::first(n);
     }
 
@@ -875,7 +950,7 @@
     //Graph& getGraph() const { return (*graph); }
     
-    //template<typename I> I& /*getF*/first(I& i) const { return graph->/*getF*/first(i); }
-    //template<typename I, typename P> I& /*getF*/first(I& i, const P& p) const { 
-    //  return graph->/*getF*/first(i, p); }
+    //template<typename I> I& first(I& i) const { return graph->first(i); }
+    //template<typename I, typename P> I& first(I& i, const P& p) const { 
+    //  return graph->first(i, p); }
     
     //template<typename I> I getNext(const I& i) const { 
@@ -884,8 +959,8 @@
 
     template< typename It > It first() const { 
-      It e; /*getF*/first(e); return e; }
+      It e; first(e); return e; }
 
     template< typename It > It first(const Node& v) const { 
-      It e; /*getF*/first(e, v); return e; }
+      It e; first(e, v); return e; }
 
     //Node head(const Edge& e) const { return graph->head(e); }
@@ -971,5 +1046,5 @@
 //     int edgeNum() const { return graph->edgeNum(); }
 
-//     Node& /*getF*/first(Node& n) const { return graph->/*getF*/first(n); }
+//     Node& first(Node& n) const { return graph->first(n); }
 
 //     // Edge and SymEdge  is missing!!!!
@@ -977,12 +1052,12 @@
 
 //     //FIXME
-//     OutEdgeIt& /*getF*/first(OutEdgeIt& e, const Node& n) const 
+//     OutEdgeIt& first(OutEdgeIt& e, const Node& n) const 
 //       {
 // 	e.n=n;
-// 	graph->/*getF*/first(e.o,n);
+// 	graph->first(e.o,n);
 // 	while(graph->valid(e.o) && fmap.get(e.o)>=himap.get(e.o))
 // 	  graph->goNext(e.o);
 // 	if(!graph->valid(e.o)) {
-// 	  graph->/*getF*/first(e.i,n);
+// 	  graph->first(e.i,n);
 // 	  while(graph->valid(e.i) && fmap.get(e.i)<=lomap.get(e.i))
 // 	    graph->goNext(e.i);
@@ -997,5 +1072,5 @@
 //   graph->goNext(e.o);
 //   if(graph->valid(e.o)) return e;
-//   else graph->/*getF*/first(e.i,e.n);
+//   else graph->first(e.i,e.n);
 //   }
 //   else {
@@ -1010,12 +1085,12 @@
 
 //     //FIXME
-//     InEdgeIt& /*getF*/first(InEdgeIt& e, const Node& n) const 
+//     InEdgeIt& first(InEdgeIt& e, const Node& n) const 
 //       {
 // 	e.n=n;
-// 	graph->/*getF*/first(e.i,n);
+// 	graph->first(e.i,n);
 // 	while(graph->valid(e.i) && fmap.get(e.i)>=himap.get(e.i))
 // 	  graph->goNext(e.i);
 // 	if(!graph->valid(e.i)) {
-// 	  graph->/*getF*/first(e.o,n);
+// 	  graph->first(e.o,n);
 // 	  while(graph->valid(e.o) && fmap.get(e.o)<=lomap.get(e.o))
 // 	    graph->goNext(e.o);
@@ -1030,5 +1105,5 @@
 //   graph->goNext(e.i);
 //   if(graph->valid(e.i)) return e;
-//   else graph->/*getF*/first(e.o,e.n);
+//   else graph->first(e.o,e.n);
 //   }
 //   else {
@@ -1046,8 +1121,8 @@
 
 //     template< typename It > It first() const { 
-//       It e; /*getF*/first(e); return e; }
+//       It e; first(e); return e; }
 
 //     template< typename It > It first(Node v) const { 
-//       It e; /*getF*/first(e, v); return e; }
+//       It e; first(e, v); return e; }
 
 //     Node head(const Edge& e) const { return graph->head(e); }
