Index: test/bellman_ford_test.cc
===================================================================
--- test/bellman_ford_test.cc	(revision 917)
+++ test/bellman_ford_test.cc	(revision 956)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -98,5 +98,5 @@
     pp = const_bf_test.path(t);
     pp = const_bf_test.negativeCycle();
-    
+
     for (BF::ActiveIt it(const_bf_test); it != INVALID; ++it) {}
   }
@@ -111,5 +111,5 @@
     concepts::ReadWriteMap<Node,Arc> pred_map;
     concepts::ReadWriteMap<Node,Value> dist_map;
-    
+
     bf_test
       .lengthMap(length_map)
@@ -190,5 +190,5 @@
   check(pathSource(gr, p) == s, "path() found a wrong path.");
   check(pathTarget(gr, p) == t, "path() found a wrong path.");
-  
+
   ListPath<Digraph> path;
   Value dist;
@@ -229,16 +229,16 @@
   SmartDigraph gr;
   IntArcMap length(gr);
-  
+
   Node n1 = gr.addNode();
   Node n2 = gr.addNode();
   Node n3 = gr.addNode();
   Node n4 = gr.addNode();
-  
+
   Arc a1 = gr.addArc(n1, n2);
   Arc a2 = gr.addArc(n2, n2);
-  
+
   length[a1] = 2;
   length[a2] = -1;
-  
+
   {
     BellmanFord<SmartDigraph, IntArcMap> bf(gr, length);
@@ -248,7 +248,7 @@
           "Wrong negative cycle.");
   }
- 
+
   length[a2] = 0;
-  
+
   {
     BellmanFord<SmartDigraph, IntArcMap> bf(gr, length);
@@ -257,10 +257,10 @@
           "Negative cycle should not be found.");
   }
-  
+
   length[gr.addArc(n1, n3)] = 5;
   length[gr.addArc(n4, n3)] = 1;
   length[gr.addArc(n2, n4)] = 2;
   length[gr.addArc(n3, n2)] = -4;
-  
+
   {
     BellmanFord<SmartDigraph, IntArcMap> bf(gr, length);
Index: test/bfs_test.cc
===================================================================
--- test/bfs_test.cc	(revision 632)
+++ test/bfs_test.cc	(revision 956)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -84,5 +84,5 @@
     b = const_bfs_test.emptyQueue();
     i = const_bfs_test.queueSize();
-    
+
     bfs_test.start();
     bfs_test.start(t);
@@ -105,10 +105,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)
@@ -120,5 +120,5 @@
     bfs_test.run(s,t);
     bfs_test.run();
-    
+
     bfs_test.init();
     bfs_test.addSource(s);
@@ -129,5 +129,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 736)
+++ test/circulation_test.cc	(revision 956)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -82,5 +82,5 @@
   CirculationType circ_test(g, lcap, ucap, supply);
   const CirculationType& const_circ_test = circ_test;
-   
+
   circ_test
     .lowerMap(lcap)
@@ -88,5 +88,5 @@
     .supplyMap(supply)
     .flowMap(flow);
-  
+
   const CirculationType::Elevator& elev = const_circ_test.elevator();
   circ_test.elevator(const_cast<CirculationType::Elevator&>(elev));
@@ -103,5 +103,5 @@
   b = const_circ_test.barrier(n);
   const_circ_test.barrierMap(bar);
-  
+
   ignore_unused_variable_warning(fm);
 }
