Index: lemon/list_graph.h
===================================================================
--- lemon/list_graph.h	(revision 1359)
+++ lemon/list_graph.h	(revision 1424)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2013
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -49,5 +49,5 @@
     };
 
-    std::vector<NodeT> _nodes;
+    std::vector<NodeT> nodes;
 
     int first_node;
@@ -55,5 +55,5 @@
     int first_free_node;
 
-    std::vector<ArcT> _arcs;
+    std::vector<ArcT> arcs;
 
     int first_free_arc;
@@ -98,13 +98,13 @@
 
     ListDigraphBase()
-      : _nodes(), first_node(-1),
-        first_free_node(-1), _arcs(), first_free_arc(-1) {}
-
-
-    int maxNodeId() const { return _nodes.size()-1; }
-    int maxArcId() const { return _arcs.size()-1; }
-
-    Node source(Arc e) const { return Node(_arcs[e.id].source); }
-    Node target(Arc e) const { return Node(_arcs[e.id].target); }
+      : nodes(), first_node(-1),
+        first_free_node(-1), arcs(), first_free_arc(-1) {}
+
+
+    int maxNodeId() const { return nodes.size()-1; }
+    int maxArcId() const { return arcs.size()-1; }
+
+    Node source(Arc e) const { return Node(arcs[e.id].source); }
+    Node target(Arc e) const { return Node(arcs[e.id].target); }
 
 
@@ -114,5 +114,5 @@
 
     void next(Node& node) const {
-      node.id = _nodes[node.id].next;
+      node.id = nodes[node.id].next;
     }
 
@@ -121,33 +121,33 @@
       int n;
       for(n = first_node;
-          n != -1 && _nodes[n].first_out == -1;
-          n = _nodes[n].next) {}
-      arc.id = (n == -1) ? -1 : _nodes[n].first_out;
+          n != -1 && nodes[n].first_out == -1;
+          n = nodes[n].next) {}
+      arc.id = (n == -1) ? -1 : nodes[n].first_out;
     }
 
     void next(Arc& arc) const {
-      if (_arcs[arc.id].next_out != -1) {
-        arc.id = _arcs[arc.id].next_out;
+      if (arcs[arc.id].next_out != -1) {
+        arc.id = arcs[arc.id].next_out;
       } else {
         int n;
-        for(n = _nodes[_arcs[arc.id].source].next;
-            n != -1 && _nodes[n].first_out == -1;
-            n = _nodes[n].next) {}
-        arc.id = (n == -1) ? -1 : _nodes[n].first_out;
+        for(n = nodes[arcs[arc.id].source].next;
+            n != -1 && nodes[n].first_out == -1;
+            n = nodes[n].next) {}
+        arc.id = (n == -1) ? -1 : nodes[n].first_out;
       }
     }
 
     void firstOut(Arc &e, const Node& v) const {
-      e.id = _nodes[v.id].first_out;
+      e.id = nodes[v.id].first_out;
     }
     void nextOut(Arc &e) const {
-      e.id=_arcs[e.id].next_out;
+      e.id=arcs[e.id].next_out;
     }
 
     void firstIn(Arc &e, const Node& v) const {
-      e.id = _nodes[v.id].first_in;
+      e.id = nodes[v.id].first_in;
     }
     void nextIn(Arc &e) const {
-      e.id=_arcs[e.id].next_in;
+      e.id=arcs[e.id].next_in;
     }
 
@@ -160,11 +160,11 @@
 
     bool valid(Node n) const {
-      return n.id >= 0 && n.id < static_cast<int>(_nodes.size()) &&
-        _nodes[n.id].prev != -2;
+      return n.id >= 0 && n.id < static_cast<int>(nodes.size()) &&
+        nodes[n.id].prev != -2;
     }
 
     bool valid(Arc a) const {
-      return a.id >= 0 && a.id < static_cast<int>(_arcs.size()) &&
-        _arcs[a.id].prev_in != -2;
+      return a.id >= 0 && a.id < static_cast<int>(arcs.size()) &&
+        arcs[a.id].prev_in != -2;
     }
 
@@ -173,17 +173,17 @@
 
       if(first_free_node==-1) {
-        n = _nodes.size();
-        _nodes.push_back(NodeT());
+        n = nodes.size();
+        nodes.push_back(NodeT());
       } else {
         n = first_free_node;
-        first_free_node = _nodes[n].next;
-      }
-
-      _nodes[n].next = first_node;
-      if(first_node != -1) _nodes[first_node].prev = n;
+        first_free_node = nodes[n].next;
+      }
+
+      nodes[n].next = first_node;
+      if(first_node != -1) nodes[first_node].prev = n;
       first_node = n;
-      _nodes[n].prev = -1;
-
-      _nodes[n].first_in = _nodes[n].first_out = -1;
+      nodes[n].prev = -1;
+
+      nodes[n].first_in = nodes[n].first_out = -1;
 
       return Node(n);
@@ -194,27 +194,27 @@
 
       if (first_free_arc == -1) {
-        n = _arcs.size();
-        _arcs.push_back(ArcT());
+        n = arcs.size();
+        arcs.push_back(ArcT());
       } else {
         n = first_free_arc;
-        first_free_arc = _arcs[n].next_in;
-      }
-
-      _arcs[n].source = u.id;
-      _arcs[n].target = v.id;
-
-      _arcs[n].next_out = _nodes[u.id].first_out;
-      if(_nodes[u.id].first_out != -1) {
-        _arcs[_nodes[u.id].first_out].prev_out = n;
-      }
-
-      _arcs[n].next_in = _nodes[v.id].first_in;
-      if(_nodes[v.id].first_in != -1) {
-        _arcs[_nodes[v.id].first_in].prev_in = n;
-      }
-
-      _arcs[n].prev_in = _arcs[n].prev_out = -1;
-
-      _nodes[u.id].first_out = _nodes[v.id].first_in = n;
+        first_free_arc = arcs[n].next_in;
+      }
+
+      arcs[n].source = u.id;
+      arcs[n].target = v.id;
+
+      arcs[n].next_out = nodes[u.id].first_out;
+      if(nodes[u.id].first_out != -1) {
+        arcs[nodes[u.id].first_out].prev_out = n;
+      }
+
+      arcs[n].next_in = nodes[v.id].first_in;
+      if(nodes[v.id].first_in != -1) {
+        arcs[nodes[v.id].first_in].prev_in = n;
+      }
+
+      arcs[n].prev_in = arcs[n].prev_out = -1;
+
+      nodes[u.id].first_out = nodes[v.id].first_in = n;
 
       return Arc(n);
@@ -224,17 +224,17 @@
       int n = node.id;
 
-      if(_nodes[n].next != -1) {
-        _nodes[_nodes[n].next].prev = _nodes[n].prev;
-      }
-
-      if(_nodes[n].prev != -1) {
-        _nodes[_nodes[n].prev].next = _nodes[n].next;
+      if(nodes[n].next != -1) {
+        nodes[nodes[n].next].prev = nodes[n].prev;
+      }
+
+      if(nodes[n].prev != -1) {
+        nodes[nodes[n].prev].next = nodes[n].next;
       } else {
-        first_node = _nodes[n].next;
-      }
-
-      _nodes[n].next = first_free_node;
+        first_node = nodes[n].next;
+      }
+
+      nodes[n].next = first_free_node;
       first_free_node = n;
-      _nodes[n].prev = -2;
+      nodes[n].prev = -2;
 
     }
@@ -243,33 +243,33 @@
       int n = arc.id;
 
