Edge(w), gw(&_gw) { }

 	Edge(e), gw(&_gw) { }

 	Edge(typename Graph::OutEdgeIt(*(_gw.graph)), n), gw(&_gw) { }

 	Edge(typename Graph::OutEdgeIt(*(_gw.graph), n)), gw(&_gw) { }

 	Edge(typename Graph::InEdgeIt(*(_gw.graph)), n), gw(&_gw) { }

 	Edge(typename Graph::InEdgeIt(*(_gw.graph), n)), gw(&_gw) { }

     class OutEdgeIt { 

     class OutEdgeIt : public Edge { 

 //      typedef typename Graph::OutEdgeIt GraphOutEdgeIt;

       const ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>* gw;

       typename Graph::OutEdgeIt e;

       OutEdgeIt(const typename Graph::OutEdgeIt& _e) : e(_e) { }

       //OutEdgeIt(const OutEdgeIt& e) : Edge(e), gw(e.gw) { }

       OutEdgeIt(const Invalid& i) : e(i) { }

       OutEdgeIt(Invalid i) : Edge(i) { }

       OutEdgeIt(const ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>& _G, 

       OutEdgeIt(const ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>& _gw, 

 		const Node& _n) : 

 		const Node& n) : 

 	e((*_G.first_out_edges)[_n]) { }

 	Edge((*(_gw.first_out_edges))[n]), gw(&_gw) { }

       operator Edge() const { return Edge(typename Graph::Edge(e)); }

       OutEdgeIt(const ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>& _gw, 

     };

 		const Edge& e) : 

     class InEdgeIt { 

 	Edge(e), gw(&_gw) { }

       friend class GraphWrapper<Graph>;

       OutEdgeIt& operator++() { 

       friend class ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>;

 	*(static_cast<Edge*>(this))=

 //      typedef typename Graph::InEdgeIt GraphInEdgeIt;

 	  ++(typename Graph::OutEdgeIt(*(gw->graph), *this));

       typename Graph::InEdgeIt e;

 	return *this; 

     public:

       }

       InEdgeIt() { }

     };

       InEdgeIt(const typename Graph::InEdgeIt& _e) : e(_e) { }

 //     class InEdgeIt { 

       InEdgeIt(const Invalid& i) : e(i) { }

 //       friend class GraphWrapper<Graph>;

       InEdgeIt(const ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>& _G, 

 //       friend class ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>;

 	       const Node& _n) : 

 // //      typedef typename Graph::InEdgeIt GraphInEdgeIt;

 	e(*(_G.graph), typename Graph::Node(_n)) { }

 //       typename Graph::InEdgeIt e;

       operator Edge() const { return Edge(typename Graph::Edge(e)); }

 //     public:

     };

 //       InEdgeIt() { }

 //       InEdgeIt(const typename Graph::InEdgeIt& _e) : e(_e) { }

 //       InEdgeIt(const Invalid& i) : e(i) { }

 //       InEdgeIt(const ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>& _G, 

 // 	       const Node& _n) : 

 // 	e(*(_G.graph), typename Graph::Node(_n)) { }

 //       operator Edge() const { return Edge(typename Graph::Edge(e)); }

 //     };	

     class EdgeIt { 

 //     class EdgeIt { 

       friend class GraphWrapper<Graph>;

 //       friend class GraphWrapper<Graph>;

       friend class ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>;

 //       friend class ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>;

 //      typedef typename Graph::EdgeIt GraphEdgeIt;

 // //      typedef typename Graph::EdgeIt GraphEdgeIt;

       typename Graph::EdgeIt e;

 //       typename Graph::EdgeIt e;

     public:

 //     public:

       EdgeIt() { }

 //       EdgeIt() { }

       EdgeIt(const typename Graph::EdgeIt& _e) : e(_e) { }

 //       EdgeIt(const typename Graph::EdgeIt& _e) : e(_e) { }

       EdgeIt(const Invalid& i) : e(i) { }

 //       EdgeIt(const Invalid& i) : e(i) { }

       EdgeIt(const ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>& _G) : 

 //       EdgeIt(const ErasingFirstGraphWrapper<Graph, FirstOutEdgesMap>& _G) : 

 	e(*(_G.graph)) { }

 // 	e(*(_G.graph)) { }

       operator Edge() const { return Edge(typename Graph::Edge(e)); }

 //       operator Edge() const { return Edge(typename Graph::Edge(e)); }

     };

 //     };

     InEdgeIt& first(InEdgeIt& i, const Node& p) const { 

 //     InEdgeIt& first(InEdgeIt& i, const Node& p) const { 

       i=InEdgeIt(*this, p); return i;

 //       i=InEdgeIt(*this, p); return i;

     }

 //     }

     EdgeIt& first(EdgeIt& i) const { 

 //     EdgeIt& first(EdgeIt& i) const { 

       i=EdgeIt(*this); return i;

 //       i=EdgeIt(*this); return i;

     }

 //     }

     using GraphWrapper<Graph>::next;

 //     using GraphWrapper<Graph>::next;

 //    NodeIt& next(NodeIt& i) const { graph->next(i.n); return i; }

 // //    NodeIt& next(NodeIt& i) const { graph->next(i.n); return i; }

     OutEdgeIt& next(OutEdgeIt& i) const { this->graph->next(i.e); return i; }

 //     OutEdgeIt& next(OutEdgeIt& i) const { this->graph->next(i.e); return i; }

     InEdgeIt& next(InEdgeIt& i) const { this->graph->next(i.e); return i; }

 //     InEdgeIt& next(InEdgeIt& i) const { this->graph->next(i.e); return i; }

     EdgeIt& next(EdgeIt& i) const { this->graph->next(i.e); return i; }    

 //     EdgeIt& next(EdgeIt& i) const { this->graph->next(i.e); return i; }    

     Node aNode(const OutEdgeIt& e) const { 

 //     Node aNode(const OutEdgeIt& e) const { 

       return Node(this->graph->aNode(e.e)); }

 //       return Node(this->graph->aNode(e.e)); }

     Node aNode(const InEdgeIt& e) const { 

 //     Node aNode(const InEdgeIt& e) const { 

       return Node(this->graph->aNode(e.e)); }

 //       return Node(this->graph->aNode(e.e)); }

     Node bNode(const OutEdgeIt& e) const { 

 //     Node bNode(const OutEdgeIt& e) const { 

       return Node(this->graph->bNode(e.e)); }

 //       return Node(this->graph->bNode(e.e)); }

     Node bNode(const InEdgeIt& e) const { 

 //     Node bNode(const InEdgeIt& e) const { 

       return Node(this->graph->bNode(e.e)); }

 //       return Node(this->graph->bNode(e.e)); }

     void erase(const OutEdgeIt& e) const {

     void erase(const Edge& e) const {

       OutEdgeIt f=e;

       Node n=tail(e);

       this->next(f);

       typename Graph::OutEdgeIt f(*graph, n);

       first_out_edges->set(this->tail(e), f.e);

       ++f;

       first_out_edges->set(n, f);