Index: test/connectivity_test.cc
===================================================================
--- test/connectivity_test.cc	(revision 696)
+++ test/connectivity_test.cc	(revision 956)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * 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);
-    
+
+  {
+    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.");
@@ -83,5 +83,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.");
@@ -102,5 +102,5 @@
     Digraph::NodeMap<int> order(d);
     Graph g(d);
-    
+
     Digraph::Node n1 = d.addNode();
     Digraph::Node n2 = d.addNode();
@@ -109,5 +109,5 @@
     Digraph::Node n5 = d.addNode();
     Digraph::Node n6 = d.addNode();
-    
+
     d.addArc(n1, n3);
     d.addArc(n3, n2);
@@ -137,21 +137,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();
@@ -173,5 +173,5 @@
     d.addArc(n6, n7);
     d.addArc(n7, n6);
-   
+
     check(!stronglyConnected(d), "This digraph is not strongly connected");
     check(countStronglyConnectedComponents(d) == 3,
@@ -236,5 +236,5 @@
     Digraph d;
     Digraph::NodeMap<int> order(d);
-    
+
     Digraph::Node belt = d.addNode();
     Digraph::Node trousers = d.addNode();
@@ -256,5 +256,5 @@
     d.addArc(shirt, necktie);
     d.addArc(necktie, coat);
-    
+
     check(dag(d), "This digraph is DAG.");
     topologicalSort(d, order);
@@ -268,5 +268,5 @@
     ListGraph g;
     ListGraph::NodeMap<bool> map(g);
-    
+
     ListGraph::Node n1 = g.addNode();
     ListGraph::Node n2 = g.addNode();
@@ -284,8 +284,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 632)
+++ test/dfs_test.cc	(revision 956)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -84,5 +84,5 @@
     b = const_dfs_test.emptyQueue();
     i = const_dfs_test.queueSize();
-    
+
     dfs_test.start();
     dfs_test.start(t);
@@ -110,5 +110,5 @@
     concepts::ReadWriteMap<Node,bool> reached_map;
     concepts::WriteMap<Node,bool> processed_map;
-    
+
     dfs_test
       .predMap(pred_map)
@@ -127,5 +127,5 @@
     b = dfs_test.emptyQueue();
     i = dfs_test.queueSize();
-    
+
     dfs_test.start();
     dfs_test.start(t);
Index: test/digraph_test.cc
===================================================================
--- test/digraph_test.cc	(revision 827)
+++ test/digraph_test.cc	(revision 956)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -393,7 +393,7 @@
   SmartDigraph::NodeMap<StaticDigraph::Node> nref(g);
   SmartDigraph::ArcMap<StaticDigraph::Arc> aref(g);
-  
+
   StaticDigraph G;
-  
+
   checkGraphNodeList(G, 0);
   checkGraphArcList(G, 0);
@@ -465,5 +465,5 @@
 
   G.build(6, arcs.begin(), arcs.end());
-  
+
   checkGraphNodeList(G, 6);
   checkGraphArcList(G, 9);
@@ -489,5 +489,5 @@
   checkGraphNodeMap(G);
   checkGraphArcMap(G);
-  
+
   int n = G.nodeNum();
   int m = G.arcNum();
Index: test/dijkstra_test.cc
===================================================================
--- test/dijkstra_test.cc	(revision 632)
+++ test/dijkstra_test.cc	(revision 956)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -86,5 +86,5 @@
     b = const_dijkstra_test.emptyQueue();
     i = const_dijkstra_test.queueSize();
-    
+
     dijkstra_test.start();
     dijkstra_test.start(t);
@@ -110,5 +110,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);
@@ -120,5 +120,5 @@
     concepts::ReadWriteMap<Node,int> heap_cross_ref;
     BinHeap<VType, concepts::ReadWriteMap<Node,int> > heap(heap_cross_ref);
-    
+
     dijkstra_test
       .lengthMap(length_map)
@@ -137,5 +137,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 559)
+++ test/edge_set_test.cc	(revision 956)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/euler_test.cc
===================================================================
--- test/euler_test.cc	(revision 639)
+++ test/euler_test.cc	(revision 956)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * 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);
@@ -129,5 +129,5 @@
     Digraph::Node n2 = d.addNode();
     Digraph::Node n3 = d.addNode();
-    
+
     d.addArc(n1, n2);
     d.addArc(n2, n1);
@@ -154,5 +154,5 @@
     Digraph::Node n5 = d.addNode();
     Digraph::Node n6 = d.addNode();
-    
+
     d.addArc(n1, n2);
     d.addArc(n2, n4);
@@ -190,5 +190,5 @@
     Digraph::Node n4 = d.addNode();
     Digraph::Node n5 = d.addNode();
-    
+
     d.addArc(n1, n2);
     d.addArc(n2, n3);
@@ -212,5 +212,5 @@
     Digraph::Node n2 = d.addNode();
     Digraph::Node n3 = d.addNode();
-    
+
     d.addArc(n1, n2);
     d.addArc(n2, n3);
