Index: gtags
===================================================================
--- .hgtags	(revision 770)
+++ 	(revision )
@@ -1,6 +1,0 @@
-06f816565bef381024acd7c15beb74ba407e3546 r1.1
-78b7231f0b2e786f74a9b0dbb345fe8b17fa35f9 r1.1.1
-86a880ba752dd02bfa084223b3cdf1698e5c0830 r1.1.2
-dfdb58f52f0220ccfb6dbedfe2a0be7d99995e0a r1.1.3
-f1398882a9280c3b0401f1c367b4b14483031786 r1.1.4
-74e2dac774c85cb589f5485213c0ff5c12166b74 r1.1.5
Index: NEWS
===================================================================
--- NEWS	(revision 768)
+++ NEWS	(revision 663)
@@ -1,73 +1,2 @@
-2011-11-09 Version 1.1.5 released
-
-        Bugfix release.
-
-        #428: Add missing lemon/lemon.pc.cmake to the release tarball
-        #429: Fix VS warnings
-        #430: Fix LpBase::Constr two-side limit bug
-
-2011-08-08 Version 1.1.4 released
-
-        Bugfix release.
-
-        #392: Bug fix in Dfs::start(s,t)
-        #414: Fix wrong initialization in Preflow
-        #404: Update Doxygen configuration
-        #416: Support tests with valgrind
-        #418: Better Win CodeBlock/MinGW support
-        #419: Backport build environment improvements from the main branch
-              - Build of mip_test and lp_test precede the running of the tests
-              - Also search for coin libs under ${COIN_ROOT_DIR}/lib/coin
-              - Do not look for COIN_VOL libraries
-        #382: Allow lgf file without Arc maps
-        
-2010-10-21 Version 1.1.3 released
-
-        Bugfix release.
-
-        #366: Fix Pred[Matrix]MapPath::empty()
-        #371: Bug fix in (di)graphCopy()
-              The target graph is cleared before adding nodes and arcs/edges.
-
-        #356: Fix multiple execution bug in weighted matchings
-        #364: Add missing UndirectedTags
-        #368: Fix the usage of std::numeric_limits<>::min() in Network Simplex
-        #372: Fix a critical bug in preflow
-
-2010-03-08 Version 1.1.2 released
-
-        Bugfix release.
-
-        #317: Fix (and improve) error message in mip_test.cc
-              Remove unnecessary OsiCbc dependency
-        #250: Fix in pathSource() and pathTarget()
-        #322: Distribute LEMONConfig.cmake.in
-        #321: Use pathCopy(from,to) instead of copyPath(to,from)
-        #330: Bug fix in map_extender.h
-        #335: Fix clear() function in ExtendFindEnum
-        #337: Use void* as LPX object pointer
-        #336: Fix the date field comment of graphToEps() output
-        #323: Bug fix in Suurballe
-
-2009-10-03 Version 1.1.1 released
-
-        Bugfix release.
-
-        #295: Suppress MSVC warnings using pragmas
-        ----: Various CMAKE related improvements
-              * Remove duplications from doc/CMakeLists.txt
-              * Rename documentation install folder from 'docs' to 'html'
-              * Add tools/CMakeLists.txt to the tarball
-              * Generate and install LEMONConfig.cmake
-              * Change the label of the html project in Visual Studio
-              * Fix the check for the 'long long' type
-              * Put the version string into config.h
-              * Minor CMake improvements
-              * Set the version to 'hg-tip' if everything fails
-        #311: Add missing 'explicit' keywords
-        #302: Fix the implementation and doc of CrossRefMap
-        #308: Remove duplicate list_graph.h entry from source list
-        #307: Bug fix in Preflow and Circulation
-
 2009-05-13 Version 1.1 released
 
Index: doc/groups.dox
===================================================================
--- doc/groups.dox	(revision 761)
+++ doc/groups.dox	(revision 661)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -227,4 +227,12 @@
 
 /**
+@defgroup matrices Matrices
+@ingroup datas
+\brief Two dimensional data storages implemented in LEMON.
+
+This group contains two dimensional data storages implemented in LEMON.
+*/
+
+/**
 @defgroup paths Path Structures
 @ingroup datas
@@ -276,6 +284,14 @@
 This group contains the algorithms for finding shortest paths in digraphs.
 
- - \ref Dijkstra Dijkstra's algorithm for finding shortest paths from a
-   source node when all arc lengths are non-negative.
+ - \ref Dijkstra algorithm for finding shortest paths from a source node
+   when all arc lengths are non-negative.
+ - \ref BellmanFord "Bellman-Ford" algorithm for finding shortest paths
+   from a source node when arc lenghts can be either positive or negative,
+   but the digraph should not contain directed cycles with negative total
+   length.
+ - \ref FloydWarshall "Floyd-Warshall" and \ref Johnson "Johnson" algorithms
+   for solving the \e all-pairs \e shortest \e paths \e problem when arc
+   lenghts can be either positive or negative, but the digraph should
+   not contain directed cycles with negative total length.
  - \ref Suurballe A successive shortest path algorithm for finding
    arc-disjoint paths between two nodes having minimum total length.
@@ -302,10 +318,16 @@
 \f[ 0 \leq f(uv) \leq cap(uv) \quad \forall uv\in A \f]
 
-\ref Preflow implements the preflow push-relabel algorithm of Goldberg and
-Tarjan for solving this problem. It also provides functions to query the
-minimum cut, which is the dual problem of maximum flow.
-
-
-\ref Circulation is a preflow push-relabel algorithm implemented directly
+LEMON contains several algorithms for solving maximum flow problems:
+- \ref EdmondsKarp Edmonds-Karp algorithm.
+- \ref Preflow Goldberg-Tarjan's preflow push-relabel algorithm.
+- \ref DinitzSleatorTarjan Dinitz's blocking flow algorithm with dynamic trees.
+- \ref GoldbergTarjan Preflow push-relabel algorithm with dynamic trees.
+
+In most cases the \ref Preflow "Preflow" algorithm provides the
+fastest method for computing a maximum flow. All implementations
+also provide functions to query the minimum cut, which is the dual
+problem of maximum flow.
+
+\ref Circulation is a preflow push-relabel algorithm implemented directly 
 for finding feasible circulations, which is a somewhat different problem,
 but it is strongly related to maximum flow.
@@ -323,7 +345,18 @@
 solution see \ref min_cost_flow "Minimum Cost Flow Problem".
 
-\ref NetworkSimplex is an efficient implementation of the primal Network
-Simplex algorithm for finding minimum cost flows. It also provides dual
-solution (node potentials), if an optimal flow is found.
+LEMON contains several algorithms for this problem.
+ - \ref NetworkSimplex Primal Network Simplex algorithm with various
+   pivot strategies.
+ - \ref CostScaling Push-Relabel and Augment-Relabel algorithms based on
+   cost scaling.
+ - \ref CapacityScaling Successive Shortest %Path algorithm with optional
+   capacity scaling.
+ - \ref CancelAndTighten The Cancel and Tighten algorithm.
+ - \ref CycleCanceling Cycle-Canceling algorithms.
+
+In general NetworkSimplex is the most efficient implementation,
+but in special cases other algorithms could be faster.
+For example, if the total supply and/or capacities are rather small,
+CapacityScaling is usually the fastest algorithm (without effective scaling).
 */
 
@@ -349,4 +382,6 @@
 - \ref HaoOrlin "Hao-Orlin algorithm" for calculating minimum cut
   in directed graphs.
+- \ref NagamochiIbaraki "Nagamochi-Ibaraki algorithm" for
+  calculating minimum cut in undirected graphs.
 - \ref GomoryHu "Gomory-Hu tree computation" for calculating
   all-pairs minimum cut in undirected graphs.
@@ -369,14 +404,28 @@
 
 /**
+@defgroup planar Planarity Embedding and Drawing
+@ingroup algs
+\brief Algorithms for planarity checking, embedding and drawing
+
+This group contains the algorithms for planarity checking,
+embedding and drawing.
+
+\image html planar.png
+\image latex planar.eps "Plane graph" width=\textwidth
+*/
+
+/**
 @defgroup matching Matching Algorithms
 @ingroup algs
 \brief Algorithms for finding matchings in graphs and bipartite graphs.
 
-This group contains the algorithms for calculating matchings in graphs.
-The general matching problem is finding a subset of the edges for which
-each node has at most one incident edge.
+This group contains the algorithms for calculating
+matchings in graphs and bipartite graphs. The general matching problem is
+finding a subset of the edges for which each node has at most one incident
+edge.
 
 There are several different algorithms for calculate matchings in
-graphs. The goal of the matching optimization
+graphs.  The matching problems in bipartite graphs are generally
+easier than in general graphs. The goal of the matching optimization
 can be finding maximum cardinality, maximum weight or minimum cost
 matching. The search can be constrained to find perfect or
@@ -384,4 +433,14 @@
 
 The matching algorithms implemented in LEMON:
+- \ref MaxBipartiteMatching Hopcroft-Karp augmenting path algorithm
+  for calculating maximum cardinality matching in bipartite graphs.
+- \ref PrBipartiteMatching Push-relabel algorithm
+  for calculating maximum cardinality matching in bipartite graphs.
+- \ref MaxWeightedBipartiteMatching
+  Successive shortest path algorithm for calculating maximum weighted
+  matching and maximum weighted bipartite matching in bipartite graphs.
+- \ref MinCostMaxBipartiteMatching
+  Successive shortest path algorithm for calculating minimum cost maximum
+  matching in bipartite graphs.
 - \ref MaxMatching Edmond's blossom shrinking algorithm for calculating
   maximum cardinality matching in general graphs.
@@ -415,4 +474,13 @@
 
 /**
+@defgroup approx Approximation Algorithms
+@ingroup algs
+\brief Approximation algorithms.
+
+This group contains the approximation and heuristic algorithms
+implemented in LEMON.
+*/
+
+/**
 @defgroup gen_opt_group General Optimization Tools
 \brief This group contains some general optimization frameworks
@@ -431,4 +499,21 @@
 various LP solvers could be used in the same manner with this
 interface.
+*/
+
+/**
+@defgroup lp_utils Tools for Lp and Mip Solvers
+@ingroup lp_group
+\brief Helper tools to the Lp and Mip solvers.
+
+This group adds some helper tools to general optimization framework
+implemented in LEMON.
+*/
+
+/**
+@defgroup metah Metaheuristics
+@ingroup gen_opt_group
+\brief Metaheuristics for LEMON library.
+
+This group contains some metaheuristic optimization tools.
 */
 
Index: doc/lgf.dox
===================================================================
--- doc/lgf.dox	(revision 761)
+++ doc/lgf.dox	(revision 757)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: doc/min_cost_flow.dox
===================================================================
--- doc/min_cost_flow.dox	(revision 761)
+++ doc/min_cost_flow.dox	(revision 661)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -82,5 +82,5 @@
    - if \f$\sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \neq sup(u)\f$,
      then \f$\pi(u)=0\f$.
-
+ 
 Here \f$cost^\pi(uv)\f$ denotes the \e reduced \e cost of the arc
 \f$uv\in A\f$ with respect to the potential function \f$\pi\f$, i.e.
@@ -120,5 +120,5 @@
 \f[ lower(uv) \leq f(uv) \leq upper(uv) \quad \forall uv\in A \f]
 
-It means that the total demand must be less or equal to the
+It means that the total demand must be less or equal to the 
 total supply (i.e. \f$\sum_{u\in V} sup(u)\f$ must be zero or
 positive) and all the demands have to be satisfied, but there
Index: lemon/adaptors.h
===================================================================
--- lemon/adaptors.h	(revision 793)
+++ lemon/adaptors.h	(revision 792)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -419,5 +419,5 @@
       Parent::initialize(digraph);
       _node_filter = &node_filter;
-      _arc_filter = &arc_filter;
+      _arc_filter = &arc_filter;      
     }
 
@@ -506,9 +506,9 @@
 
     template <typename V>