-      if(_arcs[n].next_in!=-1) {
-        _arcs[_arcs[n].next_in].prev_in = _arcs[n].prev_in;
-      }
-
-      if(_arcs[n].prev_in!=-1) {
-        _arcs[_arcs[n].prev_in].next_in = _arcs[n].next_in;
+      if(arcs[n].next_in!=-1) {
+        arcs[arcs[n].next_in].prev_in = arcs[n].prev_in;
+      }
+
+      if(arcs[n].prev_in!=-1) {
+        arcs[arcs[n].prev_in].next_in = arcs[n].next_in;
       } else {
-        _nodes[_arcs[n].target].first_in = _arcs[n].next_in;
-      }
-
-
-      if(_arcs[n].next_out!=-1) {
-        _arcs[_arcs[n].next_out].prev_out = _arcs[n].prev_out;
-      }
-
-      if(_arcs[n].prev_out!=-1) {
-        _arcs[_arcs[n].prev_out].next_out = _arcs[n].next_out;
+        nodes[arcs[n].target].first_in = arcs[n].next_in;
+      }
+
+
+      if(arcs[n].next_out!=-1) {
+        arcs[arcs[n].next_out].prev_out = arcs[n].prev_out;
+      }
+
+      if(arcs[n].prev_out!=-1) {
+        arcs[arcs[n].prev_out].next_out = arcs[n].next_out;
       } else {
-        _nodes[_arcs[n].source].first_out = _arcs[n].next_out;
-      }
-
-      _arcs[n].next_in = first_free_arc;
+        nodes[arcs[n].source].first_out = arcs[n].next_out;
+      }
+
+      arcs[n].next_in = first_free_arc;
       first_free_arc = n;
-      _arcs[n].prev_in = -2;
+      arcs[n].prev_in = -2;
     }
 
     void clear() {
-      _arcs.clear();
-      _nodes.clear();
+      arcs.clear();
+      nodes.clear();
       first_node = first_free_node = first_free_arc = -1;
     }
@@ -278,31 +278,31 @@
     void changeTarget(Arc e, Node n)
     {
-      if(_arcs[e.id].next_in != -1)
-        _arcs[_arcs[e.id].next_in].prev_in = _arcs[e.id].prev_in;
-      if(_arcs[e.id].prev_in != -1)
-        _arcs[_arcs[e.id].prev_in].next_in = _arcs[e.id].next_in;
-      else _nodes[_arcs[e.id].target].first_in = _arcs[e.id].next_in;
-      if (_nodes[n.id].first_in != -1) {
-        _arcs[_nodes[n.id].first_in].prev_in = e.id;
-      }
-      _arcs[e.id].target = n.id;
-      _arcs[e.id].prev_in = -1;
-      _arcs[e.id].next_in = _nodes[n.id].first_in;
-      _nodes[n.id].first_in = e.id;
+      if(arcs[e.id].next_in != -1)
+        arcs[arcs[e.id].next_in].prev_in = arcs[e.id].prev_in;
+      if(arcs[e.id].prev_in != -1)
+        arcs[arcs[e.id].prev_in].next_in = arcs[e.id].next_in;
+      else nodes[arcs[e.id].target].first_in = arcs[e.id].next_in;
+      if (nodes[n.id].first_in != -1) {
+        arcs[nodes[n.id].first_in].prev_in = e.id;
+      }
+      arcs[e.id].target = n.id;
+      arcs[e.id].prev_in = -1;
+      arcs[e.id].next_in = nodes[n.id].first_in;
+      nodes[n.id].first_in = e.id;
     }
     void changeSource(Arc e, Node n)
     {
-      if(_arcs[e.id].next_out != -1)
-        _arcs[_arcs[e.id].next_out].prev_out = _arcs[e.id].prev_out;
-      if(_arcs[e.id].prev_out != -1)
-        _arcs[_arcs[e.id].prev_out].next_out = _arcs[e.id].next_out;
-      else _nodes[_arcs[e.id].source].first_out = _arcs[e.id].next_out;
-      if (_nodes[n.id].first_out != -1) {
-        _arcs[_nodes[n.id].first_out].prev_out = e.id;
-      }
-      _arcs[e.id].source = n.id;
-      _arcs[e.id].prev_out = -1;
-      _arcs[e.id].next_out = _nodes[n.id].first_out;
-      _nodes[n.id].first_out = e.id;
+      if(arcs[e.id].next_out != -1)
+        arcs[arcs[e.id].next_out].prev_out = arcs[e.id].prev_out;
+      if(arcs[e.id].prev_out != -1)
+        arcs[arcs[e.id].prev_out].next_out = arcs[e.id].next_out;
+      else nodes[arcs[e.id].source].first_out = arcs[e.id].next_out;
+      if (nodes[n.id].first_out != -1) {
+        arcs[nodes[n.id].first_out].prev_out = e.id;
+      }
+      arcs[e.id].source = n.id;
+      arcs[e.id].prev_out = -1;
+      arcs[e.id].next_out = nodes[n.id].first_out;
+      nodes[n.id].first_out = e.id;
     }
 
@@ -446,5 +446,5 @@
     ///or changeTarget(), thus \c ArcIt and \c OutArcIt iterators are
     ///invalidated for the outgoing arcs of node \c v and \c InArcIt
-    ///iterators are invalidated for the incoming arcs of \c v.
+    ///iterators are invalidated for the incomming arcs of \c v.
     ///Moreover all iterators referencing node \c v or the removed
     ///loops are also invalidated. Other iterators remain valid.