Index: test/fractional_matching_test.cc
===================================================================
--- test/fractional_matching_test.cc	(revision 951)
+++ test/fractional_matching_test.cc	(revision 956)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -239,5 +239,5 @@
   for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) {
     check((e == mfm.matching(graph.u(e)) ? 1 : 0) +
-          (e == mfm.matching(graph.v(e)) ? 1 : 0) == 
+          (e == mfm.matching(graph.v(e)) ? 1 : 0) ==
           mfm.matching(e), "Invalid matching");
   }
@@ -293,5 +293,5 @@
     for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) {
       check((e == mfm.matching(graph.u(e)) ? 1 : 0) +
-            (e == mfm.matching(graph.v(e)) ? 1 : 0) == 
+            (e == mfm.matching(graph.v(e)) ? 1 : 0) ==
             mfm.matching(e), "Invalid matching");
     }
@@ -351,5 +351,5 @@
   for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) {
     check((e == mwfm.matching(graph.u(e)) ? 1 : 0) +
-          (e == mwfm.matching(graph.v(e)) ? 1 : 0) == 
+          (e == mwfm.matching(graph.v(e)) ? 1 : 0) ==
           mwfm.matching(e), "Invalid matching");
   }
@@ -411,5 +411,5 @@
   for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) {
     check((e == mwpfm.matching(graph.u(e)) ? 1 : 0) +
-          (e == mwpfm.matching(graph.v(e)) ? 1 : 0) == 
+          (e == mwpfm.matching(graph.v(e)) ? 1 : 0) ==
           mwpfm.matching(e), "Invalid matching");
   }
Index: test/gomory_hu_test.cc
===================================================================
--- test/gomory_hu_test.cc	(revision 643)
+++ test/gomory_hu_test.cc	(revision 956)
@@ -1,2 +1,20 @@
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
+ * Copyright (C) 2003-2010
+ * 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>
 
@@ -34,5 +52,5 @@
   "source 0\n"
   "target 3\n";
-  
+
 void checkGomoryHuCompile()
 {
@@ -70,5 +88,5 @@
 
 int cutValue(const Graph& graph, const BoolNodeMap& cut,
-	     const IntEdgeMap& capacity) {
+             const IntEdgeMap& capacity) {
 
   int sum = 0;
@@ -108,5 +126,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");
 
@@ -119,5 +137,5 @@
     }
   }
-  
+
   return 0;
 }
Index: test/graph_test.cc
===================================================================
--- test/graph_test.cc	(revision 787)
+++ test/graph_test.cc	(revision 956)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -265,5 +265,5 @@
   checkGraphEdgeList(G, 3);
   checkGraphArcList(G, 6);
-  
+
   G.addEdge(G.addNode(), G.addNode());
 
@@ -514,5 +514,5 @@
   G.resize(dim);
   check(G.dimension() == dim, "Wrong dimension");
-  
+
   checkGraphNodeList(G, 1 << dim);
   checkGraphEdgeList(G, dim * (1 << (dim-1)));
Index: test/hao_orlin_test.cc
===================================================================
--- test/hao_orlin_test.cc	(revision 644)
+++ test/hao_orlin_test.cc	(revision 956)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -84,5 +84,5 @@
 
 template <typename Graph, typename CapMap, typename CutMap>