-    class NodeMap
-      : public SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
-              LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> {
+    class NodeMap 
+      : public SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>, 
+	      LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> {
       typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
-        LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent;
+	LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent;
 
     public:
@@ -533,7 +533,7 @@
 
     template <typename V>
-    class ArcMap
+    class ArcMap 
       : public SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
-              LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {
+	      LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {
       typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
         LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> Parent;
@@ -580,5 +580,5 @@
       Parent::initialize(digraph);
       _node_filter = &node_filter;
-      _arc_filter = &arc_filter;
+      _arc_filter = &arc_filter;      
     }
 
@@ -649,8 +649,8 @@
 
     template <typename V>
-    class NodeMap
+    class NodeMap 
       : public SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
           LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> {
-      typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
+      typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, false>, 
         LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent;
 
@@ -676,5 +676,5 @@
 
     template <typename V>
-    class ArcMap
+    class ArcMap 
       : public SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
           LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {
@@ -1017,8 +1017,8 @@
 
     template <typename V>
-    class NodeMap
+    class NodeMap 
       : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
           LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> {
-      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>, 
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> Parent;
 
@@ -1044,8 +1044,8 @@
 
     template <typename V>
-    class ArcMap
+    class ArcMap 
       : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
           LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> {
-      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>, 
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> Parent;
 
@@ -1071,8 +1071,8 @@
 
     template <typename V>
-    class EdgeMap
+    class EdgeMap 
       : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> {
-      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>, 
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> Parent;
 
@@ -1113,6 +1113,6 @@
     NF* _node_filter;
     EF* _edge_filter;
-    SubGraphBase()
-          : Parent(), _node_filter(0), _edge_filter(0) { }
+    SubGraphBase() 
+	  : Parent(), _node_filter(0), _edge_filter(0) { }
 
     void initialize(GR& graph, NF& node_filter, EF& edge_filter) {
@@ -1215,8 +1215,8 @@
 
     template <typename V>
-    class NodeMap
+    class NodeMap 
       : public SubMapExtender<SubGraphBase<GR, NF, EF, false>,
           LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> {
-      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>, 
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> Parent;
 
@@ -1242,8 +1242,8 @@
 
     template <typename V>
-    class ArcMap
+    class ArcMap 
       : public SubMapExtender<SubGraphBase<GR, NF, EF, false>,
           LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> {
-      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>, 
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> Parent;
 
@@ -1269,9 +1269,9 @@
 
     template <typename V>
-    class EdgeMap
+    class EdgeMap 
       : public SubMapExtender<SubGraphBase<GR, NF, EF, false>,
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> {
-      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
-        LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> Parent;
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>, 
+	LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> Parent;
 
     public:
@@ -1496,5 +1496,5 @@
 #endif
     typedef DigraphAdaptorExtender<
-      SubDigraphBase<GR, NF, ConstMap<typename GR::Arc, Const<bool, true> >,
+      SubDigraphBase<GR, NF, ConstMap<typename GR::Arc, Const<bool, true> >, 
                      true> > Parent;
 
@@ -1517,5 +1517,5 @@
     /// Creates a subgraph for the given digraph or graph with the
     /// given node filter map.
-    FilterNodes(GR& graph, NF& node_filter)
+    FilterNodes(GR& graph, NF& node_filter) 
       : Parent(), const_true_map()
     {
@@ -1555,9 +1555,9 @@
                     typename enable_if<UndirectedTagIndicator<GR> >::type> :
     public GraphAdaptorExtender<
-      SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >,
+      SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >, 
                    true> > {
 
     typedef GraphAdaptorExtender<
-      SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >,
+      SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >, 
                    true> > Parent;
 
@@ -1643,5 +1643,5 @@
 #endif
     typedef DigraphAdaptorExtender<
-      SubDigraphBase<DGR, ConstMap<typename DGR::Node, Const<bool, true> >,
+      SubDigraphBase<DGR, ConstMap<typename DGR::Node, Const<bool, true> >, 
                      AF, false> > Parent;
 
@@ -1749,9 +1749,9 @@
   class FilterEdges :
     public GraphAdaptorExtender<
-      SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true> >,
+      SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true> >, 
                    EF, false> > {
 #endif
     typedef GraphAdaptorExtender<
-      SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true > >,
+      SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true > >, 
                    EF, false> > Parent;
 
@@ -1778,5 +1778,5 @@
     /// Creates a subgraph for the given graph with the given edge
     /// filter map.
-    FilterEdges(GR& graph, EF& edge_filter)
+    FilterEdges(GR& graph, EF& edge_filter) 
       : Parent(), const_true_map() {
       Parent::initialize(graph, const_true_map, edge_filter);
@@ -1846,5 +1846,5 @@
       bool _forward;
 
-      Arc(const Edge& edge, bool forward)
+      Arc(const Edge& edge, bool forward) 
         : _edge(edge), _forward(forward) {}
 
@@ -2086,5 +2086,5 @@
 
       ArcMapBase(const UndirectorBase<DGR>& adaptor, const V& value)
-        : _forward(*adaptor._digraph, value),
+        : _forward(*adaptor._digraph, value), 
           _backward(*adaptor._digraph, value) {}
 
@@ -2204,5 +2204,5 @@
     typedef typename ItemSetTraits<DGR, Edge>::ItemNotifier EdgeNotifier;
     EdgeNotifier& notifier(Edge) const { return _digraph->notifier(Edge()); }
-
+    
     typedef EdgeNotifier ArcNotifier;
     ArcNotifier& notifier(Arc) const { return _digraph->notifier(Edge()); }
@@ -2708,5 +2708,5 @@
            typename FM = CM,
            typename TL = Tolerance<typename CM::Value> >
-  class ResidualDigraph
+  class ResidualDigraph 
     : public SubDigraph<
         Undirector<const DGR>,
@@ -2765,5 +2765,5 @@
     ResidualDigraph(const DGR& digraph, const CM& capacity,
                     FM& flow, const TL& tolerance = Tolerance())
-      : Parent(), _capacity(&capacity), _flow(&flow),
+      : Parent(), _capacity(&capacity), _flow(&flow), 
         _graph(digraph), _node_filter(),
         _forward_filter(capacity, flow, tolerance),
@@ -2847,5 +2847,5 @@
 
       /// Constructor
-      ResidualCapacity(const ResidualDigraph<DGR, CM, FM, TL>& adaptor)
+      ResidualCapacity(const ResidualDigraph<DGR, CM, FM, TL>& adaptor) 
         : _adaptor(&adaptor) {}
 
@@ -3424,5 +3424,5 @@
     /// to get a node map of the split digraph.
     /// Its value type is inherited from the first node map type (\c IN).
-    /// \tparam IN The type of the node map for the in-nodes.
+    /// \tparam IN The type of the node map for the in-nodes. 
     /// \tparam OUT The type of the node map for the out-nodes.
     template <typename IN, typename OUT>
Index: lemon/assert.h
===================================================================
--- lemon/assert.h	(revision 802)
+++ lemon/assert.h	(revision 440)
@@ -200,5 +200,5 @@
                              ::lemon::_assert_bits::cstringify(msg),    \
                              #exp), 0)))
-#    if defined LEMON_ENABLE_DEBUG
+#    if LEMON_ENABLE_DEBUG
 #      define LEMON_DEBUG(exp, msg)                                     \
          (static_cast<void> (!!(exp) ? 0 : (                            \
Index: lemon/bin_heap.h
===================================================================
--- lemon/bin_heap.h	(revision 761)
+++ lemon/bin_heap.h	(revision 705)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/bits/array_map.h
===================================================================
--- lemon/bits/array_map.h	(revision 761)
+++ lemon/bits/array_map.h	(revision 609)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -71,5 +71,5 @@
 
   private:
-
+  
     // The MapBase of the Map which imlements the core regisitry function.
     typedef typename Notifier::ObserverBase Parent;
Index: lemon/bits/default_map.h
===================================================================
--- lemon/bits/default_map.h	(revision 761)
+++ lemon/bits/default_map.h	(revision 622)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -158,5 +158,5 @@
   public:
     typedef DefaultMap<_Graph, _Item, _Value> Map;
-
+    
     typedef typename Parent::GraphType GraphType;
     typedef typename Parent::Value Value;
Index: lemon/bits/edge_set_extender.h
===================================================================
--- lemon/bits/edge_set_extender.h	(revision 793)
+++ lemon/bits/edge_set_extender.h	(revision 792)
@@ -1,7 +1,7 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
+/* -*- C++ -*-
  *
- * This file is a part of LEMON, a generic C++ optimization library.
+ * This file is a part of LEMON, a generic C++ optimization library
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -64,9 +64,9 @@
     Node oppositeNode(const Node &n, const Arc &e) const {
       if (n == Parent::source(e))
-        return Parent::target(e);
+	return Parent::target(e);
       else if(n==Parent::target(e))
-        return Parent::source(e);
+	return Parent::source(e);
       else
-        return INVALID;
+	return INVALID;
     }
 
@@ -92,5 +92,5 @@
     // Iterable extensions
 
-    class NodeIt : public Node {
+    class NodeIt : public Node { 
       const Digraph* digraph;
     public:
@@ -101,19 +101,19 @@
 
       explicit NodeIt(const Digraph& _graph) : digraph(&_graph) {
-        _graph.first(static_cast<Node&>(*this));
-      }
-
-      NodeIt(const Digraph& _graph, const Node& node)
-        : Node(node), digraph(&_graph) {}
-
-      NodeIt& operator++() {
-        digraph->next(*this);
-        return *this;
-      }
-
-    };
-
-
-    class ArcIt : public Arc {
+	_graph.first(static_cast<Node&>(*this));
+      }
+
+      NodeIt(const Digraph& _graph, const Node& node) 
+	: Node(node), digraph(&_graph) {}
+
+      NodeIt& operator++() { 
+	digraph->next(*this);
+	return *this; 
+      }
+
+    };
+
+
+    class ArcIt : public Arc { 
       const Digraph* digraph;
     public:
@@ -124,19 +124,19 @@
 
       explicit ArcIt(const Digraph& _graph) : digraph(&_graph) {
-        _graph.first(static_cast<Arc&>(*this));
-      }
-
-      ArcIt(const Digraph& _graph, const Arc& e) :
-        Arc(e), digraph(&_graph) { }
-
-      ArcIt& operator++() {
-        digraph->next(*this);
-        return *this;
-      }
-
-    };
-
-
-    class OutArcIt : public Arc {
+	_graph.first(static_cast<Arc&>(*this));
+      }
+
+      ArcIt(const Digraph& _graph, const Arc& e) : 
+	Arc(e), digraph(&_graph) { }
+
+      ArcIt& operator++() { 
+	digraph->next(*this);
+	return *this; 
+      }
+
+    };
+
+
+    class OutArcIt : public Arc { 
       const Digraph* digraph;
     public:
@@ -146,21 +146,21 @@
       OutArcIt(Invalid i) : Arc(i) { }
 
-      OutArcIt(const Digraph& _graph, const Node& node)
-        : digraph(&_graph) {
-        _graph.firstOut(*this, node);
-      }
-
-      OutArcIt(const Digraph& _graph, const Arc& arc)
-        : Arc(arc), digraph(&_graph) {}
-
-      OutArcIt& operator++() {
-        digraph->nextOut(*this);
-        return *this;
-      }
-
-    };
-
-
-    class InArcIt : public Arc {
+      OutArcIt(const Digraph& _graph, const Node& node) 
+	: digraph(&_graph) {
+	_graph.firstOut(*this, node);
+      }
+
+      OutArcIt(const Digraph& _graph, const Arc& arc) 
+	: Arc(arc), digraph(&_graph) {}
+
+      OutArcIt& operator++() { 
+	digraph->nextOut(*this);
+	return *this; 
+      }
+
+    };
+
+
+    class InArcIt : public Arc { 
       const Digraph* digraph;
     public:
@@ -170,15 +170,15 @@
       InArcIt(Invalid i) : Arc(i) { }
 
-      InArcIt(const Digraph& _graph, const Node& node)
-        : digraph(&_graph) {
-        _graph.firstIn(*this, node);
-      }
-
-      InArcIt(const Digraph& _graph, const Arc& arc) :
-        Arc(arc), digraph(&_graph) {}
-
-      InArcIt& operator++() {
-        digraph->nextIn(*this);
-        return *this;
+      InArcIt(const Digraph& _graph, const Node& node) 
+	: digraph(&_graph) {
+	_graph.firstIn(*this, node);
+      }
+
+      InArcIt(const Digraph& _graph, const Arc& arc) : 
+	Arc(arc), digraph(&_graph) {}
+
+      InArcIt& operator++() { 
+	digraph->nextIn(*this);
+	return *this; 
       }
 
@@ -216,18 +216,18 @@
 
     // Mappable extension
-
+    
     template <typename _Value>
-    class ArcMap
+    class ArcMap 
       : public MapExtender<DefaultMap<Digraph, Arc, _Value> > {
       typedef MapExtender<DefaultMap<Digraph, Arc, _Value> > Parent;
 
     public:
-      explicit ArcMap(const Digraph& _g)
-        : Parent(_g) {}
-      ArcMap(const Digraph& _g, const _Value& _v)
-        : Parent(_g, _v) {}
+      explicit ArcMap(const Digraph& _g) 
+	: Parent(_g) {}
+      ArcMap(const Digraph& _g, const _Value& _v) 
+	: Parent(_g, _v) {}
 
       ArcMap& operator=(const ArcMap& cmap) {
-        return operator=<ArcMap>(cmap);
+	return operator=<ArcMap>(cmap);
       }
 
@@ -235,5 +235,5 @@
       ArcMap& operator=(const CMap& cmap) {
         Parent::operator=(cmap);
-        return *this;
+	return *this;
       }
 
@@ -248,5 +248,5 @@
       return arc;
     }
-
+    
     void clear() {
       notifier(Arc()).clear();
@@ -313,9 +313,9 @@
     Node oppositeNode(const Node &n, const Edge &e) const {
       if( n == Parent::u(e))
-        return Parent::v(e);
+	return Parent::v(e);
       else if( n == Parent::v(e))
-        return Parent::u(e);
+	return Parent::u(e);
       else
-        return INVALID;
+	return INVALID;
     }
 
@@ -341,5 +341,5 @@
 
     using Parent::notifier;
-
+    
     ArcNotifier& notifier(Arc) const {
       return arc_notifier;
@@ -351,5 +351,5 @@
 
 
-    class NodeIt : public Node {
+    class NodeIt : public Node { 
       const Graph* graph;
     public:
@@ -360,19 +360,19 @@
 
       explicit NodeIt(const Graph& _graph) : graph(&_graph) {
-        _graph.first(static_cast<Node&>(*this));
-      }
-
-      NodeIt(const Graph& _graph, const Node& node)
-        : Node(node), graph(&_graph) {}
-
-      NodeIt& operator++() {
-        graph->next(*this);
-        return *this;
-      }
-
-    };
-
-
-    class ArcIt : public Arc {
+	_graph.first(static_cast<Node&>(*this));
+      }
+
+      NodeIt(const Graph& _graph, const Node& node) 
+	: Node(node), graph(&_graph) {}
+
+      NodeIt& operator++() { 
+	graph->next(*this);
+	return *this; 
+      }
+
+    };
+
+
+    class ArcIt : public Arc { 
       const Graph* graph;
     public:
@@ -383,19 +383,19 @@
 
       explicit ArcIt(const Graph& _graph) : graph(&_graph) {
-        _graph.first(static_cast<Arc&>(*this));
-      }
-
-      ArcIt(const Graph& _graph, const Arc& e) :
-        Arc(e), graph(&_graph) { }
-
-      ArcIt& operator++() {
-        graph->next(*this);
-        return *this;
-      }
-
-    };
-
-
-    class OutArcIt : public Arc {
+	_graph.first(static_cast<Arc&>(*this));
+      }
+
+      ArcIt(const Graph& _graph, const Arc& e) : 
+	Arc(e), graph(&_graph) { }
+
+      ArcIt& operator++() { 
+	graph->next(*this);
+	return *this; 
+      }
+
+    };
+
+
+    class OutArcIt : public Arc { 
       const Graph* graph;
     public:
@@ -405,21 +405,21 @@
       OutArcIt(Invalid i) : Arc(i) { }
 
-      OutArcIt(const Graph& _graph, const Node& node)
-        : graph(&_graph) {
-        _graph.firstOut(*this, node);
-      }
-
-      OutArcIt(const Graph& _graph, const Arc& arc)
-        : Arc(arc), graph(&_graph) {}
-
-      OutArcIt& operator++() {
-        graph->nextOut(*this);
-        return *this;
-      }
-
-    };
-
-
-    class InArcIt : public Arc {
+      OutArcIt(const Graph& _graph, const Node& node) 
+	: graph(&_graph) {
+	_graph.firstOut(*this, node);
+      }
+
+      OutArcIt(const Graph& _graph, const Arc& arc) 
+	: Arc(arc), graph(&_graph) {}
+
+      OutArcIt& operator++() { 
+	graph->nextOut(*this);
+	return *this; 
+      }
+
+    };
+
+
+    class InArcIt : public Arc { 
       const Graph* graph;
     public:
@@ -429,21 +429,21 @@
       InArcIt(Invalid i) : Arc(i) { }
 
-      InArcIt(const Graph& _graph, const Node& node)
-        : graph(&_graph) {
-        _graph.firstIn(*this, node);
-      }
-
-      InArcIt(const Graph& _graph, const Arc& arc) :
-        Arc(arc), graph(&_graph) {}
-
-      InArcIt& operator++() {
-        graph->nextIn(*this);
-        return *this;
-      }
-
-    };
-
-
-    class EdgeIt : public Parent::Edge {
+      InArcIt(const Graph& _graph, const Node& node) 
+	: graph(&_graph) {
+	_graph.firstIn(*this, node);
+      }
+
+      InArcIt(const Graph& _graph, const Arc& arc) : 
+	Arc(arc), graph(&_graph) {}
+
+      InArcIt& operator++() { 
+	graph->nextIn(*this);
+	return *this; 
+      }
+
+    };
+
+
+    class EdgeIt : public Parent::Edge { 
       const Graph* graph;
     public:
@@ -454,13 +454,13 @@
 
       explicit EdgeIt(const Graph& _graph) : graph(&_graph) {
-        _graph.first(static_cast<Edge&>(*this));
-      }
-
-      EdgeIt(const Graph& _graph, const Edge& e) :
-        Edge(e), graph(&_graph) { }
-
-      EdgeIt& operator++() {
-        graph->next(*this);
-        return *this;
+	_graph.first(static_cast<Edge&>(*this));
+      }
+
+      EdgeIt(const Graph& _graph, const Edge& e) : 
+	Edge(e), graph(&_graph) { }
+
+      EdgeIt& operator++() { 
+	graph->next(*this);
+	return *this; 
       }
 
@@ -478,15 +478,15 @@
 
       IncEdgeIt(const Graph& _graph, const Node &n) : graph(&_graph) {
-        _graph.firstInc(*this, direction, n);
+	_graph.firstInc(*this, direction, n);
       }
 
       IncEdgeIt(const Graph& _graph, const Edge &ue, const Node &n)
-        : graph(&_graph), Edge(ue) {
-        direction = (_graph.source(ue) == n);
+	: graph(&_graph), Edge(ue) {
+	direction = (_graph.source(ue) == n);
       }
 
       IncEdgeIt& operator++() {
-        graph->nextInc(*this, direction);
-        return *this;
+	graph->nextInc(*this, direction);
+	return *this; 
       }
     };
@@ -535,16 +535,16 @@
 
     template <typename _Value>
-    class ArcMap
+    class ArcMap 
       : public MapExtender<DefaultMap<Graph, Arc, _Value> > {
       typedef MapExtender<DefaultMap<Graph, Arc, _Value> > Parent;
 
     public:
-      explicit ArcMap(const Graph& _g)
-        : Parent(_g) {}
-      ArcMap(const Graph& _g, const _Value& _v)
-        : Parent(_g, _v) {}
+      explicit ArcMap(const Graph& _g) 
+	: Parent(_g) {}
+      ArcMap(const Graph& _g, const _Value& _v) 
+	: Parent(_g, _v) {}
 
       ArcMap& operator=(const ArcMap& cmap) {
-        return operator=<ArcMap>(cmap);
+	return operator=<ArcMap>(cmap);
       }
 
@@ -552,5 +552,5 @@
       ArcMap& operator=(const CMap& cmap) {
         Parent::operator=(cmap);
-        return *this;
+	return *this;
       }
 
@@ -559,17 +559,17 @@
 
     template <typename _Value>
-    class EdgeMap
+    class EdgeMap 
       : public MapExtender<DefaultMap<Graph, Edge, _Value> > {
       typedef MapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
 
     public:
-      explicit EdgeMap(const Graph& _g)
-        : Parent(_g) {}
-
-      EdgeMap(const Graph& _g, const _Value& _v)
-        : Parent(_g, _v) {}
+      explicit EdgeMap(const Graph& _g) 
+	: Parent(_g) {}
+
+      EdgeMap(const Graph& _g, const _Value& _v) 
+	: Parent(_g, _v) {}
 
       EdgeMap& operator=(const EdgeMap& cmap) {
-        return operator=<EdgeMap>(cmap);
+	return operator=<EdgeMap>(cmap);
       }
 
@@ -577,5 +577,5 @@
       EdgeMap& operator=(const CMap& cmap) {
         Parent::operator=(cmap);
-        return *this;
+	return *this;
       }
 
@@ -594,5 +594,5 @@
       return edge;
     }
-
+    
     void clear() {
       notifier(Arc()).clear();
@@ -620,5 +620,5 @@
       arc_notifier.clear();
     }
-
+    
   };
 
Index: lemon/bits/graph_adaptor_extender.h
===================================================================
--- lemon/bits/graph_adaptor_extender.h	(revision 761)
+++ lemon/bits/graph_adaptor_extender.h	(revision 724)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/bits/map_extender.h
===================================================================
--- lemon/bits/map_extender.h	(revision 761)
+++ lemon/bits/map_extender.h	(revision 708)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/bits/path_dump.h
===================================================================
--- lemon/bits/path_dump.h	(revision 761)
+++ lemon/bits/path_dump.h	(revision 728)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/bits/solver_bits.h
===================================================================
--- lemon/bits/solver_bits.h	(revision 786)
+++ lemon/bits/solver_bits.h	(revision 785)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/bits/windows.cc
===================================================================
--- lemon/bits/windows.cc	(revision 761)
+++ lemon/bits/windows.cc	(revision 749)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -99,5 +99,5 @@
       GetSystemTime(&time);
       char buf1[11], buf2[9], buf3[5];
-          if (GetDateFormat(MY_LOCALE, 0, &time,
+	  if (GetDateFormat(MY_LOCALE, 0, &time,
                         ("ddd MMM dd"), buf1, 11) &&
           GetTimeFormat(MY_LOCALE, 0, &time,
Index: lemon/cbc.h
===================================================================
--- lemon/cbc.h	(revision 761)
+++ lemon/cbc.h	(revision 568)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -121,5 +121,5 @@
     int _message_level;
 
-
+    
 
   };
Index: lemon/circulation.h
===================================================================
--- lemon/circulation.h	(revision 793)
+++ lemon/circulation.h	(revision 792)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -60,6 +60,6 @@
     /// \brief The type of supply map.
     ///
-    /// The type of the map that stores the signed supply values of the
-    /// nodes.
+    /// The type of the map that stores the signed supply values of the 
+    /// nodes. 
     /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
     typedef SM SupplyMap;
@@ -135,5 +135,5 @@
      \geq sup(u) \quad \forall u\in V, \f]
      \f[ lower(uv) \leq f(uv) \leq upper(uv) \quad \forall uv\in A. \f]
-
+     
      The sum of the supply values, i.e. \f$\sum_{u\in V} sup(u)\f$ must be
      zero or negative in order to have a feasible solution (since the sum
@@ -145,5 +145,5 @@
      constraints have to be satisfied with equality, i.e. all demands
      have to be satisfied and all supplies have to be used.
-
+     
      If you need the opposite inequalities in the supply/demand constraints
      (i.e. the total demand is less than the total supply and all the demands
@@ -326,5 +326,5 @@
     /// \param graph The digraph the algorithm runs on.
     /// \param lower The lower bounds for the flow values on the arcs.
-    /// \param upper The upper bounds (capacities) for the flow values
+    /// \param upper The upper bounds (capacities) for the flow values 
     /// on the arcs.
     /// \param supply The signed supply values of the nodes.
Index: lemon/clp.cc
===================================================================
--- lemon/clp.cc	(revision 786)
+++ lemon/clp.cc	(revision 785)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/clp.h
===================================================================
--- lemon/clp.h	(revision 761)
+++ lemon/clp.h	(revision 568)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -138,5 +138,5 @@
 
     virtual void _messageLevel(MessageLevel);
-
+    
   public:
 
Index: lemon/concepts/digraph.h
===================================================================
--- lemon/concepts/digraph.h	(revision 808)
+++ lemon/concepts/digraph.h	(revision 807)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -436,5 +436,5 @@
       private:
         ///Copy constructor
-        NodeMap(const NodeMap& nm) :
+        NodeMap(const NodeMap& nm) : 
           ReferenceMap<Node, T, T&, const T&>(nm) { }
         ///Assignment operator
Index: lemon/concepts/graph_components.h
===================================================================
--- lemon/concepts/graph_components.h	(revision 808)
+++ lemon/concepts/graph_components.h	(revision 807)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -39,5 +39,5 @@
     /// \note This class is a template class so that we can use it to
     /// create graph skeleton classes. The reason for this is that \c Node
-    /// and \c Arc (or \c Edge) types should \e not derive from the same
+    /// and \c Arc (or \c Edge) types should \e not derive from the same 
     /// base class. For \c Node you should instantiate it with character
     /// \c 'n', for \c Arc with \c 'a' and for \c Edge with \c 'e'.
@@ -90,5 +90,5 @@
       ///
       /// This operator defines an ordering of the items.
-      /// It makes possible to use graph item types as key types in
+      /// It makes possible to use graph item types as key types in 
       /// associative containers (e.g. \c std::map).
       ///
@@ -126,5 +126,5 @@
     /// This class describes the base interface of directed graph types.
     /// All digraph %concepts have to conform to this class.
-    /// It just provides types for nodes and arcs and functions
+    /// It just provides types for nodes and arcs and functions 
     /// to get the source and the target nodes of arcs.
     class BaseDigraphComponent {
@@ -434,5 +434,5 @@
     /// \brief Concept class for \c NodeIt, \c ArcIt and \c EdgeIt types.
     ///
-    /// This class describes the concept of \c NodeIt, \c ArcIt and
+    /// This class describes the concept of \c NodeIt, \c ArcIt and 
     /// \c EdgeIt subtypes of digraph and graph types.
     template <typename GR, typename Item>
@@ -474,5 +474,5 @@
       /// next item.
       GraphItemIt& operator++() { return *this; }
-
+ 
       /// \brief Equality operator
       ///
@@ -512,13 +512,13 @@
     };
 
-    /// \brief Concept class for \c InArcIt, \c OutArcIt and
+    /// \brief Concept class for \c InArcIt, \c OutArcIt and 
     /// \c IncEdgeIt types.
     ///
-    /// This class describes the concept of \c InArcIt, \c OutArcIt
+    /// This class describes the concept of \c InArcIt, \c OutArcIt 
     /// and \c IncEdgeIt subtypes of digraph and graph types.
     ///
     /// \note Since these iterator classes do not inherit from the same
     /// base class, there is an additional template parameter (selector)
-    /// \c sel. For \c InArcIt you should instantiate it with character
+    /// \c sel. For \c InArcIt you should instantiate it with character 
     /// \c 'i', for \c OutArcIt with \c 'o' and for \c IncEdgeIt with \c 'e'.
     template <typename GR,
@@ -541,8 +541,8 @@
       GraphIncIt(const GraphIncIt& it) : Item(it) {}
 
-      /// \brief Constructor that sets the iterator to the first
+      /// \brief Constructor that sets the iterator to the first 
       /// incoming or outgoing arc.
       ///
-      /// Constructor that sets the iterator to the first arc
+      /// Constructor that sets the iterator to the first arc 
       /// incoming to or outgoing from the given node.
       explicit GraphIncIt(const GR&, const Base&) {}
@@ -819,7 +819,7 @@
       /// \brief Return the first edge incident to the given node.
       ///
-      /// This function gives back the first edge incident to the given
+      /// This function gives back the first edge incident to the given 
       /// node. The bool parameter gives back the direction for which the
-      /// source node of the directed arc representing the edge is the
+      /// source node of the directed arc representing the edge is the 
       /// given node.
       void firstInc(Edge&, bool&, const Node&) const {}
@@ -828,5 +828,5 @@
       /// given node.
       ///
-      /// This function gives back the next edge incident to the given
+      /// This function gives back the next edge incident to the given 
       /// node. The bool parameter should be used as \c firstInc() use it.
       void nextInc(Edge&, bool&) const {}
@@ -1008,5 +1008,5 @@
     ///
     /// This class describes the concept of standard graph maps, i.e.
-    /// the \c NodeMap, \c ArcMap and \c EdgeMap subtypes of digraph and
+    /// the \c NodeMap, \c ArcMap and \c EdgeMap subtypes of digraph and 
     /// graph types, which can be used for associating data to graph items.
     /// The standard graph maps must conform to the ReferenceMap concept.
@@ -1063,5 +1063,5 @@
           _Map m1(g);
           _Map m2(g,t);
-
+          
           // Copy constructor
           // _Map m3(m);
@@ -1087,5 +1087,5 @@
     ///
     /// This class describes the interface of mappable directed graphs.
-    /// It extends \ref BaseDigraphComponent with the standard digraph
+    /// It extends \ref BaseDigraphComponent with the standard digraph 
     /// map classes, namely \c NodeMap and \c ArcMap.
     /// This concept is part of the Digraph concept.
@@ -1225,5 +1225,5 @@
     ///
     /// This class describes the interface of mappable undirected graphs.
-    /// It extends \ref MappableDigraphComponent with the standard graph
+    /// It extends \ref MappableDigraphComponent with the standard graph 
     /// map class for edges (\c EdgeMap).
     /// This concept is part of the Graph concept.
@@ -1311,5 +1311,5 @@
     ///
     /// This class describes the interface of extendable directed graphs.
-    /// It extends \ref BaseDigraphComponent with functions for adding
+    /// It extends \ref BaseDigraphComponent with functions for adding 
     /// nodes and arcs to the digraph.
     /// This concept requires \ref AlterableDigraphComponent.
@@ -1356,5 +1356,5 @@
     ///
     /// This class describes the interface of extendable undirected graphs.
-    /// It extends \ref BaseGraphComponent with functions for adding
+    /// It extends \ref BaseGraphComponent with functions for adding 
     /// nodes and edges to the graph.
     /// This concept requires \ref AlterableGraphComponent.
@@ -1401,5 +1401,5 @@
     ///
     /// This class describes the interface of erasable directed graphs.
-    /// It extends \ref BaseDigraphComponent with functions for removing
+    /// It extends \ref BaseDigraphComponent with functions for removing 
     /// nodes and arcs from the digraph.
     /// This concept requires \ref AlterableDigraphComponent.
@@ -1414,5 +1414,5 @@
       /// \brief Erase a node from the digraph.
       ///
-      /// This function erases the given node from the digraph and all arcs
+      /// This function erases the given node from the digraph and all arcs 
       /// connected to the node.
       void erase(const Node&) {}
@@ -1441,5 +1441,5 @@
     ///
     /// This class describes the interface of erasable undirected graphs.
-    /// It extends \ref BaseGraphComponent with functions for removing
+    /// It extends \ref BaseGraphComponent with functions for removing 
     /// nodes and edges from the graph.
     /// This concept requires \ref AlterableGraphComponent.
Index: lemon/concepts/maps.h
===================================================================
--- lemon/concepts/maps.h	(revision 808)
+++ lemon/concepts/maps.h	(revision 807)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/connectivity.h
===================================================================
--- lemon/connectivity.h	(revision 761)
+++ lemon/connectivity.h	(revision 809)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -259,5 +259,5 @@
   /// \return \c true if the digraph is strongly connected.
   /// \note By definition, the empty digraph is strongly connected.
-  ///
+  /// 
   /// \see countStronglyConnectedComponents(), stronglyConnectedComponents()
   /// \see connected()
@@ -311,5 +311,5 @@
   /// \ingroup graph_properties
   ///
-  /// \brief Count the number of strongly connected components of a
+  /// \brief Count the number of strongly connected components of a 
   /// directed graph
   ///
@@ -746,5 +746,6 @@
   ///
   /// This function checks whether the given undirected graph is
-  /// bi-node-connected, i.e. any two edges are on same circle.
+  /// bi-node-connected, i.e. a connected graph without articulation
+  /// node.
   ///
   /// \return \c true if the graph bi-node-connected.
@@ -754,4 +755,20 @@
   template <typename Graph>
   bool biNodeConnected(const Graph& graph) {
+    bool hasNonIsolated = false, hasIsolated = false;
+    for (typename Graph::NodeIt n(graph); n != INVALID; ++n) {
+      if (typename Graph::OutArcIt(graph, n) == INVALID) {
+        if (hasIsolated || hasNonIsolated) {
+          return false;
+        } else {
+          hasIsolated = true;
+        }
+      } else {
+        if (hasIsolated) {
+          return false;
+        } else {
+          hasNonIsolated = true;
+        }
+      }
+    }
     return countBiNodeConnectedComponents(graph) <= 1;
   }
@@ -759,5 +776,5 @@
   /// \ingroup graph_properties
   ///
-  /// \brief Count the number of bi-node-connected components of an
+  /// \brief Count the number of bi-node-connected components of an 
   /// undirected graph.
   ///
@@ -813,5 +830,5 @@
   /// \retval compMap A writable edge map. The values will be set from 0
   /// to the number of the bi-node-connected components minus one. Each
-  /// value of the map will be set exactly once, and the values of a
+  /// value of the map will be set exactly once, and the values of a 
   /// certain component will be set continuously.
   /// \return The number of bi-node-connected components.
@@ -859,5 +876,5 @@
   ///
   /// \param graph The undirected graph.
-  /// \retval cutMap A writable node map. The values will be set to
+  /// \retval cutMap A writable node map. The values will be set to 
   /// \c true for the nodes that separate two or more components
   /// (exactly once for each cut node), and will not be changed for
@@ -1086,5 +1103,5 @@
   /// \brief Check whether an undirected graph is bi-edge-connected.
   ///
-  /// This function checks whether the given undirected graph is
+  /// This function checks whether the given undirected graph is 
   /// bi-edge-connected, i.e. any two nodes are connected with at least
   /// two edge-disjoint paths.
@@ -1193,5 +1210,5 @@
   ///
   /// This function finds the bi-edge-connected cut edges in the given
-  /// undirected graph.
+  /// undirected graph. 
   ///
   /// The bi-edge-connected components are the classes of an equivalence
@@ -1350,5 +1367,5 @@
   /// \param digraph The digraph.
   /// \retval order A readable and writable node map. The values will be
-  /// set from 0 to the number of the nodes in the digraph minus one.
+  /// set from 0 to the number of the nodes in the digraph minus one. 
   /// Each value of the map will be set exactly once, and the values will
   /// be set descending order.
Index: lemon/core.h
===================================================================
--- lemon/core.h	(revision 806)
+++ lemon/core.h	(revision 804)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -1253,6 +1253,5 @@
   protected:
 
-    class AutoNodeMap :
-      public ItemSetTraits<GR, Node>::template Map<Arc>::Type {
+    class AutoNodeMap : public ItemSetTraits<GR, Node>::template Map<Arc>::Type {
       typedef typename ItemSetTraits<GR, Node>::template Map<Arc>::Type Parent;
 
@@ -1293,5 +1292,5 @@
     };
 
-  protected:
+  protected: 
 
     const Digraph &_g;
Index: lemon/cplex.cc
===================================================================
--- lemon/cplex.cc	(revision 799)
+++ lemon/cplex.cc	(revision 798)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -456,5 +456,5 @@
 
   void CplexBase::_applyMessageLevel() {
-    CPXsetintparam(cplexEnv(), CPX_PARAM_SCRIND,
+    CPXsetintparam(cplexEnv(), CPX_PARAM_SCRIND, 
                    _message_enabled ? CPX_ON : CPX_OFF);
   }
Index: lemon/dfs.h
===================================================================
--- lemon/dfs.h	(revision 784)
+++ lemon/dfs.h	(revision 783)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/dimacs.h
===================================================================
--- lemon/dimacs.h	(revision 761)
+++ lemon/dimacs.h	(revision 576)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -62,5 +62,5 @@
 
   ///This function starts seeking the beginning of the given file for the
-  ///problem type and size info.
+  ///problem type and size info. 
   ///The found data is returned in a special struct that can be evaluated
   ///and passed to the appropriate reader function.
@@ -213,5 +213,5 @@
         std::numeric_limits<Capacity>::infinity() :
         std::numeric_limits<Capacity>::max();
-
+ 
     while (is >> c) {
       switch (c) {
@@ -238,5 +238,5 @@
           e = g.addArc(nodes[i], nodes[j]);
           capacity.set(e, _cap);
-        }
+        } 
         else if (desc.type==DimacsDescriptor::MAX) {
           is >> i >> j >> _cap;
@@ -363,9 +363,9 @@
     g.addArc(s,t);
   }
-
+  
   /// \brief DIMACS plain (di)graph reader function.
   ///
   /// This function reads a plain (di)graph without any designated nodes
-  /// and maps (e.g. a matching instance) from DIMACS format, i.e. from
+  /// and maps (e.g. a matching instance) from DIMACS format, i.e. from 
   /// DIMACS files having a line starting with
   /// \code
@@ -393,5 +393,5 @@
       nodes[k] = g.addNode();
     }
-
+    
     while (is >> c) {
       switch (c) {
Index: lemon/edge_set.h
===================================================================
--- lemon/edge_set.h	(revision 761)
+++ lemon/edge_set.h	(revision 669)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/euler.h
===================================================================
--- lemon/euler.h	(revision 761)
+++ lemon/euler.h	(revision 646)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -27,5 +27,5 @@
 /// \ingroup graph_properties
 /// \file
-/// \brief Euler tour iterators and a function for checking the \e Eulerian
+/// \brief Euler tour iterators and a function for checking the \e Eulerian 
 /// property.
 ///
@@ -42,5 +42,5 @@
   ///
   ///For example, if the given digraph has an Euler tour (i.e it has only one
-  ///non-trivial component and the in-degree is equal to the out-degree
+  ///non-trivial component and the in-degree is equal to the out-degree 
   ///for all nodes), then the following code will put the arcs of \c g
   ///to the vector \c et according to an Euler tour of \c g.
@@ -139,5 +139,5 @@
   ///and \c Edge types of the graph.
   ///
-  ///For example, if the given graph has an Euler tour (i.e it has only one
+  ///For example, if the given graph has an Euler tour (i.e it has only one 
   ///non-trivial component and the degree of each node is even),
   ///the following code will print the arc IDs according to an
@@ -148,5 +148,5 @@
   ///  }
   ///\endcode
-  ///Although this iterator is for undirected graphs, it still returns
+  ///Although this iterator is for undirected graphs, it still returns 
   ///arcs in order to indicate the direction of the tour.
   ///(But arcs convert to edges, of course.)
@@ -234,5 +234,5 @@
     /// Postfix incrementation.
     ///
-    ///\warning This incrementation returns an \c Arc (which converts to
+    ///\warning This incrementation returns an \c Arc (which converts to 
     ///an \c Edge), not an \ref EulerIt, as one may expect.
     Arc operator++(int)
Index: lemon/glpk.h
===================================================================
--- lemon/glpk.h	(revision 761)
+++ lemon/glpk.h	(revision 711)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -31,5 +31,5 @@
     class VoidPtr {
     private:
-      void *_ptr;
+      void *_ptr;      
     public:
       VoidPtr() : _ptr(0) {}
@@ -39,6 +39,6 @@
 
       template <typename T>
-      VoidPtr& operator=(T* ptr) {
-        _ptr = reinterpret_cast<void*>(ptr);
+      VoidPtr& operator=(T* ptr) { 
+        _ptr = reinterpret_cast<void*>(ptr); 
         return *this;
       }
@@ -124,11 +124,11 @@
       }
     };
-
+    
     static FreeEnvHelper freeEnvHelper;
 
   protected:
-
+    
     int _message_level;
-
+    
   public:
 
Index: lemon/gomory_hu.h
===================================================================
--- lemon/gomory_hu.h	(revision 761)
+++ lemon/gomory_hu.h	(revision 588)
@@ -1,7 +1,7 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
+/* -*- C++ -*-
  *
- * This file is a part of LEMON, a generic C++ optimization library.
+ * This file is a part of LEMON, a generic C++ optimization library
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -28,5 +28,5 @@
 
 /// \ingroup min_cut
-/// \file
+/// \file 
 /// \brief Gomory-Hu cut tree in graphs.
 
@@ -39,5 +39,5 @@
   /// The Gomory-Hu tree is a tree on the node set of a given graph, but it
   /// may contain edges which are not in the original graph. It has the
-  /// property that the minimum capacity edge of the path between two nodes
+  /// property that the minimum capacity edge of the path between two nodes 
   /// in this tree has the same weight as the minimum cut in the graph
   /// between these nodes. Moreover the components obtained by removing
@@ -45,5 +45,5 @@
   /// Therefore once this tree is computed, the minimum cut between any pair
   /// of nodes can easily be obtained.
-  ///
+  /// 
   /// The algorithm calculates \e n-1 distinct minimum cuts (currently with
   /// the \ref Preflow algorithm), thus it has \f$O(n^3\sqrt{e})\f$ overall
@@ -61,8 +61,8 @@
 #ifdef DOXYGEN
   template <typename GR,
-            typename CAP>
+	    typename CAP>
 #else
   template <typename GR,
-            typename CAP = typename GR::template EdgeMap<int> >
+	    typename CAP = typename GR::template EdgeMap<int> >
 #endif
   class GomoryHu {
@@ -75,5 +75,5 @@
     /// The value type of capacities
     typedef typename Capacity::Value Value;
-
+    
   private:
 
@@ -90,11 +90,11 @@
     void createStructures() {
       if (!_pred) {
-        _pred = new typename Graph::template NodeMap<Node>(_graph);
+	_pred = new typename Graph::template NodeMap<Node>(_graph);
       }
       if (!_weight) {
-        _weight = new typename Graph::template NodeMap<Value>(_graph);
+	_weight = new typename Graph::template NodeMap<Value>(_graph);
       }
       if (!_order) {
-        _order = new typename Graph::template NodeMap<int>(_graph);
+	_order = new typename Graph::template NodeMap<int>(_graph);
       }
     }
@@ -102,14 +102,14 @@
     void destroyStructures() {
       if (_pred) {
-        delete _pred;
+	delete _pred;
       }
       if (_weight) {
-        delete _weight;
+	delete _weight;
       }
       if (_order) {
-        delete _order;
-      }
-    }
-
+	delete _order;
+      }
+    }
+  
   public:
 
@@ -119,7 +119,7 @@
     /// \param graph The undirected graph the algorithm runs on.
     /// \param capacity The edge capacity map.
-    GomoryHu(const Graph& graph, const Capacity& capacity)
+    GomoryHu(const Graph& graph, const Capacity& capacity) 
       : _graph(graph), _capacity(capacity),
-        _pred(0), _weight(0), _order(0)
+	_pred(0), _weight(0), _order(0) 
     {
       checkConcept<concepts::ReadMap<Edge, Value>, Capacity>();
@@ -135,5 +135,5 @@
 
   private:
-
+  
     // Initialize the internal data structures
     void init() {
@@ -146,5 +146,5 @@
       }
       (*_pred)[_root] = INVALID;
-      (*_weight)[_root] = std::numeric_limits<Value>::max();
+      (*_weight)[_root] = std::numeric_limits<Value>::max(); 
     }
 
@@ -155,25 +155,25 @@
 
       for (NodeIt n(_graph); n != INVALID; ++n) {
-        if (n == _root) continue;
-
-        Node pn = (*_pred)[n];
-        fa.source(n);
-        fa.target(pn);
-
-        fa.runMinCut();
-
-        (*_weight)[n] = fa.flowValue();
-
-        for (NodeIt nn(_graph); nn != INVALID; ++nn) {
-          if (nn != n && fa.minCut(nn) && (*_pred)[nn] == pn) {
-            (*_pred)[nn] = n;
-          }
-        }
-        if ((*_pred)[pn] != INVALID && fa.minCut((*_pred)[pn])) {
-          (*_pred)[n] = (*_pred)[pn];
-          (*_pred)[pn] = n;
-          (*_weight)[n] = (*_weight)[pn];
-          (*_weight)[pn] = fa.flowValue();
-        }
+	if (n == _root) continue;
+
+	Node pn = (*_pred)[n];
+	fa.source(n);
+	fa.target(pn);
+
+	fa.runMinCut();
+
+	(*_weight)[n] = fa.flowValue();
+
+	for (NodeIt nn(_graph); nn != INVALID; ++nn) {
+	  if (nn != n && fa.minCut(nn) && (*_pred)[nn] == pn) {
+	    (*_pred)[nn] = n;
+	  }
+	}
+	if ((*_pred)[pn] != INVALID && fa.minCut((*_pred)[pn])) {
+	  (*_pred)[n] = (*_pred)[pn];
+	  (*_pred)[pn] = n;
+	  (*_weight)[n] = (*_weight)[pn];
+	  (*_weight)[pn] = fa.flowValue();
+	}
       }
 
@@ -182,14 +182,14 @@
 
       for (NodeIt n(_graph); n != INVALID; ++n) {
-        std::vector<Node> st;
-        Node nn = n;
-        while ((*_order)[nn] == -1) {
-          st.push_back(nn);
-          nn = (*_pred)[nn];
-        }
-        while (!st.empty()) {
-          (*_order)[st.back()] = index++;
-          st.pop_back();
-        }
+	std::vector<Node> st;
+	Node nn = n;
+	while ((*_order)[nn] == -1) {
+	  st.push_back(nn);
+	  nn = (*_pred)[nn];
+	}
+	while (!st.empty()) {
+	  (*_order)[st.back()] = index++;
+	  st.pop_back();
+	}
       }
     }
@@ -198,5 +198,5 @@
 
     ///\name Execution Control
-
+ 
     ///@{
 
@@ -208,5 +208,5 @@
       start();
     }
-
+    
     /// @}
 
@@ -233,5 +233,5 @@
     /// Gomory-Hu tree.
     ///
-    /// This function returns the weight of the predecessor edge of the
+    /// This function returns the weight of the predecessor edge of the 
     /// given node in the Gomory-Hu tree.
     /// If \c node is the root of the tree, the result is undefined.
@@ -255,5 +255,5 @@
     ///
     /// This function returns the minimum cut value between the nodes
-    /// \c s and \c t.
+    /// \c s and \c t. 
     /// It finds the nearest common ancestor of the given nodes in the
     /// Gomory-Hu tree and calculates the minimum weight edge on the
@@ -264,13 +264,13 @@
       Node sn = s, tn = t;
       Value value = std::numeric_limits<Value>::max();
-
+      
       while (sn != tn) {
-        if ((*_order)[sn] < (*_order)[tn]) {
-          if ((*_weight)[tn] <= value) value = (*_weight)[tn];
-          tn = (*_pred)[tn];
-        } else {
-          if ((*_weight)[sn] <= value) value = (*_weight)[sn];
-          sn = (*_pred)[sn];
-        }
+	if ((*_order)[sn] < (*_order)[tn]) {
+	  if ((*_weight)[tn] <= value) value = (*_weight)[tn];
+	  tn = (*_pred)[tn];
+	} else {
+	  if ((*_weight)[sn] <= value) value = (*_weight)[sn];
+	  sn = (*_pred)[sn];
+	}
       }
       return value;
@@ -295,9 +295,9 @@
     /// \pre \ref run() must be called before using this function.
     template <typename CutMap>
-    Value minCutMap(const Node& s, ///<
+    Value minCutMap(const Node& s, ///< 
                     const Node& t,
-                    ///<
+                    ///< 
                     CutMap& cutMap
-                    ///<
+                    ///< 
                     ) const {
       Node sn = s, tn = t;
@@ -305,21 +305,21 @@
       Node rn = INVALID;
       Value value = std::numeric_limits<Value>::max();
-
+      
       while (sn != tn) {
-        if ((*_order)[sn] < (*_order)[tn]) {
-          if ((*_weight)[tn] <= value) {
-            rn = tn;
+	if ((*_order)[sn] < (*_order)[tn]) {
+	  if ((*_weight)[tn] <= value) {
+	    rn = tn;
             s_root = false;
-            value = (*_weight)[tn];
-          }
-          tn = (*_pred)[tn];
-        } else {
-          if ((*_weight)[sn] <= value) {
-            rn = sn;
+	    value = (*_weight)[tn];
+	  }
+	  tn = (*_pred)[tn];
+	} else {
+	  if ((*_weight)[sn] <= value) {
+	    rn = sn;
             s_root = true;
-            value = (*_weight)[sn];
-          }
-          sn = (*_pred)[sn];
-        }
+	    value = (*_weight)[sn];
+	  }
+	  sn = (*_pred)[sn];
+	}
       }
 
@@ -332,16 +332,16 @@
       std::vector<Node> st;
       for (NodeIt n(_graph); n != INVALID; ++n) {
-        st.clear();
+	st.clear();
         Node nn = n;
-        while (!reached[nn]) {
-          st.push_back(nn);
-          nn = (*_pred)[nn];
-        }
-        while (!st.empty()) {
-          cutMap.set(st.back(), cutMap[nn]);
-          st.pop_back();
-        }
-      }
-
+	while (!reached[nn]) {
+	  st.push_back(nn);
+	  nn = (*_pred)[nn];
+	}
+	while (!st.empty()) {
+	  cutMap.set(st.back(), cutMap[nn]);
+	  st.pop_back();
+	}
+      }
+      
       return value;
     }
@@ -352,5 +352,5 @@
 
     /// Iterate on the nodes of a minimum cut
-
+    
     /// This iterator class lists the nodes of a minimum cut found by
     /// GomoryHu. Before using it, you must allocate a GomoryHu class
@@ -445,9 +445,9 @@
       }
     };
-
+    
     friend class MinCutEdgeIt;
-
+    
     /// Iterate on the edges of a minimum cut
-
+    
     /// This iterator class lists the edges of a minimum cut found by
     /// GomoryHu. Before using it, you must allocate a GomoryHu class
@@ -482,5 +482,5 @@
           }
       }
-
+      
     public:
       /// Constructor
@@ -551,5 +551,5 @@
       }
       /// Postfix incrementation
-
+      
       /// Postfix incrementation.
       ///
Index: lemon/graph_to_eps.h
===================================================================
--- lemon/graph_to_eps.h	(revision 806)
+++ lemon/graph_to_eps.h	(revision 805)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/hao_orlin.h
===================================================================
--- lemon/hao_orlin.h	(revision 761)
+++ lemon/hao_orlin.h	(revision 589)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -32,5 +32,5 @@
 /// \brief Implementation of the Hao-Orlin algorithm.
 ///
-/// Implementation of the Hao-Orlin algorithm for finding a minimum cut
+/// Implementation of the Hao-Orlin algorithm for finding a minimum cut 
 /// in a digraph.
 
@@ -42,5 +42,5 @@
   ///
   /// This class implements the Hao-Orlin algorithm for finding a minimum
-  /// value cut in a directed graph \f$D=(V,A)\f$.
+  /// value cut in a directed graph \f$D=(V,A)\f$. 
   /// It takes a fixed node \f$ source \in V \f$ and
   /// consists of two phases: in the first phase it determines a
@@ -59,5 +59,5 @@
   /// For an undirected graph you can run just the first phase of the
   /// algorithm or you can use the algorithm of Nagamochi and Ibaraki,
-  /// which solves the undirected problem in \f$ O(nm + n^2 \log n) \f$
+  /// which solves the undirected problem in \f$ O(nm + n^2 \log n) \f$ 
   /// time. It is implemented in the NagamochiIbaraki algorithm class.
   ///
@@ -77,5 +77,5 @@
   class HaoOrlin {
   public:
-
+   
     /// The digraph type of the algorithm
     typedef GR Digraph;
@@ -848,5 +848,5 @@
     ///
     /// This function initializes the internal data structures. It creates
-    /// the maps and some bucket structures for the algorithm.
+    /// the maps and some bucket structures for the algorithm. 
     /// The given node is used as the source node for the push-relabel
     /// algorithm.
@@ -928,5 +928,5 @@
     /// \brief Run the algorithm.
     ///
-    /// This function runs the algorithm. It uses the given \c source node,
+    /// This function runs the algorithm. It uses the given \c source node, 
     /// finds a proper \c target node and then calls the \ref init(),
     /// \ref calculateOut() and \ref calculateIn().
@@ -942,5 +942,5 @@
     /// The result of the %HaoOrlin algorithm
     /// can be obtained using these functions.\n
-    /// \ref run(), \ref calculateOut() or \ref calculateIn()
+    /// \ref run(), \ref calculateOut() or \ref calculateIn() 
     /// should be called before using them.
 
@@ -951,5 +951,5 @@
     /// This function returns the value of the minimum cut.
     ///
-    /// \pre \ref run(), \ref calculateOut() or \ref calculateIn()
+    /// \pre \ref run(), \ref calculateOut() or \ref calculateIn() 
     /// must be called before using this function.
     Value minCutValue() const {
@@ -970,5 +970,5 @@
     /// \return The value of the minimum cut.
     ///
-    /// \pre \ref run(), \ref calculateOut() or \ref calculateIn()
+    /// \pre \ref run(), \ref calculateOut() or \ref calculateIn() 
     /// must be called before using this function.
     template <typename CutMap>
Index: lemon/lgf_reader.h
===================================================================
--- lemon/lgf_reader.h	(revision 761)
+++ lemon/lgf_reader.h	(revision 757)
@@ -563,5 +563,5 @@
     friend DigraphReader<TDGR> digraphReader(TDGR& digraph, std::istream& is);
     template <typename TDGR>
-    friend DigraphReader<TDGR> digraphReader(TDGR& digraph,
+    friend DigraphReader<TDGR> digraphReader(TDGR& digraph, 
                                              const std::string& fn);
     template <typename TDGR>
@@ -1195,5 +1195,5 @@
 
   };
-
+  
   /// \ingroup lemon_io
   ///
@@ -1202,5 +1202,5 @@
   /// This function just returns a \ref DigraphReader class.
   ///
-  /// With this function a digraph can be read from an
+  /// With this function a digraph can be read from an 
   /// \ref lgf-format "LGF" file or input stream with several maps and
   /// attributes. For example, there is network flow problem on a
@@ -1257,5 +1257,5 @@
   template <typename GR>
   class GraphReader;
-
+ 
   template <typename TGR>
   GraphReader<TGR> graphReader(TGR& graph, std::istream& is = std::cin);
@@ -1394,5 +1394,5 @@
     friend GraphReader<TGR> graphReader(TGR& graph, std::istream& is);
     template <typename TGR>
-    friend GraphReader<TGR> graphReader(TGR& graph, const std::string& fn);
+    friend GraphReader<TGR> graphReader(TGR& graph, const std::string& fn); 
     template <typename TGR>
     friend GraphReader<TGR> graphReader(TGR& graph, const char *fn);
@@ -2078,7 +2078,7 @@
   /// \brief Return a \ref GraphReader class
   ///
-  /// This function just returns a \ref GraphReader class.
-  ///
-  /// With this function a graph can be read from an
+  /// This function just returns a \ref GraphReader class. 
+  ///
+  /// With this function a graph can be read from an 
   /// \ref lgf-format "LGF" file or input stream with several maps and
   /// attributes. For example, there is weighted matching problem on a
Index: lemon/lgf_writer.h
===================================================================
--- lemon/lgf_writer.h	(revision 761)
+++ lemon/lgf_writer.h	(revision 591)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -352,5 +352,5 @@
 
   template <typename TDGR>
-  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
+  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph, 
                                    std::ostream& os = std::cout);
   template <typename TDGR>
@@ -505,5 +505,5 @@
 
     template <typename TDGR>
-    friend DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
+    friend DigraphWriter<TDGR> digraphWriter(const TDGR& digraph, 
                                              std::ostream& os);
     template <typename TDGR>
@@ -918,5 +918,5 @@
   /// \brief Return a \ref DigraphWriter class
   ///
-  /// This function just returns a \ref DigraphWriter class.
+  /// This function just returns a \ref DigraphWriter class. 
   ///
   /// With this function a digraph can be write to a file or output
@@ -958,5 +958,5 @@
   /// \sa digraphWriter(const TDGR& digraph, std::ostream& os)
   template <typename TDGR>
-  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
+  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph, 
                                     const std::string& fn) {
     DigraphWriter<TDGR> tmp(digraph, fn);
@@ -1102,9 +1102,9 @@
     friend GraphWriter<TGR> graphWriter(const TGR& graph, std::ostream& os);
     template <typename TGR>
-    friend GraphWriter<TGR> graphWriter(const TGR& graph,
+    friend GraphWriter<TGR> graphWriter(const TGR& graph, 
                                         const std::string& fn);
     template <typename TGR>
     friend GraphWriter<TGR> graphWriter(const TGR& graph, const char *fn);
-
+    
     GraphWriter(GraphWriter& other)
       : _os(other._os), local_os(other.local_os), _graph(other._graph),
@@ -1557,5 +1557,5 @@
   /// \brief Return a \ref GraphWriter class
   ///
-  /// This function just returns a \ref GraphWriter class.
+  /// This function just returns a \ref GraphWriter class. 
   ///
   /// With this function a graph can be write to a file or output
Index: lemon/lp.h
===================================================================
--- lemon/lp.h	(revision 761)
+++ lemon/lp.h	(revision 622)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -85,5 +85,5 @@
 #elif LEMON_HAVE_CLP
 # define DEFAULT_LP CLP
-  typedef ClpLp Lp;
+  typedef ClpLp Lp;  
 #endif
 #endif
Index: lemon/lp_base.cc
===================================================================
--- lemon/lp_base.cc	(revision 761)
+++ lemon/lp_base.cc	(revision 486)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/lp_base.h
===================================================================
--- lemon/lp_base.h	(revision 786)
+++ lemon/lp_base.h	(revision 785)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -83,5 +83,5 @@
       MESSAGE_VERBOSE
     };
-
+    
 
     ///The floating point type used by the solver
@@ -115,12 +115,12 @@
       typedef True LpCol;
       /// Default constructor
-
+      
       /// \warning The default constructor sets the Col to an
       /// undefined value.
       Col() {}
       /// Invalid constructor \& conversion.
-
+      
       /// This constructor initializes the Col to be invalid.
-      /// \sa Invalid for more details.
+      /// \sa Invalid for more details.      
       Col(const Invalid&) : _id(-1) {}
       /// Equality operator
@@ -157,10 +157,10 @@
     public:
       /// Default constructor
-
+      
       /// \warning The default constructor sets the iterator
       /// to an undefined value.
       ColIt() {}
       /// Sets the iterator to the first Col
-
+      
       /// Sets the iterator to the first Col.
       ///
@@ -170,10 +170,10 @@
       }
       /// Invalid constructor \& conversion
-
+      
       /// Initialize the iterator to be invalid.
       /// \sa Invalid for more details.
       ColIt(const Invalid&) : Col(INVALID) {}
       /// Next column
-
+      
       /// Assign the iterator to the next column.
       ///
@@ -210,12 +210,12 @@
       typedef True LpRow;
       /// Default constructor
-
+      
       /// \warning The default constructor sets the Row to an
       /// undefined value.
       Row() {}
       /// Invalid constructor \& conversion.
-
+      
       /// This constructor initializes the Row to be invalid.
-      /// \sa Invalid for more details.
+      /// \sa Invalid for more details.      
       Row(const Invalid&) : _id(-1) {}
       /// Equality operator
@@ -225,5 +225,5 @@
       bool operator==(Row r) const  {return _id == r._id;}
       /// Inequality operator
-
+      
       /// \sa operator==(Row r)
       ///
@@ -252,10 +252,10 @@
     public:
       /// Default constructor
-
+      
       /// \warning The default constructor sets the iterator
       /// to an undefined value.
       RowIt() {}
       /// Sets the iterator to the first Row
-
+      
       /// Sets the iterator to the first Row.
       ///
@@ -265,10 +265,10 @@
       }
       /// Invalid constructor \& conversion
-
+      
       /// Initialize the iterator to be invalid.
       /// \sa Invalid for more details.
       RowIt(const Invalid&) : Row(INVALID) {}
       /// Next row
-
+      
       /// Assign the iterator to the next row.
       ///
@@ -348,5 +348,5 @@
       typedef True SolverExpr;
       /// Default constructor
-
+      
       /// Construct an empty expression, the coefficients and
       /// the constant component are initialized to zero.
@@ -449,7 +449,7 @@
 
       ///Iterator over the expression
-
-      ///The iterator iterates over the terms of the expression.
-      ///
+      
+      ///The iterator iterates over the terms of the expression. 
+      /// 
       ///\code
       ///double s=0;
@@ -465,5 +465,5 @@
 
         /// Sets the iterator to the first term
-
+        
         /// Sets the iterator to the first term of the expression.
         ///
@@ -482,5 +482,5 @@
         const Value& operator*() const { return _it->second; }
         /// Next term
-
+        
         /// Assign the iterator to the next term.
         ///
@@ -494,7 +494,7 @@
 
       /// Const iterator over the expression
-
-      ///The iterator iterates over the terms of the expression.
-      ///
+      
+      ///The iterator iterates over the terms of the expression. 
+      /// 
       ///\code
       ///double s=0;
@@ -510,5 +510,5 @@
 
         /// Sets the iterator to the first term
-
+        
         /// Sets the iterator to the first term of the expression.
         ///
@@ -525,5 +525,5 @@
 
         /// Next term
-
+        
         /// Assign the iterator to the next term.
         ///
@@ -674,5 +674,5 @@
       typedef True SolverExpr;
       /// Default constructor
-
+      
       /// Construct an empty expression, the coefficients are
       /// initialized to zero.
@@ -709,5 +709,5 @@
       }
       /// \brief Removes the coefficients which's absolute value does
-      /// not exceed \c epsilon.
+      /// not exceed \c epsilon. 
       void simplify(Value epsilon = 0.0) {
         std::map<int, Value>::iterator it=comps.begin();
@@ -758,7 +758,7 @@
 
       ///Iterator over the expression
-
-      ///The iterator iterates over the terms of the expression.
-      ///
+      
+      ///The iterator iterates over the terms of the expression. 
+      /// 
       ///\code
       ///double s=0;
@@ -774,5 +774,5 @@
 
         /// Sets the iterator to the first term
-
+        
         /// Sets the iterator to the first term of the expression.
         ///
@@ -792,5 +792,5 @@
 
         /// Next term
-
+        
         /// Assign the iterator to the next term.
         ///
@@ -804,7 +804,7 @@
 
       ///Iterator over the expression
-
-      ///The iterator iterates over the terms of the expression.
-      ///
+      
+      ///The iterator iterates over the terms of the expression. 
+      /// 
       ///\code
       ///double s=0;
@@ -820,5 +820,5 @@
 
         /// Sets the iterator to the first term
-
+        
         /// Sets the iterator to the first term of the expression.
         ///
@@ -835,5 +835,5 @@
 
         /// Next term
-
+        
         /// Assign the iterator to the next term.
         ///
@@ -1804,8 +1804,8 @@
     enum VarStatus {
       /// The variable is in the basis
-      BASIC,
+      BASIC, 
       /// The variable is free, but not basic
       FREE,
-      /// The variable has active lower bound
+      /// The variable has active lower bound 
       LOWER,
       /// The variable has active upper bound
@@ -1886,5 +1886,5 @@
     }
     /// Returns a component of the primal ray
-
+    
     /// The primal ray is solution of the modified primal problem,
     /// where we change each finite bound to 0, and we looking for a
@@ -1920,5 +1920,5 @@
 
     /// Returns a component of the dual ray
-
+    
     /// The dual ray is solution of the modified primal problem, where
     /// we change each finite bound to 0 (i.e. the objective function
@@ -2062,5 +2062,5 @@
     }
     ///The value of the objective function
-
+    
     ///\return
     ///- \ref INF or -\ref INF means either infeasibility or unboundedness
Index: lemon/lp_skeleton.cc
===================================================================
--- lemon/lp_skeleton.cc	(revision 761)
+++ lemon/lp_skeleton.cc	(revision 568)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/lp_skeleton.h
===================================================================
--- lemon/lp_skeleton.h	(revision 761)
+++ lemon/lp_skeleton.h	(revision 568)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -24,5 +24,5 @@
 ///\file
 ///\brief Skeleton file to implement LP/MIP solver interfaces
-///
+///  
 ///The classes in this file do nothing, but they can serve as skeletons when
 ///implementing an interface to new solvers.
@@ -30,5 +30,5 @@
 
   ///A skeleton class to implement LP/MIP solver base interface
-
+  
   ///This class does nothing, but it can serve as a skeleton when
   ///implementing an interface to new solvers.
Index: lemon/maps.h
===================================================================
--- lemon/maps.h	(revision 761)
+++ lemon/maps.h	(revision 684)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -1819,5 +1819,5 @@
   ///
   /// IdMap provides a unique and immutable id for each item of the
-  /// same type (\c Node, \c Arc or \c Edge) in a graph. This id is
+  /// same type (\c Node, \c Arc or \c Edge) in a graph. This id is 
   ///  - \b unique: different items get different ids,
   ///  - \b immutable: the id of an item does not change (even if you
@@ -2274,5 +2274,5 @@
 
     /// \brief Gives back the item belonging to a \e RangeId
-    ///
+    /// 
     /// Gives back the item belonging to a \e RangeId.
     Item operator()(int id) const {
@@ -2500,5 +2500,5 @@
   /// whenever the digraph changes.
   ///
-  /// \warning Besides \c addNode() and \c addArc(), a digraph structure
+  /// \warning Besides \c addNode() and \c addArc(), a digraph structure 
   /// may provide alternative ways to modify the digraph.
   /// The correct behavior of InDegMap is not guarantied if these additional
@@ -2516,5 +2516,5 @@
 
   public:
-
+    
     /// The graph type of InDegMap
     typedef GR Graph;
@@ -2630,5 +2630,5 @@
   /// whenever the digraph changes.
   ///
-  /// \warning Besides \c addNode() and \c addArc(), a digraph structure
+  /// \warning Besides \c addNode() and \c addArc(), a digraph structure 
   /// may provide alternative ways to modify the digraph.
   /// The correct behavior of OutDegMap is not guarantied if these additional
Index: lemon/matching.h
===================================================================
--- lemon/matching.h	(revision 761)
+++ lemon/matching.h	(revision 722)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -42,5 +42,5 @@
   /// This class implements Edmonds' alternating forest matching algorithm
   /// for finding a maximum cardinality matching in a general undirected graph.
-  /// It can be started from an arbitrary initial matching
+  /// It can be started from an arbitrary initial matching 
   /// (the default is the empty one).
   ///
@@ -70,9 +70,9 @@
     ///\brief Status constants for Gallai-Edmonds decomposition.
     ///
-    ///These constants are used for indicating the Gallai-Edmonds
+    ///These constants are used for indicating the Gallai-Edmonds 
     ///decomposition of a graph. The nodes with status \c EVEN (or \c D)
     ///induce a subgraph with factor-critical components, the nodes with
     ///status \c ODD (or \c A) form the canonical barrier, and the nodes
-    ///with status \c MATCHED (or \c C) induce a subgraph having a
+    ///with status \c MATCHED (or \c C) induce a subgraph having a 
     ///perfect matching.
     enum Status {
@@ -513,5 +513,5 @@
     }
 
-    /// \brief Start Edmonds' algorithm with a heuristic improvement
+    /// \brief Start Edmonds' algorithm with a heuristic improvement 
     /// for dense graphs
     ///
@@ -535,6 +535,6 @@
     /// \brief Run Edmonds' algorithm
     ///
-    /// This function runs Edmonds' algorithm. An additional heuristic of
-    /// postponing shrinks is used for relatively dense graphs
+    /// This function runs Edmonds' algorithm. An additional heuristic of 
+    /// postponing shrinks is used for relatively dense graphs 
     /// (for which <tt>m>=2*n</tt> holds).
     void run() {
@@ -557,5 +557,5 @@
     /// \brief Return the size (cardinality) of the matching.
     ///
-    /// This function returns the size (cardinality) of the current matching.
+    /// This function returns the size (cardinality) of the current matching. 
     /// After run() it returns the size of the maximum matching in the graph.
     int matchingSize() const {
@@ -571,5 +571,5 @@
     /// \brief Return \c true if the given edge is in the matching.
     ///
-    /// This function returns \c true if the given edge is in the current
+    /// This function returns \c true if the given edge is in the current 
     /// matching.
     bool matching(const Edge& edge) const {
@@ -580,5 +580,5 @@
     ///
     /// This function returns the matching arc (or edge) incident to the
-    /// given node in the current matching or \c INVALID if the node is
+    /// given node in the current matching or \c INVALID if the node is 
     /// not covered by the matching.
     Arc matching(const Node& n) const {
@@ -596,5 +596,5 @@
     /// \brief Return the mate of the given node.
     ///
-    /// This function returns the mate of the given node in the current
+    /// This function returns the mate of the given node in the current 
     /// matching or \c INVALID if the node is not covered by the matching.
     Node mate(const Node& n) const {
@@ -606,5 +606,5 @@
 
     /// \name Dual Solution
-    /// Functions to get the dual solution, i.e. the Gallai-Edmonds
+    /// Functions to get the dual solution, i.e. the Gallai-Edmonds 
     /// decomposition.
 
@@ -649,6 +649,6 @@
   /// \f$O(nm\log n)\f$ time complexity.
   ///
-  /// The maximum weighted matching problem is to find a subset of the
-  /// edges in an undirected graph with maximum overall weight for which
+  /// The maximum weighted matching problem is to find a subset of the 
+  /// edges in an undirected graph with maximum overall weight for which 
   /// each node has at most one incident edge.
   /// It can be formulated with the following linear program.
@@ -674,14 +674,14 @@
       \frac{\vert B \vert - 1}{2}z_B\f] */
   ///
-  /// The algorithm can be executed with the run() function.
+  /// The algorithm can be executed with the run() function. 
   /// After it the matching (the primal solution) and the dual solution
-  /// can be obtained using the query functions and the
-  /// \ref MaxWeightedMatching::BlossomIt "BlossomIt" nested class,
-  /// which is able to iterate on the nodes of a blossom.
+  /// can be obtained using the query functions and the 
+  /// \ref MaxWeightedMatching::BlossomIt "BlossomIt" nested class, 
+  /// which is able to iterate on the nodes of a blossom. 
   /// If the value type is integer, then the dual solution is multiplied
   /// by \ref MaxWeightedMatching::dualScale "4".
   ///
   /// \tparam GR The undirected graph type the algorithm runs on.
-  /// \tparam WM The type edge weight map. The default type is
+  /// \tparam WM The type edge weight map. The default type is 
   /// \ref concepts::Graph::EdgeMap "GR::EdgeMap<int>".
 #ifdef DOXYGEN
@@ -1721,5 +1721,5 @@
         (*_delta4_index)[i] = _delta4->PRE_HEAP;
       }
-
+      
       _delta1->clear();
       _delta2->clear();
@@ -1869,5 +1869,5 @@
 
     /// \name Primal Solution
-    /// Functions to get the primal solution, i.e. the maximum weighted
+    /// Functions to get the primal solution, i.e. the maximum weighted 
     /// matching.\n
     /// Either \ref run() or \ref start() function should be called before
@@ -1908,5 +1908,5 @@
     /// \brief Return \c true if the given edge is in the matching.
     ///
-    /// This function returns \c true if the given edge is in the found
+    /// This function returns \c true if the given edge is in the found 
     /// matching.
     ///
@@ -1919,5 +1919,5 @@
     ///
     /// This function returns the matching arc (or edge) incident to the
-    /// given node in the found matching or \c INVALID if the node is
+    /// given node in the found matching or \c INVALID if the node is 
     /// not covered by the matching.
     ///
@@ -1937,5 +1937,5 @@
     /// \brief Return the mate of the given node.
     ///
-    /// This function returns the mate of the given node in the found
+    /// This function returns the mate of the given node in the found 
     /// matching or \c INVALID if the node is not covered by the matching.
     ///
@@ -1957,6 +1957,6 @@
     /// \brief Return the value of the dual solution.
     ///
-    /// This function returns the value of the dual solution.
-    /// It should be equal to the primal value scaled by \ref dualScale
+    /// This function returns the value of the dual solution. 
+    /// It should be equal to the primal value scaled by \ref dualScale 
     /// "dual scale".
     ///
@@ -2013,7 +2013,7 @@
     /// \brief Iterator for obtaining the nodes of a blossom.
     ///
-    /// This class provides an iterator for obtaining the nodes of the
+    /// This class provides an iterator for obtaining the nodes of the 
     /// given blossom. It lists a subset of the nodes.
-    /// Before using this iterator, you must allocate a
+    /// Before using this iterator, you must allocate a 
     /// MaxWeightedMatching class and execute it.
     class BlossomIt {
@@ -2024,6 +2024,6 @@
       /// Constructor to get the nodes of the given variable.
       ///
-      /// \pre Either \ref MaxWeightedMatching::run() "algorithm.run()" or
-      /// \ref MaxWeightedMatching::start() "algorithm.start()" must be
+      /// \pre Either \ref MaxWeightedMatching::run() "algorithm.run()" or 
+      /// \ref MaxWeightedMatching::start() "algorithm.start()" must be 
       /// called before initializing this iterator.
       BlossomIt(const MaxWeightedMatching& algorithm, int variable)
@@ -2078,6 +2078,6 @@
   /// \f$O(nm\log n)\f$ time complexity.
   ///
-  /// The maximum weighted perfect matching problem is to find a subset of
-  /// the edges in an undirected graph with maximum overall weight for which
+  /// The maximum weighted perfect matching problem is to find a subset of 
+  /// the edges in an undirected graph with maximum overall weight for which 
   /// each node has exactly one incident edge.
   /// It can be formulated with the following linear program.
@@ -2102,14 +2102,14 @@
       \frac{\vert B \vert - 1}{2}z_B\f] */
   ///
-  /// The algorithm can be executed with the run() function.
+  /// The algorithm can be executed with the run() function. 
   /// After it the matching (the primal solution) and the dual solution
-  /// can be obtained using the query functions and the
-  /// \ref MaxWeightedPerfectMatching::BlossomIt "BlossomIt" nested class,
-  /// which is able to iterate on the nodes of a blossom.
+  /// can be obtained using the query functions and the 
+  /// \ref MaxWeightedPerfectMatching::BlossomIt "BlossomIt" nested class, 
+  /// which is able to iterate on the nodes of a blossom. 
   /// If the value type is integer, then the dual solution is multiplied
   /// by \ref MaxWeightedMatching::dualScale "4".
   ///
   /// \tparam GR The undirected graph type the algorithm runs on.
-  /// \tparam WM The type edge weight map. The default type is
+  /// \tparam WM The type edge weight map. The default type is 
   /// \ref concepts::Graph::EdgeMap "GR::EdgeMap<int>".
 #ifdef DOXYGEN
@@ -3116,5 +3116,5 @@
 
     /// \name Primal Solution
-    /// Functions to get the primal solution, i.e. the maximum weighted
+    /// Functions to get the primal solution, i.e. the maximum weighted 
     /// perfect matching.\n
     /// Either \ref run() or \ref start() function should be called before
@@ -3140,5 +3140,5 @@
     /// \brief Return \c true if the given edge is in the matching.
     ///
-    /// This function returns \c true if the given edge is in the found
+    /// This function returns \c true if the given edge is in the found 
     /// matching.
     ///
@@ -3151,5 +3151,5 @@
     ///
     /// This function returns the matching arc (or edge) incident to the
-    /// given node in the found matching or \c INVALID if the node is
+    /// given node in the found matching or \c INVALID if the node is 
     /// not covered by the matching.
     ///
@@ -3169,5 +3169,5 @@
     /// \brief Return the mate of the given node.
     ///
-    /// This function returns the mate of the given node in the found
+    /// This function returns the mate of the given node in the found 
     /// matching or \c INVALID if the node is not covered by the matching.
     ///
@@ -3188,6 +3188,6 @@
     /// \brief Return the value of the dual solution.
     ///
-    /// This function returns the value of the dual solution.
-    /// It should be equal to the primal value scaled by \ref dualScale
+    /// This function returns the value of the dual solution. 
+    /// It should be equal to the primal value scaled by \ref dualScale 
     /// "dual scale".
     ///
@@ -3244,7 +3244,7 @@
     /// \brief Iterator for obtaining the nodes of a blossom.
     ///
-    /// This class provides an iterator for obtaining the nodes of the
+    /// This class provides an iterator for obtaining the nodes of the 
     /// given blossom. It lists a subset of the nodes.
-    /// Before using this iterator, you must allocate a
+    /// Before using this iterator, you must allocate a 
     /// MaxWeightedPerfectMatching class and execute it.
     class BlossomIt {
@@ -3255,6 +3255,6 @@
       /// Constructor to get the nodes of the given variable.
       ///
-      /// \pre Either \ref MaxWeightedPerfectMatching::run() "algorithm.run()"
-      /// or \ref MaxWeightedPerfectMatching::start() "algorithm.start()"
+      /// \pre Either \ref MaxWeightedPerfectMatching::run() "algorithm.run()" 
+      /// or \ref MaxWeightedPerfectMatching::start() "algorithm.start()" 
       /// must be called before initializing this iterator.
       BlossomIt(const MaxWeightedPerfectMatching& algorithm, int variable)
Index: lemon/math.h
===================================================================
--- lemon/math.h	(revision 761)
+++ lemon/math.h	(revision 487)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -57,5 +57,5 @@
 
   ///Check whether the parameter is NaN or not
-
+  
   ///This function checks whether the parameter is NaN or not.
   ///Is should be equivalent with std::isnan(), but it is not
Index: lemon/min_cost_arborescence.h
===================================================================
--- lemon/min_cost_arborescence.h	(revision 761)
+++ lemon/min_cost_arborescence.h	(revision 617)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -128,6 +128,6 @@
   public:
 
-    /// \brief The \ref MinCostArborescenceDefaultTraits "traits class"
-    /// of the algorithm.
+    /// \brief The \ref MinCostArborescenceDefaultTraits "traits class" 
+    /// of the algorithm. 
     typedef TR Traits;
     /// The type of the underlying digraph.
@@ -436,5 +436,5 @@
     /// \ref named-templ-param "Named parameter" for setting
     /// \c PredMap type.
-    /// It must meet the \ref concepts::WriteMap "WriteMap" concept,
+    /// It must meet the \ref concepts::WriteMap "WriteMap" concept, 
     /// and its value type must be the \c Arc type of the digraph.
     template <class T>
Index: lemon/network_simplex.h
===================================================================
--- lemon/network_simplex.h	(revision 761)
+++ lemon/network_simplex.h	(revision 729)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -96,5 +96,5 @@
       UNBOUNDED
     };
-
+    
     /// \brief Constants for selecting the type of the supply constraints.
     ///
@@ -114,5 +114,5 @@
       LEQ
     };
-
+    
     /// \brief Constants for selecting the pivot rule.
     ///
@@ -157,5 +157,5 @@
       ALTERING_LIST
     };
-
+    
   private:
 
@@ -224,5 +224,5 @@
 
   public:
-
+  
     /// \brief Constant for infinite upper bounds (capacities).
     ///
@@ -645,5 +645,5 @@
       LEMON_ASSERT(std::numeric_limits<Cost>::is_signed,
         "The cost type of NetworkSimplex must be signed");
-
+        
       // Resize vectors
       _node_num = countNodes(_graph);
@@ -685,5 +685,5 @@
         if ((i += k) >= _arc_num) i = (i % k) + 1;
       }
-
+      
       // Initialize maps
       for (int i = 0; i != _node_num; ++i) {
@@ -810,5 +810,5 @@
       return *this;
     }
-
+    
     /// \brief Set the type of the supply constraints.
     ///
@@ -836,5 +836,5 @@
     /// This function runs the algorithm.
     /// The paramters can be specified using functions \ref lowerMap(),
-    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply(),
+    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply(), 
     /// \ref supplyType().
     /// For example,
@@ -1055,5 +1055,5 @@
         _state[i] = STATE_LOWER;
       }
-
+      
       // Set data for the artificial root node
       _root = _node_num;
@@ -1229,5 +1229,5 @@
       for (int u = second; u != join; u = _parent[u]) {
         e = _pred[u];
-        d = _forward[u] ?
+        d = _forward[u] ? 
           (_cap[e] == INF ? INF : _cap[e] - _flow[e]) : _flow[e];
         if (d <= delta) {
@@ -1436,5 +1436,5 @@
         }
       }
-
+      
       // Check feasibility
       for (int e = _search_arc_num; e != _all_arc_num; ++e) {
@@ -1453,5 +1453,5 @@
         }
       }
-
+      
       // Shift potentials to meet the requirements of the GEQ/LEQ type
       // optimality conditions
Index: lemon/path.h
===================================================================
--- lemon/path.h	(revision 788)
+++ lemon/path.h	(revision 787)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -1019,5 +1019,5 @@
     };
 
-
+    
     template <typename From, typename To,
               bool revEnable = RevPathTagIndicator<From>::value>
@@ -1025,5 +1025,5 @@
       static void copy(const From& from, To& to) {
         PathCopySelectorForward<From, To>::copy(from, to);
-      }
+      }      
     };
 
@@ -1032,5 +1032,5 @@
       static void copy(const From& from, To& to) {
         PathCopySelectorBackward<From, To>::copy(from, to);
-      }
+      }      
     };
 
Index: lemon/preflow.h
===================================================================
--- lemon/preflow.h	(revision 761)
+++ lemon/preflow.h	(revision 739)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -537,8 +537,8 @@
         }
       }
-      for (NodeIt n(_graph); n != INVALID; ++n)
+      for (NodeIt n(_graph); n != INVALID; ++n) 
         if(n!=_source && n!=_target && _tolerance.positive((*_excess)[n]))
           _level->activate(n);
-
+          
       return true;
     }
@@ -568,5 +568,5 @@
           level = _level->highestActiveLevel();
           --num;
-
+          
           Value excess = (*_excess)[n];
           int new_level = _level->maxLevel();
Index: lemon/soplex.cc
===================================================================
--- lemon/soplex.cc	(revision 761)
+++ lemon/soplex.cc	(revision 568)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -275,5 +275,5 @@
 
     _clear_temporals();
-
+    
     _applyMessageLevel();
 
Index: lemon/soplex.h
===================================================================
--- lemon/soplex.h	(revision 761)
+++ lemon/soplex.h	(revision 568)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/suurballe.h
===================================================================
--- lemon/suurballe.h	(revision 761)
+++ lemon/suurballe.h	(revision 718)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -46,6 +46,6 @@
   /// Note that this problem is a special case of the \ref min_cost_flow
   /// "minimum cost flow problem". This implementation is actually an
-  /// efficient specialized version of the Successive Shortest Path
-  /// algorithm directly for this problem.
+  /// efficient specialized version of the \ref CapacityScaling
+  /// "Successive Shortest Path" algorithm directly for this problem.
   /// Therefore this class provides query functions for flow values and
   /// node potentials (the dual solution) just like the minimum cost flow
Index: lemon/unionfind.h
===================================================================
--- lemon/unionfind.h	(revision 761)
+++ lemon/unionfind.h	(revision 722)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/Makefile.am
===================================================================
--- test/Makefile.am	(revision 776)
+++ test/Makefile.am	(revision 771)
@@ -69,7 +69,7 @@
 test_graph_test_SOURCES = test/graph_test.cc
 test_graph_utils_test_SOURCES = test/graph_utils_test.cc
-test_hao_orlin_test_SOURCES = test/hao_orlin_test.cc
 test_heap_test_SOURCES = test/heap_test.cc
 test_kruskal_test_SOURCES = test/kruskal_test.cc
+test_hao_orlin_test_SOURCES = test/hao_orlin_test.cc
 test_lgf_test_SOURCES = test/lgf_test.cc
 test_lp_test_SOURCES = test/lp_test.cc
Index: test/adaptors_test.cc
===================================================================
--- test/adaptors_test.cc	(revision 808)
+++ test/adaptors_test.cc	(revision 807)
@@ -1381,8 +1381,7 @@
 
   // Apply several adaptors on the grid graph
-  typedef Orienter<const GridGraph, GridGraph::EdgeMap<bool> >
-    OrientedGridGraph;
-  typedef ReverseDigraph<const OrientedGridGraph> RevOrientedGridGraph;
-  typedef SplitNodes<RevOrientedGridGraph> RevSplitGridGraph;
+  typedef SplitNodes< ReverseDigraph< const Orienter<
+            const GridGraph, GridGraph::EdgeMap<bool> > > >
+    RevSplitGridGraph;
   typedef ReverseDigraph<const RevSplitGridGraph> SplitGridGraph;
   typedef Undirector<const SplitGridGraph> USplitGridGraph;
@@ -1393,8 +1392,6 @@
   checkConcept<concepts::Graph, UUSplitGridGraph>();
 
-  OrientedGridGraph ori_adaptor = orienter(graph, dir_map);
-  RevOrientedGridGraph rev_ori_adaptor = reverseDigraph(ori_adaptor);
   RevSplitGridGraph rev_adaptor =
-    splitNodes(rev_ori_adaptor);
+    splitNodes(reverseDigraph(orienter(graph, dir_map)));
   SplitGridGraph adaptor = reverseDigraph(rev_adaptor);
   USplitGridGraph uadaptor = undirector(adaptor);
Index: test/bfs_test.cc
===================================================================
--- test/bfs_test.cc	(revision 808)
+++ test/bfs_test.cc	(revision 807)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -85,5 +85,5 @@
     b = const_bfs_test.emptyQueue();
     i = const_bfs_test.queueSize();
-
+    
     bfs_test.start();
     bfs_test.start(t);
@@ -106,10 +106,10 @@
       ::SetProcessedMap<concepts::WriteMap<Node,bool> >
       ::Create bfs_test(G);
-
+      
     concepts::ReadWriteMap<Node,Arc> pred_map;
     concepts::ReadWriteMap<Node,int> dist_map;
     concepts::ReadWriteMap<Node,bool> reached_map;
     concepts::WriteMap<Node,bool> processed_map;
-
+    
     bfs_test
       .predMap(pred_map)
@@ -121,5 +121,5 @@
     bfs_test.run(s,t);
     bfs_test.run();
-
+    
     bfs_test.init();
     bfs_test.addSource(s);
@@ -130,5 +130,5 @@
     b = bfs_test.emptyQueue();
     i = bfs_test.queueSize();
-
+    
     bfs_test.start();
     bfs_test.start(t);
Index: test/circulation_test.cc
===================================================================
--- test/circulation_test.cc	(revision 808)
+++ test/circulation_test.cc	(revision 807)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -83,5 +83,5 @@
   CirculationType circ_test(g, lcap, ucap, supply);
   const CirculationType& const_circ_test = circ_test;
-
+   
   circ_test
     .lowerMap(lcap)
@@ -99,5 +99,5 @@
   b = const_circ_test.barrier(n);
   const_circ_test.barrierMap(bar);
-
+  
   ::lemon::ignore_unused_variable_warning(fm);
 }
Index: test/connectivity_test.cc
===================================================================
--- test/connectivity_test.cc	(revision 808)
+++ test/connectivity_test.cc	(revision 809)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -30,10 +30,10 @@
   typedef ListDigraph Digraph;
   typedef Undirector<Digraph> Graph;
-
+  
   {
     Digraph d;
     Digraph::NodeMap<int> order(d);
     Graph g(d);
-
+    
     check(stronglyConnected(d), "The empty digraph is strongly connected");
     check(countStronglyConnectedComponents(d) == 0,
@@ -49,5 +49,5 @@
     check(countBiEdgeConnectedComponents(g) == 0,
           "The empty graph has 0 bi-edge-connected component");
-
+          
     check(dag(d), "The empty digraph is DAG.");
     check(checkedTopologicalSort(d, order), "The empty digraph is DAG.");
@@ -84,5 +84,5 @@
     check(countBiEdgeConnectedComponents(g) == 1,
           "This graph has 1 bi-edge-connected component");
-
+          
     check(dag(d), "This digraph is DAG.");
     check(checkedTopologicalSort(d, order), "This digraph is DAG.");
@@ -100,8 +100,25 @@
 
   {
+    ListGraph g;
+    ListGraph::NodeMap<bool> map(g);
+
+    ListGraph::Node n1 = g.addNode();
+    ListGraph::Node n2 = g.addNode();
+
+    ListGraph::Edge e1 = g.addEdge(n1, n2);
+    ::lemon::ignore_unused_variable_warning(e1);
+    check(biNodeConnected(g), "Graph is bi-node-connected");
+
+    ListGraph::Node n3 = g.addNode();
+    ::lemon::ignore_unused_variable_warning(n3);
+    check(!biNodeConnected(g), "Graph is not bi-node-connected");
+  }
+
+
+  {
     Digraph d;
     Digraph::NodeMap<int> order(d);
     Graph g(d);
-
+    
     Digraph::Node n1 = d.addNode();
     Digraph::Node n2 = d.addNode();
@@ -110,5 +127,5 @@
     Digraph::Node n5 = d.addNode();
     Digraph::Node n6 = d.addNode();
-
+    
     d.addArc(n1, n3);
     d.addArc(n3, n2);
@@ -138,21 +155,21 @@
     check(!parallelFree(g), "This graph is not parallel-free.");
     check(!simpleGraph(g), "This graph is not simple.");
-
+    
     d.addArc(n3, n3);
-
+    
     check(!loopFree(d), "This digraph is not loop-free.");
     check(!loopFree(g), "This graph is not loop-free.");
     check(!simpleGraph(d), "This digraph is not simple.");
-
+    
     d.addArc(n3, n2);
-
+    
     check(!parallelFree(d), "This digraph is not parallel-free.");
   }
-
+  
   {
     Digraph d;
     Digraph::ArcMap<bool> cutarcs(d, false);
     Graph g(d);
-
+    
     Digraph::Node n1 = d.addNode();
     Digraph::Node n2 = d.addNode();
@@ -174,5 +191,5 @@
     d.addArc(n6, n7);
     d.addArc(n7, n6);
-
+   
     check(!stronglyConnected(d), "This digraph is not strongly connected");
     check(countStronglyConnectedComponents(d) == 3,
@@ -237,5 +254,5 @@
     Digraph d;
     Digraph::NodeMap<int> order(d);
-
+    
     Digraph::Node belt = d.addNode();
     Digraph::Node trousers = d.addNode();
@@ -258,5 +275,5 @@
     d.addArc(shirt, necktie);
     d.addArc(necktie, coat);
-
+    
     check(dag(d), "This digraph is DAG.");
     topologicalSort(d, order);
@@ -270,5 +287,5 @@
     ListGraph g;
     ListGraph::NodeMap<bool> map(g);
-
+    
     ListGraph::Node n1 = g.addNode();
     ListGraph::Node n2 = g.addNode();
@@ -286,8 +303,8 @@
     g.addEdge(n4, n7);
     g.addEdge(n5, n7);
-
+   
     check(bipartite(g), "This graph is bipartite");
     check(bipartitePartitions(g, map), "This graph is bipartite");
-
+    
     check(map[n1] == map[n2] && map[n1] == map[n6] && map[n1] == map[n7],
           "Wrong bipartitePartitions()");
Index: test/dfs_test.cc
===================================================================
--- test/dfs_test.cc	(revision 808)
+++ test/dfs_test.cc	(revision 807)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -89,5 +89,5 @@
     b = const_dfs_test.emptyQueue();
     i = const_dfs_test.queueSize();
-
+    
     dfs_test.start();
     dfs_test.start(t);
@@ -115,5 +115,5 @@
     concepts::ReadWriteMap<Node,bool> reached_map;
     concepts::WriteMap<Node,bool> processed_map;
-
+    
     dfs_test
       .predMap(pred_map)
@@ -132,5 +132,5 @@
     b = dfs_test.emptyQueue();
     i = dfs_test.queueSize();
-
+    
     dfs_test.start();
     dfs_test.start(t);
@@ -224,5 +224,5 @@
   check(dfs.run(s1,t1) && dfs.reached(t1),"Node 3 is reachable from Node 6.");
   }
-
+  
   {
     NullMap<Node,Arc> myPredMap;
Index: test/dijkstra_test.cc
===================================================================
--- test/dijkstra_test.cc	(revision 808)
+++ test/dijkstra_test.cc	(revision 807)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -88,5 +88,5 @@
     b = const_dijkstra_test.emptyQueue();
     i = const_dijkstra_test.queueSize();
-
+    
     dijkstra_test.start();
     dijkstra_test.start(t);
@@ -112,5 +112,5 @@
       ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> > >
       ::SetStandardHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> > >
-      ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> >,
+      ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> >, 
                 concepts::ReadWriteMap<Node,int> >
       ::Create dijkstra_test(G,length);
@@ -122,5 +122,5 @@
     concepts::ReadWriteMap<Node,int> heap_cross_ref;
     BinHeap<VType, concepts::ReadWriteMap<Node,int> > heap(heap_cross_ref);
-
+    
     dijkstra_test
       .lengthMap(length_map)
@@ -139,5 +139,5 @@
     b = dijkstra_test.emptyQueue();
     i = dijkstra_test.queueSize();
-
+    
     dijkstra_test.start();
     dijkstra_test.start(t);
Index: test/edge_set_test.cc
===================================================================
--- test/edge_set_test.cc	(revision 808)
+++ test/edge_set_test.cc	(revision 807)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/euler_test.cc
===================================================================
--- test/euler_test.cc	(revision 808)
+++ test/euler_test.cc	(revision 807)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -86,9 +86,9 @@
   typedef ListDigraph Digraph;
   typedef Undirector<Digraph> Graph;
-
-  {
-    Digraph d;
-    Graph g(d);
-
+  
+  {
+    Digraph d;
+    Graph g(d);
+    
     checkDiEulerIt(d);
     checkDiEulerIt(g);
@@ -130,5 +130,5 @@
     Digraph::Node n2 = d.addNode();
     Digraph::Node n3 = d.addNode();
-
+    
     d.addArc(n1, n2);
     d.addArc(n2, n1);
@@ -155,5 +155,5 @@
     Digraph::Node n5 = d.addNode();
     Digraph::Node n6 = d.addNode();
-
+    
     d.addArc(n1, n2);
     d.addArc(n2, n4);
@@ -214,5 +214,5 @@
     Digraph::Node n2 = d.addNode();
     Digraph::Node n3 = d.addNode();
-
+    
     d.addArc(n1, n2);
     d.addArc(n2, n3);
Index: test/gomory_hu_test.cc
===================================================================
--- test/gomory_hu_test.cc	(revision 808)
+++ test/gomory_hu_test.cc	(revision 807)
@@ -1,20 +1,2 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2011
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
 #include <iostream>
 
@@ -52,5 +34,5 @@
   "source 0\n"
   "target 3\n";
-
+  
 void checkGomoryHuCompile()
 {
@@ -89,5 +71,5 @@
 
 int cutValue(const Graph& graph, const BoolNodeMap& cut,
-             const IntEdgeMap& capacity) {
+	     const IntEdgeMap& capacity) {
 
   int sum = 0;
@@ -127,5 +109,5 @@
       int sum=0;
       for(GomoryHu<Graph>::MinCutEdgeIt a(ght, u, v);a!=INVALID;++a)
-        sum+=capacity[a];
+        sum+=capacity[a]; 
       check(sum == ght.minCutValue(u, v), "Problem with MinCutEdgeIt");
 
@@ -138,5 +120,5 @@
     }
   }
-
+  
   return 0;
 }
Index: test/graph_copy_test.cc
===================================================================
--- test/graph_copy_test.cc	(revision 761)
+++ test/graph_copy_test.cc	(revision 734)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -71,5 +71,5 @@
     nodeCrossRef(ncr).arcCrossRef(ecr).
     node(fn, tn).arc(fa, ta).run();
-
+  
   check(countNodes(from) == countNodes(to), "Wrong copy.");
   check(countArcs(from) == countArcs(to), "Wrong copy.");
@@ -99,5 +99,5 @@
   // Test repeated copy
   digraphCopy(from, to).run();
-
+  
   check(countNodes(from) == countNodes(to), "Wrong copy.");
   check(countArcs(from) == countArcs(to), "Wrong copy.");
@@ -201,5 +201,5 @@
   // Test repeated copy
   graphCopy(from, to).run();
-
+  
   check(countNodes(from) == countNodes(to), "Wrong copy.");
   check(countEdges(from) == countEdges(to), "Wrong copy.");
Index: test/hao_orlin_test.cc
===================================================================
--- test/hao_orlin_test.cc	(revision 808)
+++ test/hao_orlin_test.cc	(revision 807)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -85,5 +85,5 @@
 
 template <typename Graph, typename CapMap, typename CutMap>
-typename CapMap::Value
+typename CapMap::Value 
   cutValue(const Graph& graph, const CapMap& cap, const CutMap& cut)
 {
@@ -112,5 +112,5 @@
     ho.run();
     ho.minCutMap(cut);
-
+    
     check(ho.minCutValue() == 1, "Wrong cut value");
     check(ho.minCutValue() == cutValue(graph, cap1, cut), "Wrong cut value");
@@ -128,17 +128,17 @@
     ho.run();
     ho.minCutMap(cut);
-
+    
     check(ho.minCutValue() == 1, "Wrong cut value");
     check(ho.minCutValue() == cutValue(graph, cap3, cut), "Wrong cut value");
   }
-
+  
   typedef Undirector<SmartDigraph> UGraph;
   UGraph ugraph(graph);
-
+  
   {
     HaoOrlin<UGraph, SmartDigraph::ArcMap<int> > ho(ugraph, cap1);
     ho.run();
     ho.minCutMap(cut);
-
+    
     check(ho.minCutValue() == 2, "Wrong cut value");
     check(ho.minCutValue() == cutValue(ugraph, cap1, cut), "Wrong cut value");
@@ -148,5 +148,5 @@
     ho.run();
     ho.minCutMap(cut);
-
+    
     check(ho.minCutValue() == 5, "Wrong cut value");
     check(ho.minCutValue() == cutValue(ugraph, cap2, cut), "Wrong cut value");
@@ -156,5 +156,5 @@
     ho.run();
     ho.minCutMap(cut);
-
+    
     check(ho.minCutValue() == 5, "Wrong cut value");
     check(ho.minCutValue() == cutValue(ugraph, cap3, cut), "Wrong cut value");
Index: test/heap_test.cc
===================================================================
--- test/heap_test.cc	(revision 761)
+++ test/heap_test.cc	(revision 703)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/lgf_test.cc
===================================================================
--- test/lgf_test.cc	(revision 769)
+++ test/lgf_test.cc	(revision 764)
@@ -64,8 +64,8 @@
 
 
-int main()
+int main() 
 {
   {
-    ListDigraph d;
+    ListDigraph d; 
     ListDigraph::Node s,t;
     ListDigraph::ArcMap<int> label(d);
@@ -94,5 +94,5 @@
 
   {
-    ListDigraph d;
+    ListDigraph d; 
     std::istringstream input(test_lgf_nomap);
     digraphReader(d, input).
@@ -111,5 +111,5 @@
 
   {
-    ListDigraph d;
+    ListDigraph d; 
     std::istringstream input(test_lgf_bad1);
     bool ok=false;
@@ -118,5 +118,5 @@
         run();
     }
-    catch (FormatError&)
+    catch (FormatError&) 
       {
         ok = true;
@@ -140,5 +140,5 @@
 
   {
-    ListDigraph d;
+    ListDigraph d; 
     std::istringstream input(test_lgf_bad2);
     bool ok=false;
Index: test/lp_test.cc
===================================================================
--- test/lp_test.cc	(revision 806)
+++ test/lp_test.cc	(revision 805)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/maps_test.cc
===================================================================
--- test/maps_test.cc	(revision 808)
+++ test/maps_test.cc	(revision 807)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -71,8 +71,6 @@
   checkConcept<ReadWriteMap<A,B>, ReadWriteMap<A,B> >();
   checkConcept<ReadWriteMap<A,C>, ReadWriteMap<A,C> >();
-  checkConcept<ReferenceMap<A,B,B&,const B&>,
-               ReferenceMap<A,B,B&,const B&> >();
-  checkConcept<ReferenceMap<A,C,C&,const C&>,
-               ReferenceMap<A,C,C&,const C&> >();
+  checkConcept<ReferenceMap<A,B,B&,const B&>, ReferenceMap<A,B,B&,const B&> >();
+  checkConcept<ReferenceMap<A,C,C&,const C&>, ReferenceMap<A,C,C&,const C&> >();
 
   // NullMap
@@ -371,5 +369,5 @@
       check(v1[i++] == *it, "Something is wrong with LoggerBoolMap");
   }
-
+  
   // CrossRefMap
   {
@@ -379,14 +377,14 @@
     checkConcept<ReadWriteMap<Node, int>,
                  CrossRefMap<Graph, Node, int> >();
-
+    
     Graph gr;
     typedef CrossRefMap<Graph, Node, char> CRMap;
     typedef CRMap::ValueIterator ValueIt;
     CRMap map(gr);
-
+    
     Node n0 = gr.addNode();
     Node n1 = gr.addNode();
     Node n2 = gr.addNode();
-
+    
     map.set(n0, 'A');
     map.set(n1, 'B');
Index: test/matching_test.cc
===================================================================
--- test/matching_test.cc	(revision 808)
+++ test/matching_test.cc	(revision 807)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -135,5 +135,5 @@
   mat_test.startDense();
   mat_test.run();
-
+  
   const_mat_test.matchingSize();
   const_mat_test.matching(e);
@@ -144,5 +144,5 @@
   const_mat_test.mate(n);
 
-  MaxMatching<Graph>::Status stat =
+  MaxMatching<Graph>::Status stat = 
     const_mat_test.status(n);
   ::lemon::ignore_unused_variable_warning(stat);
@@ -172,5 +172,5 @@
   mat_test.start();
   mat_test.run();
-
+  
   const_mat_test.matchingWeight();
   const_mat_test.matchingSize();
@@ -181,5 +181,5 @@
   e = mmap[n];
   const_mat_test.mate(n);
-
+  
   int k = 0;
   const_mat_test.dualValue();
@@ -209,5 +209,5 @@
   mat_test.start();
   mat_test.run();
-
+  
   const_mat_test.matchingWeight();
   const_mat_test.matching(e);
@@ -217,5 +217,5 @@
   e = mmap[n];
   const_mat_test.mate(n);
-
+  
   int k = 0;
   const_mat_test.dualValue();
Index: test/min_cost_arborescence_test.cc
===================================================================
--- test/min_cost_arborescence_test.cc	(revision 808)
+++ test/min_cost_arborescence_test.cc	(revision 807)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -112,5 +112,5 @@
   b = const_mcarb_test.emptyQueue();
   i = const_mcarb_test.queueSize();
-
+  
   c = const_mcarb_test.arborescenceCost();
   b = const_mcarb_test.arborescence(e);
@@ -122,10 +122,10 @@
   b = const_mcarb_test.reached(n);
   b = const_mcarb_test.processed(n);
-
+  
   i = const_mcarb_test.dualNum();
   c = const_mcarb_test.dualValue();
   i = const_mcarb_test.dualSize(i);
   c = const_mcarb_test.dualValue(i);
-
+  
   ::lemon::ignore_unused_variable_warning(am);
   ::lemon::ignore_unused_variable_warning(pm);
Index: test/min_cost_flow_test.cc
===================================================================
--- test/min_cost_flow_test.cc	(revision 761)
+++ test/min_cost_flow_test.cc	(revision 668)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -48,5 +48,5 @@
   "   11     0    0    0    0  -10    0\n"
   "   12   -20  -27    0  -30  -30  -20\n"
-  "\n"
+  "\n"                
   "@arcs\n"
   "       cost  cap low1 low2 low3\n"
@@ -94,5 +94,5 @@
     void constraints() {
       checkConcept<concepts::Digraph, GR>();
-
+      
       const Constraints& me = *this;
 
@@ -123,5 +123,5 @@
     typedef concepts::WriteMap<Arc, Value> FlowMap;
     typedef concepts::WriteMap<Node, Cost> PotMap;
-
+  
     GR g;
     VAM lower;
@@ -177,5 +177,5 @@
            typename CM, typename SM, typename FM, typename PM >
 bool checkPotential( const GR& gr, const LM& lower, const UM& upper,
-                     const CM& cost, const SM& supply, const FM& flow,
+                     const CM& cost, const SM& supply, const FM& flow, 
                      const PM& pi, SupplyType type )
 {
@@ -190,5 +190,5 @@
           (red_cost < 0 && flow[e] == upper[e]);
   }
-
+  
   for (NodeIt n(gr); opt && n != INVALID; ++n) {
     typename SM::Value sum = 0;
@@ -203,5 +203,5 @@
     }
   }
-
+  
   return opt;
 }
@@ -228,5 +228,5 @@
     }
   }
-
+  
   for (NodeIt n(gr); n != INVALID; ++n) {
     dual_cost -= red_supply[n] * pi[n];
@@ -237,5 +237,5 @@
     dual_cost -= (upper[a] - lower[a]) * std::max(-red_cost, 0);
   }
-
+  
   return dual_cost == total;
 }
@@ -309,5 +309,5 @@
     .node("target", w)
     .run();
-
+  
   // Build test digraphs with negative costs
   Digraph neg_gr;
@@ -319,5 +319,5 @@
   Node n6 = neg_gr.addNode();
   Node n7 = neg_gr.addNode();
-
+  
   Arc a1 = neg_gr.addArc(n1, n2);
   Arc a2 = neg_gr.addArc(n1, n3);
@@ -329,15 +329,15 @@
   Arc a8 = neg_gr.addArc(n6, n7);
   Arc a9 = neg_gr.addArc(n7, n5);
-
+  
   Digraph::ArcMap<int> neg_c(neg_gr), neg_l1(neg_gr, 0), neg_l2(neg_gr, 0);
   ConstMap<Arc, int> neg_u1(std::numeric_limits<int>::max()), neg_u2(5000);
   Digraph::NodeMap<int> neg_s(neg_gr, 0);
-
+  
   neg_l2[a7] =  1000;
   neg_l2[a8] = -1000;
-
+  
   neg_s[n1] =  100;
   neg_s[n4] = -100;
-
+  
   neg_c[a1] =  100;
   neg_c[a2] =   30;
@@ -423,5 +423,5 @@
     checkMcf(neg_mcf, neg_mcf.run(), neg_gr, neg_l2, neg_u1,
       neg_c, neg_s, neg_mcf.UNBOUNDED, false,    0, "#A18");
-
+      
     NetworkSimplex<Digraph> negs_mcf(negs_gr);
     negs_mcf.costMap(negs_c).supplyMap(negs_s);
Index: test/preflow_test.cc
===================================================================
--- test/preflow_test.cc	(revision 808)
+++ test/preflow_test.cc	(revision 807)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -115,5 +115,5 @@
   b = const_preflow_test.minCut(n);
   const_preflow_test.minCutMap(cut);
-
+  
   ::lemon::ignore_unused_variable_warning(fm);
 }
@@ -156,5 +156,5 @@
 {
   DIGRAPH_TYPEDEFS(SmartDigraph);
-
+  
   SmartDigraph g;
   SmartDigraph::ArcMap<int> cap(g),iflow(g);
@@ -268,5 +268,5 @@
 
   initFlowTest();
-
+  
   return 0;
 }
Index: test/suurballe_test.cc
===================================================================
--- test/suurballe_test.cc	(revision 808)
+++ test/suurballe_test.cc	(revision 807)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -81,5 +81,5 @@
   typedef Digraph::Arc Arc;
   typedef concepts::ReadMap<Arc, VType> LengthMap;
-
+  
   typedef Suurballe<Digraph, LengthMap> SuurballeType;
 
@@ -105,5 +105,5 @@
   k = suurb_test.findFlow(n, k);
   suurb_test.findPaths();
-
+  
   int f;
   VType c;
@@ -119,5 +119,5 @@
   k = const_suurb_test.pathNum();
   Path<Digraph> p = const_suurb_test.path(k);
-
+  
   ::lemon::ignore_unused_variable_warning(fm);
   ::lemon::ignore_unused_variable_warning(pm);
Index: tools/dimacs-solver.cc
===================================================================
--- tools/dimacs-solver.cc	(revision 795)
+++ tools/dimacs-solver.cc	(revision 794)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -89,5 +89,5 @@
   pre.run();
   if(report) std::cerr << "Run Preflow: " << ti << '\n';
-  if(report) std::cerr << "\nMax flow value: " << pre.flowValue() << '\n';
+  if(report) std::cerr << "\nMax flow value: " << pre.flowValue() << '\n';  
 }
 
@@ -149,5 +149,5 @@
   if(report) std::cerr << "Run MaxMatching: " << ti << '\n';
   if(report) std::cerr << "\nCardinality of max matching: "
-                       << mat.matchingSize() << '\n';
+                       << mat.matchingSize() << '\n';  
 }
 
@@ -167,5 +167,5 @@
       exit(1);
     }
-
+  
   switch(desc.type)
     {
@@ -236,5 +236,5 @@
 
   DimacsDescriptor desc = dimacsType(is);
-
+  
   if(!ap.given("q"))
     {
@@ -261,5 +261,5 @@
       std::cout << "\n\n";
     }
-
+    
   if(ap.given("double"))
     solve<double>(ap,is,os,desc);