@@ -487,8 +487,8 @@
     Node split(Node n, bool connect = true) {
       Node b = addNode();
-      _nodes[b.id].first_out=_nodes[n.id].first_out;
-      _nodes[n.id].first_out=-1;
-      for(int i=_nodes[b.id].first_out; i!=-1; i=_arcs[i].next_out) {
-        _arcs[i].source=b.id;
+      nodes[b.id].first_out=nodes[n.id].first_out;
+      nodes[n.id].first_out=-1;
+      for(int i=nodes[b.id].first_out; i!=-1; i=arcs[i].next_out) {
+        arcs[i].source=b.id;
       }
       if (connect) addArc(n,b);
@@ -533,5 +533,5 @@
     /// to build the digraph.
     /// \sa reserveArc()
-    void reserveNode(int n) { _nodes.reserve(n); };
+    void reserveNode(int n) { nodes.reserve(n); };
 
     /// Reserve memory for arcs.
@@ -543,5 +543,5 @@
     /// to build the digraph.
     /// \sa reserveNode()
-    void reserveArc(int m) { _arcs.reserve(m); };
+    void reserveArc(int m) { arcs.reserve(m); };
 
     /// \brief Class to make a snapshot of the digraph and restore
@@ -804,5 +804,5 @@
     };
 
-    std::vector<NodeT> _nodes;
+    std::vector<NodeT> nodes;
 
     int first_node;
@@ -810,5 +810,5 @@
     int first_free_node;
 
-    std::vector<ArcT> _arcs;
+    std::vector<ArcT> arcs;
 
     int first_free_arc;
@@ -868,17 +868,17 @@
 
     ListGraphBase()
-      : _nodes(), first_node(-1),
-        first_free_node(-1), _arcs(), first_free_arc(-1) {}
-
-
-    int maxNodeId() const { return _nodes.size()-1; }
-    int maxEdgeId() const { return _arcs.size() / 2 - 1; }
-    int maxArcId() const { return _arcs.size()-1; }
-
-    Node source(Arc e) const { return Node(_arcs[e.id ^ 1].target); }
-    Node target(Arc e) const { return Node(_arcs[e.id].target); }
-
-    Node u(Edge e) const { return Node(_arcs[2 * e.id].target); }
-    Node v(Edge e) const { return Node(_arcs[2 * e.id + 1].target); }
+      : nodes(), first_node(-1),
+        first_free_node(-1), arcs(), first_free_arc(-1) {}
+
+
+    int maxNodeId() const { return nodes.size()-1; }
+    int maxEdgeId() const { return arcs.size() / 2 - 1; }
+    int maxArcId() const { return arcs.size()-1; }
+
+    Node source(Arc e) const { return Node(arcs[e.id ^ 1].target); }
+    Node target(Arc e) const { return Node(arcs[e.id].target); }
+
+    Node u(Edge e) const { return Node(arcs[2 * e.id].target); }
+    Node v(Edge e) const { return Node(arcs[2 * e.id + 1].target); }
 
     static bool direction(Arc e) {
@@ -895,24 +895,24 @@
 
     void next(Node& node) const {
-      node.id = _nodes[node.id].next;
+      node.id = nodes[node.id].next;
     }
 
     void first(Arc& e) const {
       int n = first_node;
-      while (n != -1 && _nodes[n].first_out == -1) {
-        n = _nodes[n].next;
-      }
-      e.id = (n == -1) ? -1 : _nodes[n].first_out;
+      while (n != -1 && nodes[n].first_out == -1) {
+        n = nodes[n].next;
+      }
+      e.id = (n == -1) ? -1 : nodes[n].first_out;
     }
 
     void next(Arc& e) const {
-      if (_arcs[e.id].next_out != -1) {
-        e.id = _arcs[e.id].next_out;
+      if (arcs[e.id].next_out != -1) {
+        e.id = arcs[e.id].next_out;
       } else {
-        int n = _nodes[_arcs[e.id ^ 1].target].next;
-        while(n != -1 && _nodes[n].first_out == -1) {
-          n = _nodes[n].next;
-        }
-        e.id = (n == -1) ? -1 : _nodes[n].first_out;
+        int n = nodes[arcs[e.id ^ 1].target].next;
+        while(n != -1 && nodes[n].first_out == -1) {
+          n = nodes[n].next;
+        }
+        e.id = (n == -1) ? -1 : nodes[n].first_out;
       }
     }
@@ -921,7 +921,7 @@
       int n = first_node;
       while (n != -1) {
-        e.id = _nodes[n].first_out;
+        e.id = nodes[n].first_out;
         while ((e.id & 1) != 1) {
-          e.id = _arcs[e.id].next_out;
+          e.id = arcs[e.id].next_out;
         }
         if (e.id != -1) {
@@ -929,5 +929,5 @@
           return;
         }
-        n = _nodes[n].next;
+        n = nodes[n].next;
       }
       e.id = -1;
@@ -935,8 +935,8 @@
 
     void next(Edge& e) const {
-      int n = _arcs[e.id * 2].target;
-      e.id = _arcs[(e.id * 2) | 1].next_out;
+      int n = arcs[e.id * 2].target;
+      e.id = arcs[(e.id * 2) | 1].next_out;
       while ((e.id & 1) != 1) {
-        e.id = _arcs[e.id].next_out;
+        e.id = arcs[e.id].next_out;
       }
       if (e.id != -1) {
@@ -944,9 +944,9 @@
         return;
       }
-      n = _nodes[n].next;
+      n = nodes[n].next;
       while (n != -1) {
-        e.id = _nodes[n].first_out;
+        e.id = nodes[n].first_out;
         while ((e.id & 1) != 1) {
-          e.id = _arcs[e.id].next_out;
+          e.id = arcs[e.id].next_out;
         }
         if (e.id != -1) {
@@ -954,5 +954,5 @@
           return;
         }
-        n = _nodes[n].next;
+        n = nodes[n].next;
       }
       e.id = -1;
@@ -960,21 +960,21 @@
 
     void firstOut(Arc &e, const Node& v) const {
-      e.id = _nodes[v.id].first_out;
+      e.id = nodes[v.id].first_out;
     }
     void nextOut(Arc &e) const {
-      e.id = _arcs[e.id].next_out;
+      e.id = arcs[e.id].next_out;
     }
 
     void firstIn(Arc &e, const Node& v) const {
-      e.id = ((_nodes[v.id].first_out) ^ 1);
+      e.id = ((nodes[v.id].first_out) ^ 1);
       if (e.id == -2) e.id = -1;
     }
     void nextIn(Arc &e) const {
-      e.id = ((_arcs[e.id ^ 1].next_out) ^ 1);
+      e.id = ((arcs[e.id ^ 1].next_out) ^ 1);
       if (e.id == -2) e.id = -1;
     }
 
     void firstInc(Edge &e, bool& d, const Node& v) const {
-      int a = _nodes[v.id].first_out;
+      int a = nodes[v.id].first_out;
       if (a != -1 ) {
         e.id = a / 2;
@@ -986,5 +986,5 @@
     }
     void nextInc(Edge &e, bool& d) const {
-      int a = (_arcs[(e.id * 2) | (d ? 1 : 0)].next_out);
+      int a = (arcs[(e.id * 2) | (d ? 1 : 0)].next_out);
       if (a != -1 ) {
         e.id = a / 2;
@@ -1005,16 +1005,16 @@
 
     bool valid(Node n) const {
-      return n.id >= 0 && n.id < static_cast<int>(_nodes.size()) &&
-        _nodes[n.id].prev != -2;
+      return n.id >= 0 && n.id < static_cast<int>(nodes.size()) &&
+        nodes[n.id].prev != -2;
     }
 
     bool valid(Arc a) const {
-      return a.id >= 0 && a.id < static_cast<int>(_arcs.size()) &&
-        _arcs[a.id].prev_out != -2;
+      return a.id >= 0 && a.id < static_cast<int>(arcs.size()) &&
+        arcs[a.id].prev_out != -2;
     }
 
     bool valid(Edge e) const {
-      return e.id >= 0 && 2 * e.id < static_cast<int>(_arcs.size()) &&
-        _arcs[2 * e.id].prev_out != -2;
+      return e.id >= 0 && 2 * e.id < static_cast<int>(arcs.size()) &&
+        arcs[2 * e.id].prev_out != -2;
     }
 
@@ -1023,17 +1023,17 @@
 
       if(first_free_node==-1) {
-        n = _nodes.size();
-        _nodes.push_back(NodeT());
+        n = nodes.size();
+        nodes.push_back(NodeT());
       } else {
         n = first_free_node;
-        first_free_node = _nodes[n].next;
-      }
-
-      _nodes[n].next = first_node;
-      if (first_node != -1) _nodes[first_node].prev = n;
+        first_free_node = nodes[n].next;
+      }
+
+      nodes[n].next = first_node;
+      if (first_node != -1) nodes[first_node].prev = n;
       first_node = n;
-      _nodes[n].prev = -1;
-
-      _nodes[n].first_out = -1;
+      nodes[n].prev = -1;
+
+      nodes[n].first_out = -1;
 
       return Node(n);
@@ -1044,28 +1044,28 @@
 
       if (first_free_arc == -1) {
-        n = _arcs.size();
-        _arcs.push_back(ArcT());
-        _arcs.push_back(ArcT());
+        n = arcs.size();
+        arcs.push_back(ArcT());
+        arcs.push_back(ArcT());
       } else {
         n = first_free_arc;
-        first_free_arc = _arcs[n].next_out;
-      }
-
-      _arcs[n].target = u.id;
-      _arcs[n | 1].target = v.id;
-
-      _arcs[n].next_out = _nodes[v.id].first_out;
-      if (_nodes[v.id].first_out != -1) {
-        _arcs[_nodes[v.id].first_out].prev_out = n;
-      }
-      _arcs[n].prev_out = -1;
-      _nodes[v.id].first_out = n;
-
-      _arcs[n | 1].next_out = _nodes[u.id].first_out;
-      if (_nodes[u.id].first_out != -1) {
-        _arcs[_nodes[u.id].first_out].prev_out = (n | 1);
-      }
-      _arcs[n | 1].prev_out = -1;
-      _nodes[u.id].first_out = (n | 1);
+        first_free_arc = arcs[n].next_out;
+      }
+
+      arcs[n].target = u.id;
+      arcs[n | 1].target = v.id;
+
+      arcs[n].next_out = nodes[v.id].first_out;
+      if (nodes[v.id].first_out != -1) {
+        arcs[nodes[v.id].first_out].prev_out = n;
+      }
+      arcs[n].prev_out = -1;
+      nodes[v.id].first_out = n;
+
+      arcs[n | 1].next_out = nodes[u.id].first_out;
+      if (nodes[u.id].first_out != -1) {
+        arcs[nodes[u.id].first_out].prev_out = (n | 1);
+      }
+      arcs[n | 1].prev_out = -1;
+      nodes[u.id].first_out = (n | 1);
 
       return Edge(n / 2);
@@ -1075,17 +1075,17 @@
       int n = node.id;
 
-      if(_nodes[n].next != -1) {
-        _nodes[_nodes[n].next].prev = _nodes[n].prev;
-      }
-
-      if(_nodes[n].prev != -1) {
-        _nodes[_nodes[n].prev].next = _nodes[n].next;
+      if(nodes[n].next != -1) {
+        nodes[nodes[n].next].prev = nodes[n].prev;
+      }
+
+      if(nodes[n].prev != -1) {
+        nodes[nodes[n].prev].next = nodes[n].next;
       } else {
-        first_node = _nodes[n].next;
-      }
-
-      _nodes[n].next = first_free_node;
+        first_node = nodes[n].next;
+      }
+
+      nodes[n].next = first_free_node;
       first_free_node = n;
-      _nodes[n].prev = -2;
+      nodes[n].prev = -2;
     }
 
@@ -1093,34 +1093,34 @@
       int n = edge.id * 2;
 
-      if (_arcs[n].next_out != -1) {
-        _arcs[_arcs[n].next_out].prev_out = _arcs[n].prev_out;
-      }
-
-      if (_arcs[n].prev_out != -1) {
-        _arcs[_arcs[n].prev_out].next_out = _arcs[n].next_out;
+      if (arcs[n].next_out != -1) {
+        arcs[arcs[n].next_out].prev_out = arcs[n].prev_out;
+      }
+
+      if (arcs[n].prev_out != -1) {
+        arcs[arcs[n].prev_out].next_out = arcs[n].next_out;
       } else {
-        _nodes[_arcs[n | 1].target].first_out = _arcs[n].next_out;
-      }
-
-      if (_arcs[n | 1].next_out != -1) {
-        _arcs[_arcs[n | 1].next_out].prev_out = _arcs[n | 1].prev_out;
-      }
-
-      if (_arcs[n | 1].prev_out != -1) {
-        _arcs[_arcs[n | 1].prev_out].next_out = _arcs[n | 1].next_out;
+        nodes[arcs[n | 1].target].first_out = arcs[n].next_out;
+      }
+
+      if (arcs[n | 1].next_out != -1) {
+        arcs[arcs[n | 1].next_out].prev_out = arcs[n | 1].prev_out;
+      }
+
+      if (arcs[n | 1].prev_out != -1) {
+        arcs[arcs[n | 1].prev_out].next_out = arcs[n | 1].next_out;
       } else {
-        _nodes[_arcs[n].target].first_out = _arcs[n | 1].next_out;
-      }
-
-      _arcs[n].next_out = first_free_arc;
+        nodes[arcs[n].target].first_out = arcs[n | 1].next_out;
+      }
+
+      arcs[n].next_out = first_free_arc;
       first_free_arc = n;
-      _arcs[n].prev_out = -2;
-      _arcs[n | 1].prev_out = -2;
+      arcs[n].prev_out = -2;
+      arcs[n | 1].prev_out = -2;
 
     }
 
     void clear() {
-      _arcs.clear();
-      _nodes.clear();
+      arcs.clear();
+      nodes.clear();
       first_node = first_free_node = first_free_arc = -1;
     }
@@ -1129,44 +1129,44 @@
 
     void changeV(Edge e, Node n) {
-      if(_arcs[2 * e.id].next_out != -1) {
-        _arcs[_arcs[2 * e.id].next_out].prev_out = _arcs[2 * e.id].prev_out;
-      }
-      if(_arcs[2 * e.id].prev_out != -1) {
-        _arcs[_arcs[2 * e.id].prev_out].next_out =
-          _arcs[2 * e.id].next_out;
+      if(arcs[2 * e.id].next_out != -1) {
+        arcs[arcs[2 * e.id].next_out].prev_out = arcs[2 * e.id].prev_out;
+      }
+      if(arcs[2 * e.id].prev_out != -1) {
+        arcs[arcs[2 * e.id].prev_out].next_out =
+          arcs[2 * e.id].next_out;
       } else {
-        _nodes[_arcs[(2 * e.id) | 1].target].first_out =
-          _arcs[2 * e.id].next_out;
-      }
-
-      if (_nodes[n.id].first_out != -1) {
-        _arcs[_nodes[n.id].first_out].prev_out = 2 * e.id;
-      }
-      _arcs[(2 * e.id) | 1].target = n.id;
-      _arcs[2 * e.id].prev_out = -1;
-      _arcs[2 * e.id].next_out = _nodes[n.id].first_out;
-      _nodes[n.id].first_out = 2 * e.id;
+        nodes[arcs[(2 * e.id) | 1].target].first_out =
+          arcs[2 * e.id].next_out;
+      }
+
+      if (nodes[n.id].first_out != -1) {
+        arcs[nodes[n.id].first_out].prev_out = 2 * e.id;
+      }
+      arcs[(2 * e.id) | 1].target = n.id;
+      arcs[2 * e.id].prev_out = -1;
+      arcs[2 * e.id].next_out = nodes[n.id].first_out;
+      nodes[n.id].first_out = 2 * e.id;
     }
 
     void changeU(Edge e, Node n) {
-      if(_arcs[(2 * e.id) | 1].next_out != -1) {
-        _arcs[_arcs[(2 * e.id) | 1].next_out].prev_out =
-          _arcs[(2 * e.id) | 1].prev_out;
-      }
-      if(_arcs[(2 * e.id) | 1].prev_out != -1) {
-        _arcs[_arcs[(2 * e.id) | 1].prev_out].next_out =
-          _arcs[(2 * e.id) | 1].next_out;
+      if(arcs[(2 * e.id) | 1].next_out != -1) {
+        arcs[arcs[(2 * e.id) | 1].next_out].prev_out =
+          arcs[(2 * e.id) | 1].prev_out;
+      }
+      if(arcs[(2 * e.id) | 1].prev_out != -1) {
+        arcs[arcs[(2 * e.id) | 1].prev_out].next_out =
+          arcs[(2 * e.id) | 1].next_out;
       } else {
-        _nodes[_arcs[2 * e.id].target].first_out =
-          _arcs[(2 * e.id) | 1].next_out;
-      }
-
-      if (_nodes[n.id].first_out != -1) {
-        _arcs[_nodes[n.id].first_out].prev_out = ((2 * e.id) | 1);
-      }
-      _arcs[2 * e.id].target = n.id;
-      _arcs[(2 * e.id) | 1].prev_out = -1;
-      _arcs[(2 * e.id) | 1].next_out = _nodes[n.id].first_out;
-      _nodes[n.id].first_out = ((2 * e.id) | 1);
+        nodes[arcs[2 * e.id].target].first_out =
+          arcs[(2 * e.id) | 1].next_out;
+      }
+
+      if (nodes[n.id].first_out != -1) {
+        arcs[nodes[n.id].first_out].prev_out = ((2 * e.id) | 1);
+      }
+      arcs[2 * e.id].target = n.id;
+      arcs[(2 * e.id) | 1].prev_out = -1;
+      arcs[(2 * e.id) | 1].next_out = nodes[n.id].first_out;
+      nodes[n.id].first_out = ((2 * e.id) | 1);
     }
 
@@ -1345,5 +1345,5 @@
     /// to build the graph.
     /// \sa reserveEdge()
-    void reserveNode(int n) { _nodes.reserve(n); };
+    void reserveNode(int n) { nodes.reserve(n); };
 
     /// Reserve memory for edges.
@@ -1355,5 +1355,5 @@
     /// to build the graph.
     /// \sa reserveNode()
-    void reserveEdge(int m) { _arcs.reserve(2 * m); };
+    void reserveEdge(int m) { arcs.reserve(2 * m); };
 
     /// \brief Class to make a snapshot of the graph and restore
@@ -1600,909 +1600,4 @@
 
   /// @}
-
-  class ListBpGraphBase {
-
-  protected:
-
-    struct NodeT {
-      int first_out;
-      int prev, next;
-      int partition_prev, partition_next;
-      int partition_index;
-      bool red;
-    };
-
-    struct ArcT {
-      int target;
-      int prev_out, next_out;
-    };
-
-    std::vector<NodeT> _nodes;
-
-    int first_node, first_red, first_blue;
-    int max_red, max_blue;
-
-    int first_free_red, first_free_blue;
-
-    std::vector<ArcT> _arcs;
-
-    int first_free_arc;
-
-  public:
-
-    typedef ListBpGraphBase BpGraph;
-
-    class Node {
-      friend class ListBpGraphBase;
-    protected:
-
-      int id;
-      explicit Node(int pid) { id = pid;}
-
-    public:
-      Node() {}
-      Node (Invalid) { id = -1; }
-      bool operator==(const Node& node) const {return id == node.id;}
-      bool operator!=(const Node& node) const {return id != node.id;}
-      bool operator<(const Node& node) const {return id < node.id;}
-    };
-
-    class RedNode : public Node {
-      friend class ListBpGraphBase;
-    protected:
-
-      explicit RedNode(int pid) : Node(pid) {}
-
-    public:
-      RedNode() {}
-      RedNode(const RedNode& node) : Node(node) {}
-      RedNode(Invalid) : Node(INVALID){}
-    };
-
-    class BlueNode : public Node {
-      friend class ListBpGraphBase;
-    protected:
-
-      explicit BlueNode(int pid) : Node(pid) {}
-
-    public:
-      BlueNode() {}
-      BlueNode(const BlueNode& node) : Node(node) {}
-      BlueNode(Invalid) : Node(INVALID){}
-    };
-
-    class Edge {
-      friend class ListBpGraphBase;
-    protected:
-
-      int id;
-      explicit Edge(int pid) { id = pid;}
-
-    public:
-      Edge() {}
-      Edge (Invalid) { id = -1; }
-      bool operator==(const Edge& edge) const {return id == edge.id;}
-      bool operator!=(const Edge& edge) const {return id != edge.id;}
-      bool operator<(const Edge& edge) const {return id < edge.id;}
-    };
-
-    class Arc {
-      friend class ListBpGraphBase;
-    protected:
-
-      int id;
-      explicit Arc(int pid) { id = pid;}
-
-    public:
-      operator Edge() const {
-        return id != -1 ? edgeFromId(id / 2) : INVALID;
-      }
-
-      Arc() {}
-      Arc (Invalid) { id = -1; }
-      bool operator==(const Arc& arc) const {return id == arc.id;}
-      bool operator!=(const Arc& arc) const {return id != arc.id;}
-      bool operator<(const Arc& arc) const {return id < arc.id;}
-    };
-
-    ListBpGraphBase()
-      : _nodes(), first_node(-1),
-        first_red(-1), first_blue(-1),
-        max_red(-1), max_blue(-1),
-        first_free_red(-1), first_free_blue(-1),
-        _arcs(), first_free_arc(-1) {}
-
-
-    bool red(Node n) const { return _nodes[n.id].red; }
-    bool blue(Node n) const { return !_nodes[n.id].red; }
-
-    static RedNode asRedNodeUnsafe(Node n) { return RedNode(n.id); }
-    static BlueNode asBlueNodeUnsafe(Node n) { return BlueNode(n.id); }
-
-    int maxNodeId() const { return _nodes.size()-1; }
-    int maxRedId() const { return max_red; }
-    int maxBlueId() const { return max_blue; }
-    int maxEdgeId() const { return _arcs.size() / 2 - 1; }
-    int maxArcId() const { return _arcs.size()-1; }
-
-    Node source(Arc e) const { return Node(_arcs[e.id ^ 1].target); }
-    Node target(Arc e) const { return Node(_arcs[e.id].target); }
-
-    RedNode redNode(Edge e) const {
-      return RedNode(_arcs[2 * e.id].target);
-    }
-    BlueNode blueNode(Edge e) const {
-      return BlueNode(_arcs[2 * e.id + 1].target);
-    }
-
-    static bool direction(Arc e) {
-      return (e.id & 1) == 1;
-    }
-
-    static Arc direct(Edge e, bool d) {
-      return Arc(e.id * 2 + (d ? 1 : 0));
-    }
-
-    void first(Node& node) const {
-      node.id = first_node;
-    }
-
-    void next(Node& node) const {
-      node.id = _nodes[node.id].next;
-    }
-
-    void first(RedNode& node) const {
-      node.id = first_red;
-    }
-
-    void next(RedNode& node) const {
-      node.id = _nodes[node.id].partition_next;
-    }
-
-    void first(BlueNode& node) const {
-      node.id = first_blue;
-    }
-
-    void next(BlueNode& node) const {
-      node.id = _nodes[node.id].partition_next;
-    }
-
-    void first(Arc& e) const {
-      int n = first_node;
-      while (n != -1 && _nodes[n].first_out == -1) {
-        n = _nodes[n].next;
-      }
-      e.id = (n == -1) ? -1 : _nodes[n].first_out;
-    }
-
-    void next(Arc& e) const {
-      if (_arcs[e.id].next_out != -1) {
-        e.id = _arcs[e.id].next_out;
-      } else {
-        int n = _nodes[_arcs[e.id ^ 1].target].next;
-        while(n != -1 && _nodes[n].first_out == -1) {
-          n = _nodes[n].next;
-        }
-        e.id = (n == -1) ? -1 : _nodes[n].first_out;
-      }
-    }
-
-    void first(Edge& e) const {
-      int n = first_node;
-      while (n != -1) {
-        e.id = _nodes[n].first_out;
-        while ((e.id & 1) != 1) {
-          e.id = _arcs[e.id].next_out;
-        }
-        if (e.id != -1) {
-          e.id /= 2;
-          return;
-        }
-        n = _nodes[n].next;
-      }
-      e.id = -1;
-    }
-
-    void next(Edge& e) const {
-      int n = _arcs[e.id * 2].target;
-      e.id = _arcs[(e.id * 2) | 1].next_out;
-      while ((e.id & 1) != 1) {
-        e.id = _arcs[e.id].next_out;
-      }
-      if (e.id != -1) {
-        e.id /= 2;
-        return;
-      }
-      n = _nodes[n].next;
-      while (n != -1) {
-        e.id = _nodes[n].first_out;
-        while ((e.id & 1) != 1) {
-          e.id = _arcs[e.id].next_out;
-        }
-        if (e.id != -1) {
-          e.id /= 2;
-          return;
-        }
-        n = _nodes[n].next;
-      }
-      e.id = -1;
-    }
-
-    void firstOut(Arc &e, const Node& v) const {
-      e.id = _nodes[v.id].first_out;
-    }
-    void nextOut(Arc &e) const {
-      e.id = _arcs[e.id].next_out;
-    }
-
-    void firstIn(Arc &e, const Node& v) const {
-      e.id = ((_nodes[v.id].first_out) ^ 1);
-      if (e.id == -2) e.id = -1;
-    }
-    void nextIn(Arc &e) const {
-      e.id = ((_arcs[e.id ^ 1].next_out) ^ 1);
-      if (e.id == -2) e.id = -1;
-    }
-
-    void firstInc(Edge &e, bool& d, const Node& v) const {
-      int a = _nodes[v.id].first_out;
-      if (a != -1 ) {
-        e.id = a / 2;
-        d = ((a & 1) == 1);
-      } else {
-        e.id = -1;
-        d = true;
-      }
-    }
-    void nextInc(Edge &e, bool& d) const {
-      int a = (_arcs[(e.id * 2) | (d ? 1 : 0)].next_out);
-      if (a != -1 ) {
-        e.id = a / 2;
-        d = ((a & 1) == 1);
-      } else {
-        e.id = -1;
-        d = true;
-      }
-    }
-
-    static int id(Node v) { return v.id; }
-    int id(RedNode v) const { return _nodes[v.id].partition_index; }
-    int id(BlueNode v) const { return _nodes[v.id].partition_index; }
-    static int id(Arc e) { return e.id; }
-    static int id(Edge e) { return e.id; }
-
-    static Node nodeFromId(int id) { return Node(id);}
-    static Arc arcFromId(int id) { return Arc(id);}
-    static Edge edgeFromId(int id) { return Edge(id);}
-
-    bool valid(Node n) const {
-      return n.id >= 0 && n.id < static_cast<int>(_nodes.size()) &&
-        _nodes[n.id].prev != -2;
-    }
-
-    bool valid(Arc a) const {
-      return a.id >= 0 && a.id < static_cast<int>(_arcs.size()) &&
-        _arcs[a.id].prev_out != -2;
-    }
-
-    bool valid(Edge e) const {
-      return e.id >= 0 && 2 * e.id < static_cast<int>(_arcs.size()) &&
-        _arcs[2 * e.id].prev_out != -2;
-    }
-
-    RedNode addRedNode() {
-      int n;
-
-      if(first_free_red==-1) {
-        n = _nodes.size();
-        _nodes.push_back(NodeT());
-        _nodes[n].partition_index = ++max_red;
-        _nodes[n].red = true;
-      } else {
-        n = first_free_red;
-        first_free_red = _nodes[n].next;
-      }
-
-      _nodes[n].next = first_node;
-      if (first_node != -1) _nodes[first_node].prev = n;
-      first_node = n;
-      _nodes[n].prev = -1;
-
-      _nodes[n].partition_next = first_red;
-      if (first_red != -1) _nodes[first_red].partition_prev = n;
-      first_red = n;
-      _nodes[n].partition_prev = -1;
-
-      _nodes[n].first_out = -1;
-
-      return RedNode(n);
-    }
-
-    BlueNode addBlueNode() {
-      int n;
-
-      if(first_free_blue==-1) {
-        n = _nodes.size();
-        _nodes.push_back(NodeT());
-        _nodes[n].partition_index = ++max_blue;
-        _nodes[n].red = false;
-      } else {
-        n = first_free_blue;
-        first_free_blue = _nodes[n].next;
-      }
-
-      _nodes[n].next = first_node;
-      if (first_node != -1) _nodes[first_node].prev = n;
-      first_node = n;
-      _nodes[n].prev = -1;
-
-      _nodes[n].partition_next = first_blue;
-      if (first_blue != -1) _nodes[first_blue].partition_prev = n;
-      first_blue = n;
-      _nodes[n].partition_prev = -1;
-
-      _nodes[n].first_out = -1;
-
-      return BlueNode(n);
-    }
-
-    Edge addEdge(Node u, Node v) {
-      int n;
-
-      if (first_free_arc == -1) {
-        n = _arcs.size();
-        _arcs.push_back(ArcT());
-        _arcs.push_back(ArcT());
-      } else {
-        n = first_free_arc;
-        first_free_arc = _arcs[n].next_out;
-      }
-
-      _arcs[n].target = u.id;
-      _arcs[n | 1].target = v.id;
-
-      _arcs[n].next_out = _nodes[v.id].first_out;
-      if (_nodes[v.id].first_out != -1) {
-        _arcs[_nodes[v.id].first_out].prev_out = n;
-      }
-      _arcs[n].prev_out = -1;
-      _nodes[v.id].first_out = n;
-
-      _arcs[n | 1].next_out = _nodes[u.id].first_out;
-      if (_nodes[u.id].first_out != -1) {
-        _arcs[_nodes[u.id].first_out].prev_out = (n | 1);
-      }
-      _arcs[n | 1].prev_out = -1;
-      _nodes[u.id].first_out = (n | 1);
-
-      return Edge(n / 2);
-    }
-
-    void erase(const Node& node) {
-      int n = node.id;
-
-      if(_nodes[n].next != -1) {
-        _nodes[_nodes[n].next].prev = _nodes[n].prev;
-      }
-
-      if(_nodes[n].prev != -1) {
-        _nodes[_nodes[n].prev].next = _nodes[n].next;
-      } else {
-        first_node = _nodes[n].next;
-      }
-
-      if (_nodes[n].partition_next != -1) {
-        _nodes[_nodes[n].partition_next].partition_prev = _nodes[n].partition_prev;
-      }
-
-      if (_nodes[n].partition_prev != -1) {
-        _nodes[_nodes[n].partition_prev].partition_next = _nodes[n].partition_next;
-      } else {
-        if (_nodes[n].red) {
-          first_red = _nodes[n].partition_next;
-        } else {
-          first_blue = _nodes[n].partition_next;
-        }
-      }
-
-      if (_nodes[n].red) {
-        _nodes[n].next = first_free_red;
-        first_free_red = n;
-      } else {
-        _nodes[n].next = first_free_blue;
-        first_free_blue = n;
-      }
-      _nodes[n].prev = -2;
-    }
-
-    void erase(const Edge& edge) {
-      int n = edge.id * 2;
-
-      if (_arcs[n].next_out != -1) {
-        _arcs[_arcs[n].next_out].prev_out = _arcs[n].prev_out;
-      }
-
-      if (_arcs[n].prev_out != -1) {
-        _arcs[_arcs[n].prev_out].next_out = _arcs[n].next_out;
-      } else {
-        _nodes[_arcs[n | 1].target].first_out = _arcs[n].next_out;
-      }
-
-      if (_arcs[n | 1].next_out != -1) {
-        _arcs[_arcs[n | 1].next_out].prev_out = _arcs[n | 1].prev_out;
-      }
-
-      if (_arcs[n | 1].prev_out != -1) {
-        _arcs[_arcs[n | 1].prev_out].next_out = _arcs[n | 1].next_out;
-      } else {
-        _nodes[_arcs[n].target].first_out = _arcs[n | 1].next_out;
-      }
-
-      _arcs[n].next_out = first_free_arc;
-      first_free_arc = n;
-      _arcs[n].prev_out = -2;
-      _arcs[n | 1].prev_out = -2;
-
-    }
-
-    void clear() {
-      _arcs.clear();
-      _nodes.clear();
-      first_node = first_free_arc = first_red = first_blue =
-        max_red = max_blue = first_free_red = first_free_blue = -1;
-    }
-
-  protected:
-
-    void changeRed(Edge e, RedNode n) {
-      if(_arcs[(2 * e.id) | 1].next_out != -1) {
-        _arcs[_arcs[(2 * e.id) | 1].next_out].prev_out =
-          _arcs[(2 * e.id) | 1].prev_out;
-      }
-      if(_arcs[(2 * e.id) | 1].prev_out != -1) {
-        _arcs[_arcs[(2 * e.id) | 1].prev_out].next_out =
-          _arcs[(2 * e.id) | 1].next_out;
-      } else {
-        _nodes[_arcs[2 * e.id].target].first_out =
-          _arcs[(2 * e.id) | 1].next_out;
-      }
-
-      if (_nodes[n.id].first_out != -1) {
-        _arcs[_nodes[n.id].first_out].prev_out = ((2 * e.id) | 1);
-      }
-      _arcs[2 * e.id].target = n.id;
-      _arcs[(2 * e.id) | 1].prev_out = -1;
-      _arcs[(2 * e.id) | 1].next_out = _nodes[n.id].first_out;
-      _nodes[n.id].first_out = ((2 * e.id) | 1);
-    }
-
-    void changeBlue(Edge e, BlueNode n) {
-       if(_arcs[2 * e.id].next_out != -1) {
-        _arcs[_arcs[2 * e.id].next_out].prev_out = _arcs[2 * e.id].prev_out;
-      }
-      if(_arcs[2 * e.id].prev_out != -1) {
-        _arcs[_arcs[2 * e.id].prev_out].next_out =
-          _arcs[2 * e.id].next_out;
-      } else {
-        _nodes[_arcs[(2 * e.id) | 1].target].first_out =
-          _arcs[2 * e.id].next_out;
-      }
-
-      if (_nodes[n.id].first_out != -1) {
-        _arcs[_nodes[n.id].first_out].prev_out = 2 * e.id;
-      }
-      _arcs[(2 * e.id) | 1].target = n.id;
-      _arcs[2 * e.id].prev_out = -1;
-      _arcs[2 * e.id].next_out = _nodes[n.id].first_out;
-      _nodes[n.id].first_out = 2 * e.id;
-    }
-
-  };
-
-  typedef BpGraphExtender<ListBpGraphBase> ExtendedListBpGraphBase;
-
-
-  /// \addtogroup graphs
-  /// @{
-
-  ///A general undirected graph structure.
-
-  ///\ref ListBpGraph is a versatile and fast undirected graph
-  ///implementation based on linked lists that are stored in
-  ///\c std::vector structures.
-  ///
-  ///This type fully conforms to the \ref concepts::BpGraph "BpGraph concept"
-  ///and it also provides several useful additional functionalities.
-  ///Most of its member functions and nested classes are documented
-  ///only in the concept class.
-  ///
-  ///This class provides only linear time counting for nodes, edges and arcs.
-  ///
-  ///\sa concepts::BpGraph
-  ///\sa ListDigraph
-  class ListBpGraph : public ExtendedListBpGraphBase {
-    typedef ExtendedListBpGraphBase Parent;
-
-  private:
-    /// BpGraphs are \e not copy constructible. Use BpGraphCopy instead.
-    ListBpGraph(const ListBpGraph &) :ExtendedListBpGraphBase()  {};
-    /// \brief Assignment of a graph to another one is \e not allowed.
-    /// Use BpGraphCopy instead.
-    void operator=(const ListBpGraph &) {}
-  public:
-    /// Constructor
-
-    /// Constructor.
-    ///
-    ListBpGraph() {}
-
-    typedef Parent::IncEdgeIt IncEdgeIt;
-
-    /// \brief Add a new red node to the graph.
-    ///
-    /// This function adds a red new node to the graph.
-    /// \return The new node.
-    RedNode addRedNode() { return Parent::addRedNode(); }
-
-    /// \brief Add a new blue node to the graph.
-    ///
-    /// This function adds a blue new node to the graph.
-    /// \return The new node.
-    BlueNode addBlueNode() { return Parent::addBlueNode(); }
-
-    /// \brief Add a new edge to the graph.
-    ///
-    /// This function adds a new edge to the graph between nodes
-    /// \c u and \c v with inherent orientation from node \c u to
-    /// node \c v.
-    /// \return The new edge.
-    Edge addEdge(RedNode u, BlueNode v) {
-      return Parent::addEdge(u, v);
-    }
-    Edge addEdge(BlueNode v, RedNode u) {
-      return Parent::addEdge(u, v);
-    }
-
-    ///\brief Erase a node from the graph.
-    ///
-    /// This function erases the given node along with its incident arcs
-    /// from the graph.
-    ///
-    /// \note All iterators referencing the removed node or the incident
-    /// edges are invalidated, of course.
-    void erase(Node n) { Parent::erase(n); }
-
-    ///\brief Erase an edge from the graph.
-    ///
-    /// This function erases the given edge from the graph.
-    ///
-    /// \note All iterators referencing the removed edge are invalidated,
-    /// of course.
-    void erase(Edge e) { Parent::erase(e); }
-    /// Node validity check
-
-    /// This function gives back \c true if the given node is valid,
-    /// i.e. it is a real node of the graph.
-    ///
-    /// \warning A removed node could become valid again if new nodes are
-    /// added to the graph.
-    bool valid(Node n) const { return Parent::valid(n); }
-    /// Edge validity check
-
-    /// This function gives back \c true if the given edge is valid,
-    /// i.e. it is a real edge of the graph.
-    ///
-    /// \warning A removed edge could become valid again if new edges are
-    /// added to the graph.
-    bool valid(Edge e) const { return Parent::valid(e); }
-    /// Arc validity check
-
-    /// This function gives back \c true if the given arc is valid,
-    /// i.e. it is a real arc of the graph.
-    ///
-    /// \warning A removed arc could become valid again if new edges are
-    /// added to the graph.
-    bool valid(Arc a) const { return Parent::valid(a); }
-
-    /// \brief Change the red node of an edge.
-    ///
-    /// This function changes the red node of the given edge \c e to \c n.
-    ///
-    ///\note \c EdgeIt and \c ArcIt iterators referencing the
-    ///changed edge are invalidated and all other iterators whose
-    ///base node is the changed node are also invalidated.
-    ///
-    ///\warning This functionality cannot be used together with the
-    ///Snapshot feature.
-    void changeRed(Edge e, RedNode n) {
-      Parent::changeRed(e, n);
-    }
-    /// \brief Change the blue node of an edge.
-    ///
-    /// This function changes the blue node of the given edge \c e to \c n.
-    ///
-    ///\note \c EdgeIt iterators referencing the changed edge remain
-    ///valid, but \c ArcIt iterators referencing the changed edge and
-    ///all other iterators whose base node is the changed node are also
-    ///invalidated.
-    ///
-    ///\warning This functionality cannot be used together with the
-    ///Snapshot feature.
-    void changeBlue(Edge e, BlueNode n) {
-      Parent::changeBlue(e, n);
-    }
-
-    ///Clear the graph.
-
-    ///This function erases all nodes and arcs from the graph.
-    ///
-    ///\note All iterators of the graph are invalidated, of course.
-    void clear() {
-      Parent::clear();
-    }
-
-    /// Reserve memory for nodes.
-
-    /// Using this function, it is possible to avoid superfluous memory
-    /// allocation: if you know that the graph you want to build will
-    /// be large (e.g. it will contain millions of nodes and/or edges),
-    /// then it is worth reserving space for this amount before starting
-    /// to build the graph.
-    /// \sa reserveEdge()
-    void reserveNode(int n) { _nodes.reserve(n); };
-
-    /// Reserve memory for edges.
-
-    /// Using this function, it is possible to avoid superfluous memory
-    /// allocation: if you know that the graph you want to build will
-    /// be large (e.g. it will contain millions of nodes and/or edges),
-    /// then it is worth reserving space for this amount before starting
-    /// to build the graph.
-    /// \sa reserveNode()
-    void reserveEdge(int m) { _arcs.reserve(2 * m); };
-
-    /// \brief Class to make a snapshot of the graph and restore
-    /// it later.
-    ///
-    /// Class to make a snapshot of the graph and restore it later.
-    ///
-    /// The newly added nodes and edges can be removed
-    /// using the restore() function.
-    ///
-    /// \note After a state is restored, you cannot restore a later state,
-    /// i.e. you cannot add the removed nodes and edges again using
-    /// another Snapshot instance.
-    ///
-    /// \warning Node and edge deletions and other modifications
-    /// (e.g. changing the end-nodes of edges or contracting nodes)
-    /// cannot be restored. These events invalidate the snapshot.
-    /// However, the edges and nodes that were added to the graph after
-    /// making the current snapshot can be removed without invalidating it.
-    class Snapshot {
-    protected:
-
-      typedef Parent::NodeNotifier NodeNotifier;
-
-      class NodeObserverProxy : public NodeNotifier::ObserverBase {
-      public:
-
-        NodeObserverProxy(Snapshot& _snapshot)
-          : snapshot(_snapshot) {}
-
-        using NodeNotifier::ObserverBase::attach;
-        using NodeNotifier::ObserverBase::detach;
-        using NodeNotifier::ObserverBase::attached;
-
-      protected:
-
-        virtual void add(const Node& node) {
-          snapshot.addNode(node);
-        }
-        virtual void add(const std::vector<Node>& nodes) {
-          for (int i = nodes.size() - 1; i >= 0; --i) {
-            snapshot.addNode(nodes[i]);
-          }
-        }
-        virtual void erase(const Node& node) {
-          snapshot.eraseNode(node);
-        }
-        virtual void erase(const std::vector<Node>& nodes) {
-          for (int i = 0; i < int(nodes.size()); ++i) {
-            snapshot.eraseNode(nodes[i]);
-          }
-        }
-        virtual void build() {
-          Node node;
-          std::vector<Node> nodes;
-          for (notifier()->first(node); node != INVALID;
-               notifier()->next(node)) {
-            nodes.push_back(node);
-          }
-          for (int i = nodes.size() - 1; i >= 0; --i) {
-            snapshot.addNode(nodes[i]);
-          }
-        }
-        virtual void clear() {
-          Node node;
-          for (notifier()->first(node); node != INVALID;
-               notifier()->next(node)) {
-            snapshot.eraseNode(node);
-          }
-        }
-
-        Snapshot& snapshot;
-      };
-
-      class EdgeObserverProxy : public EdgeNotifier::ObserverBase {
-      public:
-
-        EdgeObserverProxy(Snapshot& _snapshot)
-          : snapshot(_snapshot) {}
-
-        using EdgeNotifier::ObserverBase::attach;
-        using EdgeNotifier::ObserverBase::detach;
-        using EdgeNotifier::ObserverBase::attached;
-
-      protected:
-
-        virtual void add(const Edge& edge) {
-          snapshot.addEdge(edge);
-        }
-        virtual void add(const std::vector<Edge>& edges) {
-          for (int i = edges.size() - 1; i >= 0; --i) {
-            snapshot.addEdge(edges[i]);
-          }
-        }
-        virtual void erase(const Edge& edge) {
-          snapshot.eraseEdge(edge);
-        }
-        virtual void erase(const std::vector<Edge>& edges) {
-          for (int i = 0; i < int(edges.size()); ++i) {
-            snapshot.eraseEdge(edges[i]);
-          }
-        }
-        virtual void build() {
-          Edge edge;
-          std::vector<Edge> edges;
-          for (notifier()->first(edge); edge != INVALID;
-               notifier()->next(edge)) {
-            edges.push_back(edge);
-          }
-          for (int i = edges.size() - 1; i >= 0; --i) {
-            snapshot.addEdge(edges[i]);
-          }
-        }
-        virtual void clear() {
-          Edge edge;
-          for (notifier()->first(edge); edge != INVALID;
-               notifier()->next(edge)) {
-            snapshot.eraseEdge(edge);
-          }
-        }
-
-        Snapshot& snapshot;
-      };
-
-      ListBpGraph *graph;
-
-      NodeObserverProxy node_observer_proxy;
-      EdgeObserverProxy edge_observer_proxy;
-
-      std::list<Node> added_nodes;
-      std::list<Edge> added_edges;
-
-
-      void addNode(const Node& node) {
-        added_nodes.push_front(node);
-      }
-      void eraseNode(const Node& node) {
-        std::list<Node>::iterator it =
-          std::find(added_nodes.begin(), added_nodes.end(), node);
-        if (it == added_nodes.end()) {
-          clear();
-          edge_observer_proxy.detach();
-          throw NodeNotifier::ImmediateDetach();
-        } else {
-          added_nodes.erase(it);
-        }
-      }
-
-      void addEdge(const Edge& edge) {
-        added_edges.push_front(edge);
-      }
-      void eraseEdge(const Edge& edge) {
-        std::list<Edge>::iterator it =
-          std::find(added_edges.begin(), added_edges.end(), edge);
-        if (it == added_edges.end()) {
-          clear();
-          node_observer_proxy.detach();
-          throw EdgeNotifier::ImmediateDetach();
-        } else {
-          added_edges.erase(it);
-        }
-      }
-
-      void attach(ListBpGraph &_graph) {
-        graph = &_graph;
-        node_observer_proxy.attach(graph->notifier(Node()));
-        edge_observer_proxy.attach(graph->notifier(Edge()));
-      }
-
-      void detach() {
-        node_observer_proxy.detach();
-        edge_observer_proxy.detach();
-      }
-
-      bool attached() const {
-        return node_observer_proxy.attached();
-      }
-
-      void clear() {
-        added_nodes.clear();
-        added_edges.clear();
-      }
-
-    public:
-
-      /// \brief Default constructor.
-      ///
-      /// Default constructor.
-      /// You have to call save() to actually make a snapshot.
-      Snapshot()
-        : graph(0), node_observer_proxy(*this),
-          edge_observer_proxy(*this) {}
-
-      /// \brief Constructor that immediately makes a snapshot.
-      ///
-      /// This constructor immediately makes a snapshot of the given graph.
-      Snapshot(ListBpGraph &gr)
-        : node_observer_proxy(*this),
-          edge_observer_proxy(*this) {
-        attach(gr);
-      }
-
-      /// \brief Make a snapshot.
-      ///
-      /// This function makes a snapshot of the given graph.
-      /// It can be called more than once. In case of a repeated
-      /// call, the previous snapshot gets lost.
-      void save(ListBpGraph &gr) {
-        if (attached()) {
-          detach();
-          clear();
-        }
-        attach(gr);
-      }
-
-      /// \brief Undo the changes until the last snapshot.
-      ///
-      /// This function undos the changes until the last snapshot
-      /// created by save() or Snapshot(ListBpGraph&).
-      ///
-      /// \warning This method invalidates the snapshot, i.e. repeated
-      /// restoring is not supported unless you call save() again.
-      void restore() {
-        detach();
-        for(std::list<Edge>::iterator it = added_edges.begin();
-            it != added_edges.end(); ++it) {
-          graph->erase(*it);
-        }
-        for(std::list<Node>::iterator it = added_nodes.begin();
-            it != added_nodes.end(); ++it) {
-          graph->erase(*it);
-        }
-        clear();
-      }
-
-      /// \brief Returns \c true if the snapshot is valid.
-      ///
-      /// This function returns \c true if the snapshot is valid.
-      bool valid() const {
-        return attached();
-      }
-    };
-  };
-
-  /// @}
 } //namespace lemon
 