-typename CapMap::Value 
+typename CapMap::Value
   cutValue(const Graph& graph, const CapMap& cap, const CutMap& cut)
 {
@@ -111,5 +111,5 @@
     ho.run();
     ho.minCutMap(cut);
-    
+
     check(ho.minCutValue() == 1, "Wrong cut value");
     check(ho.minCutValue() == cutValue(graph, cap1, cut), "Wrong cut value");
@@ -127,17 +127,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");
@@ -147,5 +147,5 @@
     ho.run();
     ho.minCutMap(cut);
-    
+
     check(ho.minCutValue() == 5, "Wrong cut value");
     check(ho.minCutValue() == cutValue(ugraph, cap2, cut), "Wrong cut value");
@@ -155,5 +155,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/maps_test.cc
===================================================================
--- test/maps_test.cc	(revision 836)
+++ test/maps_test.cc	(revision 956)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -226,5 +226,6 @@
 
     checkConcept<ReadMap<A,B>, MapToFunctor<ReadMap<A,B> > >();
-    MapToFunctor<ReadMap<A,B> > map = MapToFunctor<ReadMap<A,B> >(ReadMap<A,B>());
+    MapToFunctor<ReadMap<A,B> > map =
+      MapToFunctor<ReadMap<A,B> >(ReadMap<A,B>());
 
     check(functorToMap(&func)[A()] == 3,
@@ -378,5 +379,5 @@
           it != map2.end(); ++it )
       check(v1[i++] == *it, "Something is wrong with LoggerBoolMap");
-    
+
     typedef ListDigraph Graph;
     DIGRAPH_TYPEDEFS(Graph);
@@ -387,5 +388,5 @@
     Node n2 = gr.addNode();
     Node n3 = gr.addNode();
-    
+
     gr.addArc(n3, n0);
     gr.addArc(n3, n2);
@@ -393,5 +394,5 @@
     gr.addArc(n2, n1);
     gr.addArc(n0, n1);
-    
+
     {
       std::vector<Node> v;
@@ -404,10 +405,10 @@
       std::vector<Node> v(countNodes(gr));
       dfs(gr).processedMap(loggerBoolMap(v.begin())).run();
-      
+
       check(v.size()==4 && v[0]==n1 && v[1]==n2 && v[2]==n0 && v[3]==n3,
             "Something is wrong with LoggerBoolMap");
     }
   }
-  
+
   // IdMap, RangeIdMap
   {
@@ -419,5 +420,5 @@
     checkConcept<ReadMap<Node, int>, RangeIdMap<Graph, Node> >();
     checkConcept<ReadMap<Arc, int>, RangeIdMap<Graph, Arc> >();
-    
+
     Graph gr;
     IdMap<Graph, Node> nmap(gr);
@@ -425,14 +426,14 @@
     RangeIdMap<Graph, Node> nrmap(gr);
     RangeIdMap<Graph, Arc> armap(gr);
-    
+
     Node n0 = gr.addNode();
     Node n1 = gr.addNode();
     Node n2 = gr.addNode();
-    
+
     Arc a0 = gr.addArc(n0, n1);
     Arc a1 = gr.addArc(n0, n2);
     Arc a2 = gr.addArc(n2, n1);
     Arc a3 = gr.addArc(n2, n0);
-    
+
     check(nmap[n0] == gr.id(n0) && nmap(gr.id(n0)) == n0, "Wrong IdMap");
     check(nmap[n1] == gr.id(n1) && nmap(gr.id(n1)) == n1, "Wrong IdMap");
@@ -446,5 +447,5 @@
     check(nmap.inverse()[gr.id(n0)] == n0, "Wrong IdMap::InverseMap");
     check(amap.inverse()[gr.id(a0)] == a0, "Wrong IdMap::InverseMap");
-    
+
     check(nrmap.size() == 3 && armap.size() == 4,
           "Wrong RangeIdMap::size()");
@@ -453,5 +454,5 @@
     check(nrmap[n1] == 1 && nrmap(1) == n1, "Wrong RangeIdMap");
     check(nrmap[n2] == 2 && nrmap(2) == n2, "Wrong RangeIdMap");
-    
+
     check(armap[a0] == 0 && armap(0) == a0, "Wrong RangeIdMap");
     check(armap[a1] == 1 && armap(1) == a1, "Wrong RangeIdMap");
@@ -461,12 +462,12 @@
     check(nrmap.inverse()[0] == n0, "Wrong RangeIdMap::InverseMap");
     check(armap.inverse()[0] == a0, "Wrong RangeIdMap::InverseMap");
-    
+
     gr.erase(n1);
-    
+
     if (nrmap[n0] == 1) nrmap.swap(n0, n2);
     nrmap.swap(n2, n0);
     if (armap[a1] == 1) armap.swap(a1, a3);
     armap.swap(a3, a1);
-    
+
     check(nrmap.size() == 2 && armap.size() == 2,
           "Wrong RangeIdMap::size()");
@@ -474,5 +475,5 @@
     check(nrmap[n0] == 1 && nrmap(1) == n0, "Wrong RangeIdMap");
     check(nrmap[n2] == 0 && nrmap(0) == n2, "Wrong RangeIdMap");
-    
+
     check(armap[a1] == 1 && armap(1) == a1, "Wrong RangeIdMap");
     check(armap[a3] == 0 && armap(0) == a3, "Wrong RangeIdMap");
@@ -481,10 +482,10 @@
     check(armap.inverse()[0] == a3, "Wrong RangeIdMap::InverseMap");
   }
-  
+
   // SourceMap, TargetMap, ForwardMap, BackwardMap, InDegMap, OutDegMap
   {
     typedef ListGraph Graph;
     GRAPH_TYPEDEFS(Graph);
-    
+
     checkConcept<ReadMap<Arc, Node>, SourceMap<Graph> >();
     checkConcept<ReadMap<Arc, Node>, TargetMap<Graph> >();
@@ -498,5 +499,5 @@
     Node n1 = gr.addNode();
     Node n2 = gr.addNode();
-    
+
     gr.addEdge(n0,n1);
     gr.addEdge(n1,n2);
@@ -505,10 +506,10 @@
     gr.addEdge(n1,n2);
     gr.addEdge(n0,n1);
-    
+
     for (EdgeIt e(gr); e != INVALID; ++e) {
       check(forwardMap(gr)[e] == gr.direct(e, true), "Wrong ForwardMap");
       check(backwardMap(gr)[e] == gr.direct(e, false), "Wrong BackwardMap");
     }
-    
+
     check(mapCompare(gr,
           sourceMap(orienter(gr, constMap<Edge, bool>(true))),
@@ -520,8 +521,8 @@
     OutDegMap<Digraph> odm(dgr);
     InDegMap<Digraph> idm(dgr);
-    
+
     check(odm[n0] == 3 && odm[n1] == 2 && odm[n2] == 1, "Wrong OutDegMap");
     check(idm[n0] == 0 && idm[n1] == 3 && idm[n2] == 3, "Wrong InDegMap");
-   
+
     gr.addEdge(n2, n0);
 
@@ -529,5 +530,5 @@
     check(idm[n0] == 1 && idm[n1] == 3 && idm[n2] == 3, "Wrong InDegMap");
   }
-  
+
   // CrossRefMap
   {
@@ -541,17 +542,17 @@
     checkConcept<ReadWriteMap<Node, double>,
                  CrossRefMap<Graph, Node, double> >();
-    
+
     Graph gr;
     typedef CrossRefMap<Graph, Node, char> CRMap;
     CRMap map(gr);
-    
+
     Node n0 = gr.addNode();
     Node n1 = gr.addNode();
     Node n2 = gr.addNode();
-    
+
     map.set(n0, 'A');
     map.set(n1, 'B');
     map.set(n2, 'C');
-    
+
     check(map[n0] == 'A' && map('A') == n0 && map.inverse()['A'] == n0,
           "Wrong CrossRefMap");
@@ -562,9 +563,9 @@
     check(map.count('A') == 1 && map.count('B') == 1 && map.count('C') == 1,
           "Wrong CrossRefMap::count()");
-    
+
     CRMap::ValueIt it = map.beginValue();
     check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' &&
           it == map.endValue(), "Wrong value iterator");
-    
+
     map.set(n2, 'A');
 
@@ -604,14 +605,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');
@@ -630,5 +631,5 @@
           it == map.endValue(), "Wrong value iterator");
   }
-  
+
   // Iterable bool map
   {
@@ -818,5 +819,5 @@
 
   }
-  
+
   // Graph map utilities:
   // mapMin(), mapMax(), mapMinValue(), mapMaxValue()
@@ -830,14 +831,14 @@
     Node n2 = g.addNode();
     Node n3 = g.addNode();
-    
+
     SmartDigraph::NodeMap<int> map1(g);
     SmartDigraph::ArcMap<char> map2(g);
     ConstMap<Node, A> cmap1 = A();
     ConstMap<Arc, C> cmap2 = C(0);
-    
+
     map1[n1] = 10;
     map1[n2] = 5;
     map1[n3] = 12;
-    
+
     // mapMin(), mapMax(), mapMinValue(), mapMaxValue()
     check(mapMin(g, map1) == n2, "Wrong mapMin()");
@@ -858,5 +859,5 @@
     Arc a3 = g.addArc(n2, n3);
     Arc a4 = g.addArc(n3, n1);
-    
+
     map2[a1] = 'b';
     map2[a2] = 'a';
@@ -925,5 +926,5 @@
     check(mapCountIf(g, map2, Less<char>('a')) == 0,
           "Wrong mapCountIf()");
-     
+
     // MapIt, ConstMapIt
 /*
@@ -935,5 +936,5 @@
     check(*std::max_element(ConstMapIt(map1), ConstMapIt(INVALID)) == 12,
           "Wrong NodeMap<>::MapIt");
-    
+
     int sum = 0;
     std::for_each(MapIt(map1), MapIt(INVALID), Sum<int>(sum));
@@ -952,23 +953,23 @@
     SmartDigraph::NodeMap<int> map3(g, 0);
     SmartDigraph::ArcMap<char> map4(g, 'a');
-    
+
     check(!mapCompare(g, map1, map3), "Wrong mapCompare()");
-    check(!mapCompare(g, map2, map4), "Wrong mapCompare()");    
-    
+    check(!mapCompare(g, map2, map4), "Wrong mapCompare()");
+
     mapCopy(g, map1, map3);
     mapCopy(g, map2, map4);
 
     check(mapCompare(g, map1, map3), "Wrong mapCompare() or mapCopy()");
-    check(mapCompare(g, map2, map4), "Wrong mapCompare() or mapCopy()");    
-    
+    check(mapCompare(g, map2, map4), "Wrong mapCompare() or mapCopy()");
+
     Undirector<SmartDigraph> ug(g);
     Undirector<SmartDigraph>::EdgeMap<char> umap1(ug, 'x');
     Undirector<SmartDigraph>::ArcMap<double> umap2(ug, 3.14);
-    
+
     check(!mapCompare(g, map2, umap1), "Wrong mapCompare() or mapCopy()");
     check(!mapCompare(g, umap1, map2), "Wrong mapCompare() or mapCopy()");
     check(!mapCompare(ug, map2, umap1), "Wrong mapCompare() or mapCopy()");
     check(!mapCompare(ug, umap1, map2), "Wrong mapCompare() or mapCopy()");
-    
+
     mapCopy(g, map2, umap1);
 
@@ -977,14 +978,14 @@
     check(mapCompare(ug, map2, umap1), "Wrong mapCompare() or mapCopy()");
     check(mapCompare(ug, umap1, map2), "Wrong mapCompare() or mapCopy()");
-    
+
     mapCopy(g, map2, umap1);
     mapCopy(g, umap1, map2);
     mapCopy(ug, map2, umap1);
     mapCopy(ug, umap1, map2);
-    
+
     check(!mapCompare(ug, umap1, umap2), "Wrong mapCompare() or mapCopy()");
     mapCopy(ug, umap1, umap2);
     check(mapCompare(ug, umap1, umap2), "Wrong mapCompare() or mapCopy()");
-    
+
     check(!mapCompare(g, map1, constMap<Node>(2)), "Wrong mapCompare()");
     mapFill(g, map1, 2);
@@ -995,5 +996,5 @@
     check(mapCompare(g, constMap<Arc>('z'), map2), "Wrong mapCopy()");
   }
-  
+
   return 0;
 }
Index: test/matching_test.cc
===================================================================
--- test/matching_test.cc	(revision 949)
+++ test/matching_test.cc	(revision 956)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * 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);
   const MaxMatching<Graph>::StatusMap& smap =
@@ -171,5 +171,5 @@
   mat_test.start();
   mat_test.run();
-  
+
   const_mat_test.matchingWeight();
   const_mat_test.matchingSize();
@@ -180,5 +180,5 @@
   e = mmap[n];
   const_mat_test.mate(n);
-  
+
   int k = 0;
   const_mat_test.dualValue();
@@ -208,5 +208,5 @@
   mat_test.start();
   mat_test.run();
-  
+
   const_mat_test.matchingWeight();
   const_mat_test.matching(e);
@@ -216,5 +216,5 @@
   e = mmap[n];
   const_mat_test.mate(n);
-  
+
   int k = 0;
   const_mat_test.dualValue();
@@ -426,5 +426,5 @@
       MaxWeightedPerfectMatching<SmartGraph> mwpm(graph, weight);
       bool result = mwpm.run();
-      
+
       check(result == perfect, "Perfect matching found");
       if (perfect) {
@@ -437,5 +437,5 @@
       mwpm.init();
       bool result = mwpm.start();
-      
+
       check(result == perfect, "Perfect matching found");
       if (perfect) {
Index: test/min_cost_arborescence_test.cc
===================================================================
--- test/min_cost_arborescence_test.cc	(revision 672)
+++ test/min_cost_arborescence_test.cc	(revision 956)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -111,5 +111,5 @@
   b = const_mcarb_test.emptyQueue();
   i = const_mcarb_test.queueSize();
-  
+
   c = const_mcarb_test.arborescenceCost();
   b = const_mcarb_test.arborescence(e);
@@ -121,10 +121,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);
-  
+
   ignore_unused_variable_warning(am);
   ignore_unused_variable_warning(pm);
Index: test/min_cost_flow_test.cc
===================================================================
--- test/min_cost_flow_test.cc	(revision 898)
+++ test/min_cost_flow_test.cc	(revision 956)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -53,5 +53,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"
@@ -103,5 +103,5 @@
   "6 7     30      0  -1000\n"
   "7 5   -120      0      0\n";
-  
+
 char test_neg2_lgf[] =
   "@nodes\n"
@@ -152,5 +152,5 @@
     void constraints() {
       checkConcept<concepts::Digraph, GR>();
-      
+
       const Constraints& me = *this;
 
@@ -181,5 +181,5 @@
     typedef concepts::WriteMap<Arc, Value> FlowMap;
     typedef concepts::WriteMap<Node, Cost> PotMap;
-  
+
     GR g;
     VAM lower;
@@ -235,5 +235,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 )
 {
@@ -248,5 +248,5 @@
           (red_cost < 0 && flow[e] == upper[e]);
   }
-  
+
   for (NodeIt n(gr); opt && n != INVALID; ++n) {
     typename SM::Value sum = 0;
@@ -261,5 +261,5 @@
     }
   }
-  
+
   return opt;
 }
@@ -286,5 +286,5 @@
     }
   }
-  
+
   for (NodeIt n(gr); n != INVALID; ++n) {
     dual_cost -= red_supply[n] * pi[n];
@@ -295,5 +295,5 @@
     dual_cost -= (upper[a] - lower[a]) * std::max(-red_cost, 0);
   }
-  
+
   return dual_cost == total;
 }
@@ -333,5 +333,5 @@
 {
   MCF mcf1(gr), mcf2(neg1_gr), mcf3(neg2_gr);
-  
+
   // Basic tests
   mcf1.upperMap(u).costMap(c).supplyMap(s1);
@@ -436,5 +436,5 @@
     .node("target", w)
     .run();
-  
+
   std::istringstream neg_inp1(test_neg1_lgf);
   DigraphReader<Digraph>(neg1_gr, neg_inp1)
@@ -444,5 +444,5 @@
     .nodeMap("sup", neg1_s)
     .run();
-  
+
   std::istringstream neg_inp2(test_neg2_lgf);
   DigraphReader<Digraph>(neg2_gr, neg_inp2)
@@ -450,5 +450,5 @@
     .nodeMap("sup", neg2_s)
     .run();
-  
+
   // Check the interface of NetworkSimplex
   {
@@ -502,5 +502,5 @@
 
   // Test NetworkSimplex
-  { 
+  {
     typedef NetworkSimplex<Digraph> MCF;
     runMcfGeqTests<MCF>(MCF::FIRST_ELIGIBLE, "NS-FE", true);
@@ -515,5 +515,5 @@
     runMcfLeqTests<MCF>(MCF::ALTERING_LIST,  "NS-AL");
   }
-  
+
   // Test CapacityScaling
   {
Index: test/min_mean_cycle_test.cc
===================================================================
--- test/min_mean_cycle_test.cc	(revision 942)
+++ test/min_mean_cycle_test.cc	(revision 956)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -62,5 +62,5 @@
   "7 7    4    4    4   -1   0  0  0  1\n";
 
-                        
+
 // Check the interface of an MMC algorithm
 template <typename GR, typename Cost>
@@ -78,8 +78,8 @@
       MmcAlg mmc(me.g, me.cost);
       const MmcAlg& const_mmc = mmc;
-      
+
       typename MmcAlg::Tolerance tol = const_mmc.tolerance();
       mmc.tolerance(tol);
-      
+
       b = mmc.cycle(p).run();
       b = mmc.findCycleMean();
@@ -93,5 +93,5 @@
 
     typedef concepts::ReadMap<typename GR::Arc, Cost> CM;
-  
+
     GR g;
     CM cost;
@@ -154,5 +154,5 @@
     checkConcept< MmcClassConcept<GR, float>,
                   KarpMmc<GR, concepts::ReadMap<GR::Arc, float> > >();
-    
+
     // HartmannOrlinMmc
     checkConcept< MmcClassConcept<GR, int>,
@@ -160,5 +160,5 @@
     checkConcept< MmcClassConcept<GR, float>,
                   HartmannOrlinMmc<GR, concepts::ReadMap<GR::Arc, float> > >();
-    
+
     // HowardMmc
     checkConcept< MmcClassConcept<GR, int>,
@@ -177,9 +177,9 @@
     typedef SmartDigraph GR;
     DIGRAPH_TYPEDEFS(GR);
-    
+
     GR gr;
     IntArcMap l1(gr), l2(gr), l3(gr), l4(gr);
     IntArcMap c1(gr), c2(gr), c3(gr), c4(gr);
-    
+
     std::istringstream input(test_lgf);
     digraphReader(gr, input).
Index: test/preflow_test.cc
===================================================================
--- test/preflow_test.cc	(revision 736)
+++ test/preflow_test.cc	(revision 956)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -95,5 +95,5 @@
   PreflowType preflow_test(g, cap, n, n);
   const PreflowType& const_preflow_test = preflow_test;
-  
+
   const PreflowType::Elevator& elev = const_preflow_test.elevator();
   preflow_test.elevator(const_cast<PreflowType::Elevator&>(elev));
@@ -119,5 +119,5 @@
   b = const_preflow_test.minCut(n);
   const_preflow_test.minCutMap(cut);
-  
+
   ignore_unused_variable_warning(fm);
 }
Index: test/suurballe_test.cc
===================================================================
--- test/suurballe_test.cc	(revision 932)
+++ test/suurballe_test.cc	(revision 956)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -82,5 +82,5 @@
   typedef Digraph::Arc Arc;
   typedef concepts::ReadMap<Arc, VType> LengthMap;
-  
+
   typedef Suurballe<Digraph, LengthMap> ST;
   typedef Suurballe<Digraph, LengthMap>
@@ -115,5 +115,5 @@
   k = suurb_test.findFlow(n, k);
   suurb_test.findPaths();
-  
+
   int f;
   VType c;
@@ -127,5 +127,5 @@
   k = const_suurb_test.pathNum();
   Path<Digraph> p = const_suurb_test.path(k);
-  
+
   ignore_unused_variable_warning(fm);
   ignore_unused_variable_warning(pm);
@@ -209,5 +209,5 @@
   {
     Suurballe<ListDigraph> suurballe(digraph, length);
-    
+
     // Find 2 paths
     check(suurballe.run(s, t) == 2, "Wrong number of paths");
@@ -220,5 +220,5 @@
     for (int i = 0; i < suurballe.pathNum(); ++i)
       check(checkPath(digraph, suurballe.path(i), s, t), "Wrong path");
-   
+
     // Find 3 paths
     check(suurballe.run(s, t, 3) == 3, "Wrong number of paths");
@@ -231,5 +231,5 @@
     for (int i = 0; i < suurballe.pathNum(); ++i)
       check(checkPath(digraph, suurballe.path(i), s, t), "Wrong path");
-    
+
     // Find 5 paths (only 3 can be found)
     check(suurballe.run(s, t, 5) == 3, "Wrong number of paths");
@@ -243,10 +243,10 @@
       check(checkPath(digraph, suurballe.path(i), s, t), "Wrong path");
   }
-  
+
   // Check fullInit() + start()
   {
     Suurballe<ListDigraph> suurballe(digraph, length);
     suurballe.fullInit(s);
-    
+
     // Find 2 paths
     check(suurballe.start(t) == 2, "Wrong number of paths");
Index: test/test_tools.h
===================================================================
--- test/test_tools.h	(revision 810)
+++ test/test_tools.h	(revision 956)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2010
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -46,5 +46,5 @@
     } else { }                                                          \
   }                                                                     \
-    
+
 
 #endif
