Index: doc/coding_style.dox
===================================================================
--- doc/coding_style.dox	(revision 1023)
+++ doc/coding_style.dox	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: doc/dirs.dox
===================================================================
--- doc/dirs.dox	(revision 1031)
+++ doc/dirs.dox	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: doc/groups.dox
===================================================================
--- doc/groups.dox	(revision 1254)
+++ doc/groups.dox	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -430,5 +430,5 @@
 data are required to be integer).
 
-For more details about these implementations and for a comprehensive 
+For more details about these implementations and for a comprehensive
 experimental study, see the paper \cite KiralyKovacs12MCF.
 It also compares these codes to other publicly available
@@ -571,5 +571,5 @@
 \image latex planar.eps "Plane graph" width=\textwidth
 */
- 
+
 /**
 @defgroup tsp Traveling Salesman Problem
Index: doc/lgf.dox
===================================================================
--- doc/lgf.dox	(revision 1250)
+++ doc/lgf.dox	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: doc/min_cost_flow.dox
===================================================================
--- doc/min_cost_flow.dox	(revision 1221)
+++ doc/min_cost_flow.dox	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/adaptors.h
===================================================================
--- lemon/adaptors.h	(revision 1159)
+++ lemon/adaptors.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/assert.h
===================================================================
--- lemon/assert.h	(revision 1242)
+++ lemon/assert.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/base.cc
===================================================================
--- lemon/base.cc	(revision 1222)
+++ lemon/base.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/bellman_ford.h
===================================================================
--- lemon/bellman_ford.h	(revision 1254)
+++ lemon/bellman_ford.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/bfs.h
===================================================================
--- lemon/bfs.h	(revision 1250)
+++ lemon/bfs.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/bin_heap.h
===================================================================
--- lemon/bin_heap.h	(revision 758)
+++ lemon/bin_heap.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/bits/alteration_notifier.h
===================================================================
--- lemon/bits/alteration_notifier.h	(revision 1131)
+++ lemon/bits/alteration_notifier.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/bits/array_map.h
===================================================================
--- lemon/bits/array_map.h	(revision 956)
+++ lemon/bits/array_map.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/bits/bezier.h
===================================================================
--- lemon/bits/bezier.h	(revision 1157)
+++ lemon/bits/bezier.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/bits/default_map.h
===================================================================
--- lemon/bits/default_map.h	(revision 956)
+++ lemon/bits/default_map.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/bits/edge_set_extender.h
===================================================================
--- lemon/bits/edge_set_extender.h	(revision 1161)
+++ lemon/bits/edge_set_extender.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/bits/graph_adaptor_extender.h
===================================================================
--- lemon/bits/graph_adaptor_extender.h	(revision 965)
+++ lemon/bits/graph_adaptor_extender.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/bits/graph_extender.h
===================================================================
--- lemon/bits/graph_extender.h	(revision 1195)
+++ lemon/bits/graph_extender.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -844,5 +844,5 @@
 
     typedef AlterationNotifier<BpGraphExtender, Node> NodeNotifier;
-    typedef AlterationNotifier<BpGraphExtender, RedNode> RedNodeNotifier; 
+    typedef AlterationNotifier<BpGraphExtender, RedNode> RedNodeNotifier;
     typedef AlterationNotifier<BpGraphExtender, BlueNode> BlueNodeNotifier;
     typedef AlterationNotifier<BpGraphExtender, Arc> ArcNotifier;
Index: lemon/bits/lock.h
===================================================================
--- lemon/bits/lock.h	(revision 1131)
+++ lemon/bits/lock.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2012
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -34,14 +34,14 @@
     public:
       Lock() {
-	pthread_mutex_init(&_lock, 0);
+        pthread_mutex_init(&_lock, 0);
       }
       ~Lock() {
-	pthread_mutex_destroy(&_lock);
+        pthread_mutex_destroy(&_lock);
       }
       void lock() {
-	pthread_mutex_lock(&_lock);
+        pthread_mutex_lock(&_lock);
       }
       void unlock() {
-	pthread_mutex_unlock(&_lock);
+        pthread_mutex_unlock(&_lock);
       }
 
@@ -58,5 +58,5 @@
       void lock() {}
       void unlock() {}
-    };    
+    };
 #endif
   }
Index: lemon/bits/map_extender.h
===================================================================
--- lemon/bits/map_extender.h	(revision 867)
+++ lemon/bits/map_extender.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/bits/path_dump.h
===================================================================
--- lemon/bits/path_dump.h	(revision 973)
+++ lemon/bits/path_dump.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/bits/solver_bits.h
===================================================================
--- lemon/bits/solver_bits.h	(revision 1142)
+++ lemon/bits/solver_bits.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/bits/traits.h
===================================================================
--- lemon/bits/traits.h	(revision 1194)
+++ lemon/bits/traits.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/bits/windows.cc
===================================================================
--- lemon/bits/windows.cc	(revision 1163)
+++ lemon/bits/windows.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -141,5 +141,5 @@
 #endif
     }
-    
+
     WinLock::~WinLock() {
 #ifdef WIN32
Index: lemon/bits/windows.h
===================================================================
--- lemon/bits/windows.h	(revision 1131)
+++ lemon/bits/windows.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/capacity_scaling.h
===================================================================
--- lemon/capacity_scaling.h	(revision 1254)
+++ lemon/capacity_scaling.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -839,5 +839,5 @@
       return OPTIMAL;
     }
-    
+
     // Check if the upper bound is greater or equal to the lower bound
     // on each arc.
Index: lemon/cbc.cc
===================================================================
--- lemon/cbc.cc	(revision 1161)
+++ lemon/cbc.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/cbc.h
===================================================================
--- lemon/cbc.h	(revision 1232)
+++ lemon/cbc.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/christofides_tsp.h
===================================================================
--- lemon/christofides_tsp.h	(revision 1250)
+++ lemon/christofides_tsp.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -31,5 +31,5 @@
 
 namespace lemon {
-  
+
   /// \ingroup tsp
   ///
@@ -109,9 +109,9 @@
           return _sum = 2 * _cost[_gr.edge(_gr(0), _gr(1))];
         }
-        
+
         // Compute min. cost spanning tree
         std::vector<Edge> tree;
         kruskal(_gr, _cost, std::back_inserter(tree));
-        
+
         FullGraph::NodeMap<int> deg(_gr, 0);
         for (int i = 0; i != int(tree.size()); ++i) {
@@ -126,5 +126,5 @@
           if (deg[u] % 2 == 1) odd_nodes.push_back(u);
         }
-  
+
         SmartGraph sgr;
         SmartGraph::EdgeMap<Cost> scost(sgr);
@@ -140,10 +140,10 @@
           }
         }
-        
+
         // Compute min. cost perfect matching
         MaxWeightedPerfectMatching<SmartGraph, SmartGraph::EdgeMap<Cost> >
           mwpm(sgr, scost);
         mwpm.run();
-        
+
         for (SmartGraph::EdgeIt e(sgr); e != INVALID; ++e) {
           if (mwpm.matching(e)) {
@@ -152,6 +152,6 @@
           }
         }
-        
-        // Join the spanning tree and the matching        
+
+        // Join the spanning tree and the matching
         sgr.clear();
         for (int i = 0; i != _gr.nodeNum(); ++i) {
@@ -183,8 +183,8 @@
 
       /// @}
-      
+
       /// \name Query Functions
       /// @{
-      
+
       /// \brief The total cost of the found tour.
       ///
@@ -195,5 +195,5 @@
         return _sum;
       }
-      
+
       /// \brief Returns a const reference to the node sequence of the
       /// found tour.
@@ -228,5 +228,5 @@
         std::copy(_path.begin(), _path.end(), out);
       }
-      
+
       /// \brief Gives back the found tour as a path.
       ///
@@ -245,7 +245,7 @@
         }
       }
-      
+
       /// @}
-      
+
   };
 
Index: lemon/circulation.h
===================================================================
--- lemon/circulation.h	(revision 1250)
+++ lemon/circulation.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/clp.cc
===================================================================
--- lemon/clp.cc	(revision 1142)
+++ lemon/clp.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/clp.h
===================================================================
--- lemon/clp.h	(revision 956)
+++ lemon/clp.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/concept_check.h
===================================================================
--- lemon/concept_check.h	(revision 1257)
+++ lemon/concept_check.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/concepts/bpgraph.h
===================================================================
--- lemon/concepts/bpgraph.h	(revision 1262)
+++ lemon/concepts/bpgraph.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -805,10 +805,10 @@
 
       /// \brief Gives back the red end node of the edge.
-      /// 
+      ///
       /// Gives back the red end node of the edge.
       RedNode redNode(const Edge&) const { return RedNode(); }
 
       /// \brief Gives back the blue end node of the edge.
-      /// 
+      ///
       /// Gives back the blue end node of the edge.
       BlueNode blueNode(const Edge&) const { return BlueNode(); }
Index: lemon/concepts/digraph.h
===================================================================
--- lemon/concepts/digraph.h	(revision 1261)
+++ lemon/concepts/digraph.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/concepts/graph.h
===================================================================
--- lemon/concepts/graph.h	(revision 1261)
+++ lemon/concepts/graph.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/concepts/graph_components.h
===================================================================
--- lemon/concepts/graph_components.h	(revision 1262)
+++ lemon/concepts/graph_components.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -392,10 +392,10 @@
 
       /// \brief Gives back the red end node of the edge.
-      /// 
+      ///
       /// Gives back the red end node of the edge.
       RedNode redNode(const Edge&) const { return RedNode(); }
 
       /// \brief Gives back the blue end node of the edge.
-      /// 
+      ///
       /// Gives back the blue end node of the edge.
       BlueNode blueNode(const Edge&) const { return BlueNode(); }
@@ -1151,5 +1151,5 @@
       typedef typename Base::Arc Arc;
       typedef typename Base::Edge Edge;
-      
+
       typedef IterableBpGraphComponent BpGraph;
 
@@ -1211,5 +1211,5 @@
           typename _BpGraph::RedNode rn(INVALID);
           bpgraph.first(rn);
-          bpgraph.next(rn); 
+          bpgraph.next(rn);
           typename _BpGraph::BlueNode bn(INVALID);
           bpgraph.first(bn);
Index: lemon/concepts/heap.h
===================================================================
--- lemon/concepts/heap.h	(revision 1259)
+++ lemon/concepts/heap.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/concepts/maps.h
===================================================================
--- lemon/concepts/maps.h	(revision 1257)
+++ lemon/concepts/maps.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/concepts/path.h
===================================================================
--- lemon/concepts/path.h	(revision 1259)
+++ lemon/concepts/path.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/connectivity.h
===================================================================
--- lemon/connectivity.h	(revision 1268)
+++ lemon/connectivity.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/core.h
===================================================================
--- lemon/core.h	(revision 1261)
+++ lemon/core.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -255,5 +255,5 @@
 
   namespace _graph_utils_bits {
-    
+
     template <typename Graph, typename Enable = void>
     struct CountRedNodesSelector {
@@ -265,11 +265,11 @@
     template <typename Graph>
     struct CountRedNodesSelector<
-      Graph, typename 
-      enable_if<typename Graph::NodeNumTag, void>::type> 
+      Graph, typename
+      enable_if<typename Graph::NodeNumTag, void>::type>
     {
       static int count(const Graph &g) {
         return g.redNum();
       }
-    };    
+    };
   }
 
@@ -280,5 +280,5 @@
   /// graph structures it is specialized to run in O(1).
   ///
-  /// If the graph contains a \e redNum() member function and a 
+  /// If the graph contains a \e redNum() member function and a
   /// \e NodeNumTag tag then this function calls directly the member
   /// function to query the cardinality of the node set.
@@ -289,5 +289,5 @@
 
   namespace _graph_utils_bits {
-    
+
     template <typename Graph, typename Enable = void>
     struct CountBlueNodesSelector {
@@ -299,11 +299,11 @@
     template <typename Graph>
     struct CountBlueNodesSelector<
-      Graph, typename 
-      enable_if<typename Graph::NodeNumTag, void>::type> 
+      Graph, typename
+      enable_if<typename Graph::NodeNumTag, void>::type>
     {
       static int count(const Graph &g) {
         return g.blueNum();
       }
-    };    
+    };
   }
 
@@ -314,5 +314,5 @@
   /// graph structures it is specialized to run in O(1).
   ///
-  /// If the graph contains a \e blueNum() member function and a 
+  /// If the graph contains a \e blueNum() member function and a
   /// \e NodeNumTag tag then this function calls directly the member
   /// function to query the cardinality of the node set.
@@ -1866,5 +1866,5 @@
     /// The Digraph type
     typedef GR Digraph;
-    
+
   protected:
 
Index: lemon/cost_scaling.h
===================================================================
--- lemon/cost_scaling.h	(revision 1254)
+++ lemon/cost_scaling.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -905,5 +905,5 @@
       return OPTIMAL;
     }
-    
+
     // Check if the upper bound is greater or equal to the lower bound
     // on each arc.
Index: lemon/cplex.cc
===================================================================
--- lemon/cplex.cc	(revision 1231)
+++ lemon/cplex.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/cplex.h
===================================================================
--- lemon/cplex.h	(revision 1250)
+++ lemon/cplex.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/cycle_canceling.h
===================================================================
--- lemon/cycle_canceling.h	(revision 1255)
+++ lemon/cycle_canceling.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -784,5 +784,5 @@
       return OPTIMAL;
     }
-    
+
     // Check if the upper bound is greater or equal to the lower bound
     // on each arc.
@@ -961,5 +961,5 @@
       buildResidualNetwork();
       while (true) {
-        
+
         typename HwMmc::TerminationCause hw_tc =
             hw_mmc.findCycleMean(hw_iter_limit);
@@ -977,5 +977,5 @@
           hw_mmc.findCycle();
         }
-        
+
         // Compute delta value
         Value delta = INF;
Index: lemon/dfs.h
===================================================================
--- lemon/dfs.h	(revision 1250)
+++ lemon/dfs.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/dijkstra.h
===================================================================
--- lemon/dijkstra.h	(revision 1250)
+++ lemon/dijkstra.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/dimacs.h
===================================================================
--- lemon/dimacs.h	(revision 956)
+++ lemon/dimacs.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/edge_set.h
===================================================================
--- lemon/edge_set.h	(revision 956)
+++ lemon/edge_set.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/edmonds_karp.h
===================================================================
--- lemon/edmonds_karp.h	(revision 1250)
+++ lemon/edmonds_karp.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -37,5 +37,5 @@
   struct EdmondsKarpDefaultTraits {
 
-    /// \brief The digraph type the algorithm runs on. 
+    /// \brief The digraph type the algorithm runs on.
     typedef GR Digraph;
 
@@ -61,5 +61,5 @@
     /// \brief Instantiates a FlowMap.
     ///
-    /// This function instantiates a \ref FlowMap. 
+    /// This function instantiates a \ref FlowMap.
     /// \param digraph The digraph for which we would like to define
     /// the flow map.
@@ -96,5 +96,5 @@
   /// \tparam GR The type of the digraph the algorithm runs on.
   /// \tparam CAP The type of the capacity map. The default map
-  /// type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>". 
+  /// type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
   /// \tparam TR The traits class that defines various types used by the
   /// algorithm. By default, it is \ref EdmondsKarpDefaultTraits
@@ -105,7 +105,7 @@
 #ifdef DOXYGEN
   template <typename GR, typename CAP, typename TR>
-#else 
+#else
   template <typename GR,
-	    typename CAP = typename GR::template ArcMap<int>,
+            typename CAP = typename GR::template ArcMap<int>,
             typename TR = EdmondsKarpDefaultTraits<GR, CAP> >
 #endif
@@ -121,5 +121,5 @@
     typedef typename Traits::CapacityMap CapacityMap;
     /// The type of the flow values.
-    typedef typename Traits::Value Value; 
+    typedef typename Traits::Value Value;
 
     /// The type of the flow map.
@@ -132,5 +132,5 @@
     TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
     typedef typename Digraph::template NodeMap<Arc> PredMap;
-    
+
     const Digraph& _graph;
     const CapacityMap* _capacity;
@@ -143,5 +143,5 @@
     PredMap* _pred;
     std::vector<Node> _queue;
-    
+
     Tolerance _tolerance;
     Value _flow_value;
@@ -149,9 +149,9 @@
     void createStructures() {
       if (!_flow) {
-	_flow = Traits::createFlowMap(_graph);
-	_local_flow = true;
+        _flow = Traits::createFlowMap(_graph);
+        _local_flow = true;
       }
       if (!_pred) {
-	_pred = new PredMap(_graph);
+        _pred = new PredMap(_graph);
       }
       _queue.resize(countNodes(_graph));
@@ -160,11 +160,11 @@
     void destroyStructures() {
       if (_local_flow) {
-	delete _flow;
+        delete _flow;
       }
       if (_pred) {
-	delete _pred;
-      }
-    }
-    
+        delete _pred;
+      }
+    }
+
   public:
 
@@ -179,5 +179,5 @@
       typedef T FlowMap;
       static FlowMap *createFlowMap(const Digraph&) {
-	LEMON_ASSERT(false, "FlowMap is not initialized");
+        LEMON_ASSERT(false, "FlowMap is not initialized");
         return 0;
       }
@@ -190,5 +190,5 @@
     /// type
     template <typename T>
-    struct SetFlowMap 
+    struct SetFlowMap
       : public EdmondsKarp<Digraph, CapacityMap, SetFlowMapTraits<T> > {
       typedef EdmondsKarp<Digraph, CapacityMap, SetFlowMapTraits<T> > Create;
@@ -198,5 +198,5 @@
 
   protected:
-    
+
     EdmondsKarp() {}
 
@@ -205,13 +205,13 @@
     /// \brief The constructor of the class.
     ///
-    /// The constructor of the class. 
-    /// \param digraph The digraph the algorithm runs on. 
-    /// \param capacity The capacity of the arcs. 
+    /// The constructor of the class.
+    /// \param digraph The digraph the algorithm runs on.
+    /// \param capacity The capacity of the arcs.
     /// \param source The source node.
     /// \param target The target node.
     EdmondsKarp(const Digraph& digraph, const CapacityMap& capacity,
-		Node source, Node target)
+                Node source, Node target)
       : _graph(digraph), _capacity(&capacity), _source(source), _target(target),
-	_flow(0), _local_flow(false), _pred(0), _tolerance(), _flow_value()
+        _flow(0), _local_flow(false), _pred(0), _tolerance(), _flow_value()
     {
       LEMON_ASSERT(_source != _target,
@@ -245,6 +245,6 @@
     EdmondsKarp& flowMap(FlowMap& map) {
       if (_local_flow) {
-	delete _flow;
-	_local_flow = false;
+        delete _flow;
+        _local_flow = false;
       }
       _flow = &map;
@@ -277,5 +277,5 @@
       _tolerance = tolerance;
       return *this;
-    } 
+    }
 
     /// \brief Returns a const reference to the tolerance.
@@ -285,5 +285,5 @@
     const Tolerance& tolerance() const {
       return _tolerance;
-    } 
+    }
 
     /// \name Execution control
@@ -292,5 +292,5 @@
     /// you have to call one of the \ref init() functions first, then
     /// \ref start() or multiple times the \ref augment() function.
-    
+
     ///@{
 
@@ -306,5 +306,5 @@
       _flow_value = 0;
     }
-    
+
     /// \brief Initializes the algorithm using the given flow map.
     ///
@@ -318,5 +318,5 @@
       createStructures();
       for (ArcIt e(_graph); e != INVALID; ++e) {
-	_flow->set(e, flowMap[e]);
+        _flow->set(e, flowMap[e]);
       }
       _flow_value = 0;
@@ -335,5 +335,5 @@
     /// contain a feasible flow, i.e. at each node excluding the source
     /// and the target, the incoming flow should be equal to the
-    /// outgoing flow. 
+    /// outgoing flow.
     /// \return \c false when the given \c flowMap does not contain a
     /// feasible flow.
@@ -342,5 +342,5 @@
       createStructures();
       for (ArcIt e(_graph); e != INVALID; ++e) {
-	_flow->set(e, flowMap[e]);
+        _flow->set(e, flowMap[e]);
       }
       for (NodeIt it(_graph); it != INVALID; ++it) {
@@ -373,5 +373,5 @@
 
     /// \brief Augments the solution along a shortest path.
-    /// 
+    ///
     /// Augments the solution along a shortest path. This function searches a
     /// shortest path between the source and the target
@@ -384,72 +384,72 @@
     bool augment() {
       for (NodeIt n(_graph); n != INVALID; ++n) {
-	_pred->set(n, INVALID);
-      }
-      
+        _pred->set(n, INVALID);
+      }
+
       int first = 0, last = 1;
-      
+
       _queue[0] = _source;
       _pred->set(_source, OutArcIt(_graph, _source));
 
       while (first != last && (*_pred)[_target] == INVALID) {
-	Node n = _queue[first++];
-	
-	for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-	  Value rem = (*_capacity)[e] - (*_flow)[e];
-	  Node t = _graph.target(e);
-	  if (_tolerance.positive(rem) && (*_pred)[t] == INVALID) {
-	    _pred->set(t, e);
-	    _queue[last++] = t;
-	  }
-	}
-	for (InArcIt e(_graph, n); e != INVALID; ++e) {
-	  Value rem = (*_flow)[e];
-	  Node t = _graph.source(e);
-	  if (_tolerance.positive(rem) && (*_pred)[t] == INVALID) {
-	    _pred->set(t, e);
-	    _queue[last++] = t;
-	  }
-	}
+        Node n = _queue[first++];
+
+        for (OutArcIt e(_graph, n); e != INVALID; ++e) {
+          Value rem = (*_capacity)[e] - (*_flow)[e];
+          Node t = _graph.target(e);
+          if (_tolerance.positive(rem) && (*_pred)[t] == INVALID) {
+            _pred->set(t, e);
+            _queue[last++] = t;
+          }
+        }
+        for (InArcIt e(_graph, n); e != INVALID; ++e) {
+          Value rem = (*_flow)[e];
+          Node t = _graph.source(e);
+          if (_tolerance.positive(rem) && (*_pred)[t] == INVALID) {
+            _pred->set(t, e);
+            _queue[last++] = t;
+          }
+        }
       }
 
       if ((*_pred)[_target] != INVALID) {
-	Node n = _target;
-	Arc e = (*_pred)[n];
-
-	Value prem = (*_capacity)[e] - (*_flow)[e];
-	n = _graph.source(e);
-	while (n != _source) {
-	  e = (*_pred)[n];
-	  if (_graph.target(e) == n) {
-	    Value rem = (*_capacity)[e] - (*_flow)[e];
-	    if (rem < prem) prem = rem;
-	    n = _graph.source(e);
-	  } else {
-	    Value rem = (*_flow)[e];
-	    if (rem < prem) prem = rem;
-	    n = _graph.target(e);   
-	  } 
-	}
-
-	n = _target;
-	e = (*_pred)[n];
-
-	_flow->set(e, (*_flow)[e] + prem);
-	n = _graph.source(e);
-	while (n != _source) {
-	  e = (*_pred)[n];
-	  if (_graph.target(e) == n) {
-	    _flow->set(e, (*_flow)[e] + prem);
-	    n = _graph.source(e);
-	  } else {
-	    _flow->set(e, (*_flow)[e] - prem);
-	    n = _graph.target(e);   
-	  } 
-	}
-
-	_flow_value += prem;	
-	return true;
+        Node n = _target;
+        Arc e = (*_pred)[n];
+
+        Value prem = (*_capacity)[e] - (*_flow)[e];
+        n = _graph.source(e);
+        while (n != _source) {
+          e = (*_pred)[n];
+          if (_graph.target(e) == n) {
+            Value rem = (*_capacity)[e] - (*_flow)[e];
+            if (rem < prem) prem = rem;
+            n = _graph.source(e);
+          } else {
+            Value rem = (*_flow)[e];
+            if (rem < prem) prem = rem;
+            n = _graph.target(e);
+          }
+        }
+
+        n = _target;
+        e = (*_pred)[n];
+
+        _flow->set(e, (*_flow)[e] + prem);
+        n = _graph.source(e);
+        while (n != _source) {
+          e = (*_pred)[n];
+          if (_graph.target(e) == n) {
+            _flow->set(e, (*_flow)[e] + prem);
+            n = _graph.source(e);
+          } else {
+            _flow->set(e, (*_flow)[e] - prem);
+            n = _graph.target(e);
+          }
+        }
+
+        _flow_value += prem;
+        return true;
       } else {
-	return false;
+        return false;
       }
     }
@@ -458,5 +458,5 @@
     ///
     /// Executes the algorithm by performing augmenting phases until the
-    /// optimal solution is reached. 
+    /// optimal solution is reached.
     /// \pre One of the \ref init() functions must be called before
     /// using this function.
@@ -466,8 +466,8 @@
 
     /// \brief Runs the algorithm.
-    /// 
+    ///
     /// Runs the Edmonds-Karp algorithm.
     /// \note ek.run() is just a shortcut of the following code.
-    ///\code 
+    ///\code
     /// ek.init();
     /// ek.start();
@@ -484,5 +484,5 @@
     /// functions.\n
     /// Either \ref run() or \ref start() should be called before using them.
-    
+
     ///@{
 
@@ -543,8 +543,8 @@
     void minCutMap(CutMap& cutMap) const {
       for (NodeIt n(_graph); n != INVALID; ++n) {
-	cutMap.set(n, (*_pred)[n] != INVALID);
+        cutMap.set(n, (*_pred)[n] != INVALID);
       }
       cutMap.set(_source, true);
-    }    
+    }
 
     /// @}
Index: lemon/euler.h
===================================================================
--- lemon/euler.h	(revision 1023)
+++ lemon/euler.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/fractional_matching.h
===================================================================
--- lemon/fractional_matching.h	(revision 1250)
+++ lemon/fractional_matching.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/full_graph.h
===================================================================
--- lemon/full_graph.h	(revision 1193)
+++ lemon/full_graph.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -875,5 +875,5 @@
     static int id(Arc e) { return e._id; }
     static int id(Edge e) { return e._id; }
-    
+
     static Node nodeFromId(int id) { return Node(id);}
     static Arc arcFromId(int id) { return Arc(id);}
@@ -905,5 +905,5 @@
       return n._id - _red_num;
     }
-        
+
     void clear() {
       _red_num = 0; _blue_num = 0;
@@ -911,5 +911,5 @@
     }
 
-    Edge edge(const Node& u, const Node& v) const { 
+    Edge edge(const Node& u, const Node& v) const {
       if (u._id < _red_num) {
         if (v._id < _red_num) {
@@ -927,5 +927,5 @@
     }
 
-    Arc arc(const Node& u, const Node& v) const { 
+    Arc arc(const Node& u, const Node& v) const {
       if (u._id < _red_num) {
         if (v._id < _red_num) {
Index: lemon/glpk.cc
===================================================================
--- lemon/glpk.cc	(revision 1231)
+++ lemon/glpk.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/glpk.h
===================================================================
--- lemon/glpk.h	(revision 1250)
+++ lemon/glpk.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -149,5 +149,5 @@
 #ifdef DOXYGEN
     /// Write the problem or the solution to a file in the given format
-    
+
     /// This function writes the problem or the solution
     /// to a file in the given format.
Index: lemon/gomory_hu.h
===================================================================
--- lemon/gomory_hu.h	(revision 1254)
+++ lemon/gomory_hu.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/graph_to_eps.h
===================================================================
--- lemon/graph_to_eps.h	(revision 1249)
+++ lemon/graph_to_eps.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/greedy_tsp.h
===================================================================
--- lemon/greedy_tsp.h	(revision 1250)
+++ lemon/greedy_tsp.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -68,7 +68,7 @@
       Cost _sum;
       std::vector<Node> _path;
-      
+
     private:
-    
+
       // Functor class to compare edges by their costs
       class EdgeComp {
Index: lemon/grosso_locatelli_pullan_mc.h
===================================================================
--- lemon/grosso_locatelli_pullan_mc.h	(revision 1221)
+++ lemon/grosso_locatelli_pullan_mc.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -121,9 +121,9 @@
     BoolMatrix _gr;
     int _n;
-    
+
     // Search options
     bool _delta_based_restart;
     int _restart_delta_limit;
- 
+
     // Search limits
     int _iteration_limit;
@@ -443,10 +443,10 @@
     /// \name Execution Control
     /// The \ref run() function can be used to execute the algorithm.\n
-    /// The functions \ref iterationLimit(int), \ref stepLimit(int), and 
+    /// The functions \ref iterationLimit(int), \ref stepLimit(int), and
     /// \ref sizeLimit(int) can be used to specify various limits for the
     /// search process.
-    
+
     /// @{
-    
+
     /// \brief Sets the maximum number of iterations.
     ///
@@ -460,5 +460,5 @@
     /// likely finds larger cliques. For smaller values, the algorithm is
     /// faster but probably gives worse results.
-    /// 
+    ///
     /// The default value is \c 1000.
     /// \c -1 means that number of iterations is not limited.
@@ -475,5 +475,5 @@
       return *this;
     }
-    
+
     /// \brief Sets the maximum number of search steps.
     ///
@@ -487,5 +487,5 @@
     /// likely finds larger cliques. For smaller values, the algorithm is
     /// faster but probably gives worse results.
-    /// 
+    ///
     /// The default value is \c -1, which means that number of steps
     /// is not limited explicitly. However, the number of iterations is
@@ -503,5 +503,5 @@
       return *this;
     }
-    
+
     /// \brief Sets the desired clique size.
     ///
@@ -509,9 +509,9 @@
     /// limit. If a clique of this size (or a larger one) is found, then the
     /// algorithm terminates.
-    /// 
+    ///
     /// This function is especially useful if you know an exact upper bound
-    /// for the size of the cliques in the graph or if any clique above 
+    /// for the size of the cliques in the graph or if any clique above
     /// a certain size limit is sufficient for your application.
-    /// 
+    ///
     /// The default value is \c -1, which means that the size limit is set to
     /// the number of nodes in the graph.
@@ -525,5 +525,5 @@
       return *this;
     }
-    
+
     /// \brief The maximum number of iterations.
     ///
@@ -535,5 +535,5 @@
       return _iteration_limit;
     }
-    
+
     /// \brief The maximum number of search steps.
     ///
@@ -545,5 +545,5 @@
       return _step_limit;
     }
-    
+
     /// \brief The desired clique size.
     ///
@@ -584,5 +584,5 @@
     /// \name Query Functions
     /// The results of the algorithm can be obtained using these functions.\n
-    /// The run() function must be called before using them. 
+    /// The run() function must be called before using them.
 
     /// @{
@@ -677,5 +677,5 @@
 
   private:
-  
+
     // Initialize search options and limits
     void initOptions() {
@@ -683,5 +683,5 @@
       _delta_based_restart = true;
       _restart_delta_limit = 4;
-     
+
       // Search limits
       _iteration_limit = 1000;
Index: lemon/hao_orlin.h
===================================================================
--- lemon/hao_orlin.h	(revision 1019)
+++ lemon/hao_orlin.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/hartmann_orlin_mmc.h
===================================================================
--- lemon/hartmann_orlin_mmc.h	(revision 1254)
+++ lemon/hartmann_orlin_mmc.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/howard_mmc.h
===================================================================
--- lemon/howard_mmc.h	(revision 1250)
+++ lemon/howard_mmc.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -156,8 +156,8 @@
     /// these values.
     enum TerminationCause {
-      
+
       /// No directed cycle can be found in the digraph.
       NO_CYCLE = 0,
-    
+
       /// Optimal solution (minimum cycle mean) is found.
       OPTIMAL = 1,
@@ -357,9 +357,9 @@
     ///
     /// \param limit  The maximum allowed number of iterations during
-    /// the search process. Its default value implies that the algorithm 
+    /// the search process. Its default value implies that the algorithm
     /// runs until it finds the exact optimal solution.
     ///
     /// \return The termination cause of the search process.
-    /// For more information, see \ref TerminationCause. 
+    /// For more information, see \ref TerminationCause.
     TerminationCause findCycleMean(int limit = std::numeric_limits<int>::max()) {
       // Initialize and find strongly connected components
@@ -390,5 +390,5 @@
           _best_node = _curr_node;
         }
-        
+
         if (iter_limit_reached) break;
       }
Index: lemon/insertion_tsp.h
===================================================================
--- lemon/insertion_tsp.h	(revision 1250)
+++ lemon/insertion_tsp.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -361,5 +361,5 @@
               Node u = _notused[i];
               Cost min_cost = costDiff(_tour.back(), _tour.front(), u);
-              int min_pos = 0;              
+              int min_pos = 0;
               for (unsigned int j=1; j<_tour.size(); ++j) {
                 Cost curr_cost = costDiff(_tour[j-1], _tour[j], u);
@@ -391,5 +391,5 @@
             _notused[min_node] = _notused.back();
             _notused.pop_back();
-            
+
             // Insert the selected node into the tour
             const int ipos = _ins_pos[sn];
@@ -406,5 +406,5 @@
               Cost nc1 = costDiff(_tour[ipos_prev], _tour[ipos], u);
               Cost nc2 = costDiff(_tour[ipos], _tour[ipos_next], u);
-              
+
               if (nc1 <= curr_cost || nc2 <= curr_cost) {
                 // A new position is better than the old one
@@ -421,5 +421,5 @@
                   // The minimum should be found again
                   curr_cost = costDiff(_tour.back(), _tour.front(), u);
-                  curr_pos = 0;              
+                  curr_pos = 0;
                   for (unsigned int j=1; j<_tour.size(); ++j) {
                     Cost tmp_cost = costDiff(_tour[j-1], _tour[j], u);
@@ -434,5 +434,5 @@
                 }
               }
-              
+
               _ins_cost[u] = curr_cost;
               _ins_pos[u] = curr_pos;
Index: lemon/karp_mmc.h
===================================================================
--- lemon/karp_mmc.h	(revision 1254)
+++ lemon/karp_mmc.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/kruskal.h
===================================================================
--- lemon/kruskal.h	(revision 1025)
+++ lemon/kruskal.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/lgf_reader.h
===================================================================
--- lemon/lgf_reader.h	(revision 1250)
+++ lemon/lgf_reader.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -2639,5 +2639,5 @@
         _red_node_index.insert(std::make_pair(converter(map[n]), n));
       }
-      for (BlueNodeIt n(_graph); n != INVALID; ++n) {      
+      for (BlueNodeIt n(_graph); n != INVALID; ++n) {
         _blue_node_index.insert(std::make_pair(converter(map[n]), n));
       }
Index: lemon/lgf_writer.h
===================================================================
--- lemon/lgf_writer.h	(revision 1250)
+++ lemon/lgf_writer.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -186,5 +186,5 @@
       ValueStorage(const Value& value, const Converter& converter = Converter())
         : _value(value), _converter(converter) {}
-      
+
       virtual std::string get() {
         return _converter(_value);
Index: lemon/list_graph.h
===================================================================
--- lemon/list_graph.h	(revision 1217)
+++ lemon/list_graph.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -1766,5 +1766,5 @@
     void next(BlueNode& node) const {
       node.id = nodes[node.id].partition_next;
-    }    
+    }
 
     void first(Arc& e) const {
Index: lemon/lp.h
===================================================================
--- lemon/lp.h	(revision 1232)
+++ lemon/lp.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/lp_base.cc
===================================================================
--- lemon/lp_base.cc	(revision 956)
+++ lemon/lp_base.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/lp_base.h
===================================================================
--- lemon/lp_base.h	(revision 1252)
+++ lemon/lp_base.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -1029,5 +1029,5 @@
       }
     };
-    
+
   protected:
     virtual void _write(std::string, std::string format) const
@@ -1035,5 +1035,5 @@
       throw UnsupportedFormatError(format);
     }
-    
+
   public:
 
Index: lemon/lp_skeleton.cc
===================================================================
--- lemon/lp_skeleton.cc	(revision 1231)
+++ lemon/lp_skeleton.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/lp_skeleton.h
===================================================================
--- lemon/lp_skeleton.h	(revision 1231)
+++ lemon/lp_skeleton.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/maps.h
===================================================================
--- lemon/maps.h	(revision 1057)
+++ lemon/maps.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/matching.h
===================================================================
--- lemon/matching.h	(revision 956)
+++ lemon/matching.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/math.h
===================================================================
--- lemon/math.h	(revision 1222)
+++ lemon/math.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/max_cardinality_search.h
===================================================================
--- lemon/max_cardinality_search.h	(revision 1129)
+++ lemon/max_cardinality_search.h	(revision 1270)
@@ -1,7 +1,7 @@
-/* -*- C++ -*-
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
  *
- * 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-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -22,5 +22,5 @@
 
 /// \ingroup search
-/// \file 
+/// \file
 /// \brief Maximum cardinality search in undirected digraphs.
 
@@ -42,5 +42,5 @@
   template <typename GR, typename CAP>
   struct MaxCardinalitySearchDefaultTraits {
-    /// The digraph type the algorithm runs on. 
+    /// The digraph type the algorithm runs on.
     typedef GR Digraph;
 
@@ -51,5 +51,5 @@
 
       static CapacityMap *createCapacityMap(const Digraph& g) {
-	return new CapacityMap(g);
+        return new CapacityMap(g);
       }
     };
@@ -61,5 +61,5 @@
 
       static CapacityMap *createCapacityMap(const Digraph&) {
-	return new CapacityMap;
+        return new CapacityMap;
       }
     };
@@ -91,15 +91,15 @@
     /// \brief Instantiates a HeapCrossRef.
     ///
-    /// This function instantiates a \ref HeapCrossRef. 
-    /// \param digraph is the digraph, to which we would like to define the 
+    /// This function instantiates a \ref HeapCrossRef.
+    /// \param digraph is the digraph, to which we would like to define the
     /// HeapCrossRef.
     static HeapCrossRef *createHeapCrossRef(const Digraph &digraph) {
       return new HeapCrossRef(digraph);
     }
-    
+
     template <typename CapacityMap>
     struct HeapSelector {
       template <typename Value, typename Ref>
-      struct Selector { 
+      struct Selector {
         typedef BinHeap<Value, Ref, std::greater<Value> > Heap;
       };
@@ -129,5 +129,5 @@
     /// \brief Instantiates a Heap.
     ///
-    /// This function instantiates a \ref Heap. 
+    /// This function instantiates a \ref Heap.
     /// \param crossref The cross reference of the heap.
     static Heap *createHeap(HeapCrossRef& crossref) {
@@ -144,5 +144,5 @@
     /// \brief Instantiates a ProcessedMap.
     ///
-    /// This function instantiates a \ref ProcessedMap. 
+    /// This function instantiates a \ref ProcessedMap.
     /// \param digraph is the digraph, to which
     /// we would like to define the \ref ProcessedMap
@@ -157,5 +157,5 @@
 
     /// \brief The type of the map that stores the cardinalities of the nodes.
-    /// 
+    ///
     /// The type of the map that stores the cardinalities of the nodes.
     /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
@@ -164,6 +164,6 @@
     /// \brief Instantiates a CardinalityMap.
     ///
-    /// This function instantiates a \ref CardinalityMap. 
-    /// \param digraph is the digraph, to which we would like to define the \ref 
+    /// This function instantiates a \ref CardinalityMap.
+    /// \param digraph is the digraph, to which we would like to define the \ref
     /// CardinalityMap
     static CardinalityMap *createCardinalityMap(const Digraph &digraph) {
@@ -173,11 +173,11 @@
 
   };
-  
+
   /// \ingroup search
   ///
   /// \brief Maximum Cardinality Search algorithm class.
   ///
-  /// This class provides an efficient implementation of Maximum Cardinality 
-  /// Search algorithm. The maximum cardinality search first chooses any 
+  /// This class provides an efficient implementation of Maximum Cardinality
+  /// Search algorithm. The maximum cardinality search first chooses any
   /// node of the digraph. Then every time it chooses one unprocessed node
   /// with maximum cardinality, i.e the sum of capacities on out arcs to the nodes
@@ -187,8 +187,8 @@
 
   /// The arc capacities are passed to the algorithm using a
-  /// \ref concepts::ReadMap "ReadMap", so it is easy to change it to any 
+  /// \ref concepts::ReadMap "ReadMap", so it is easy to change it to any
   /// kind of capacity.
   ///
-  /// The type of the capacity is determined by the \ref 
+  /// The type of the capacity is determined by the \ref
   /// concepts::ReadMap::Value "Value" of the capacity map.
   ///
@@ -197,18 +197,18 @@
   ///
   /// \param GR The digraph type the algorithm runs on. The value of
-  /// Digraph is not used directly by the search algorithm, it 
+  /// Digraph is not used directly by the search algorithm, it
   /// is only passed to \ref MaxCardinalitySearchDefaultTraits.
-  /// \param CAP This read-only ArcMap determines the capacities of 
+  /// \param CAP This read-only ArcMap determines the capacities of
   /// the arcs. It is read once for each arc, so the map may involve in
   /// relatively time consuming process to compute the arc capacity if
   /// it is necessary. The default map type is \ref
   /// ConstMap "ConstMap<concepts::Digraph::Arc, Const<int,1> >". The value
-  /// of CapacityMap is not used directly by search algorithm, it is only 
-  /// passed to \ref MaxCardinalitySearchDefaultTraits.  
-  /// \param TR Traits class to set various data types used by the 
-  /// algorithm.  The default traits class is 
-  /// \ref MaxCardinalitySearchDefaultTraits 
-  /// "MaxCardinalitySearchDefaultTraits<GR, CAP>".  
-  /// See \ref MaxCardinalitySearchDefaultTraits 
+  /// of CapacityMap is not used directly by search algorithm, it is only
+  /// passed to \ref MaxCardinalitySearchDefaultTraits.
+  /// \param TR Traits class to set various data types used by the
+  /// algorithm.  The default traits class is
+  /// \ref MaxCardinalitySearchDefaultTraits
+  /// "MaxCardinalitySearchDefaultTraits<GR, CAP>".
+  /// See \ref MaxCardinalitySearchDefaultTraits
   /// for the documentation of a MaxCardinalitySearch traits class.
 
@@ -216,7 +216,7 @@
   template <typename GR, typename CAP, typename TR>
 #else
-  template <typename GR, typename CAP = 
-	    ConstMap<typename GR::Arc, Const<int,1> >,
-	    typename TR = 
+  template <typename GR, typename CAP =
+            ConstMap<typename GR::Arc, Const<int,1> >,
+            typename TR =
             MaxCardinalitySearchDefaultTraits<GR, CAP> >
 #endif
@@ -227,5 +227,5 @@
     ///The type of the underlying digraph.
     typedef typename Traits::Digraph Digraph;
-    
+
     ///The type of the capacity of the arcs.
     typedef typename Traits::CapacityMap::Value Value;
@@ -267,5 +267,5 @@
 
     typedef MaxCardinalitySearch Create;
- 
+
     ///\name Named template parameters
 
@@ -276,9 +276,9 @@
       typedef T CapacityMap;
       static CapacityMap *createCapacityMap(const Digraph &) {
-       	LEMON_ASSERT(false,"Uninitialized parameter.");
-	return 0;
-      }
-    };
-    /// \brief \ref named-templ-param "Named parameter" for setting 
+               LEMON_ASSERT(false,"Uninitialized parameter.");
+        return 0;
+      }
+    };
+    /// \brief \ref named-templ-param "Named parameter" for setting
     /// CapacityMap type
     ///
@@ -286,8 +286,8 @@
     /// for the algorithm.
     template <class T>
-    struct SetCapacityMap 
-      : public MaxCardinalitySearch<Digraph, CapacityMap, 
-                                    DefCapacityMapTraits<T> > { 
-      typedef MaxCardinalitySearch<Digraph, CapacityMap, 
+    struct SetCapacityMap
+      : public MaxCardinalitySearch<Digraph, CapacityMap,
+                                    DefCapacityMapTraits<T> > {
+      typedef MaxCardinalitySearch<Digraph, CapacityMap,
                                    DefCapacityMapTraits<T> > Create;
     };
@@ -296,32 +296,32 @@
     struct DefCardinalityMapTraits : public Traits {
       typedef T CardinalityMap;
-      static CardinalityMap *createCardinalityMap(const Digraph &) 
+      static CardinalityMap *createCardinalityMap(const Digraph &)
       {
-	LEMON_ASSERT(false,"Uninitialized parameter.");
-	return 0;
-      }
-    };
-    /// \brief \ref named-templ-param "Named parameter" for setting 
+        LEMON_ASSERT(false,"Uninitialized parameter.");
+        return 0;
+      }
+    };
+    /// \brief \ref named-templ-param "Named parameter" for setting
     /// CardinalityMap type
     ///
-    /// \ref named-templ-param "Named parameter" for setting CardinalityMap 
+    /// \ref named-templ-param "Named parameter" for setting CardinalityMap
     /// type for the algorithm.
     template <class T>
-    struct SetCardinalityMap 
-      : public MaxCardinalitySearch<Digraph, CapacityMap, 
-                                    DefCardinalityMapTraits<T> > { 
-      typedef MaxCardinalitySearch<Digraph, CapacityMap, 
+    struct SetCardinalityMap
+      : public MaxCardinalitySearch<Digraph, CapacityMap,
+                                    DefCardinalityMapTraits<T> > {
+      typedef MaxCardinalitySearch<Digraph, CapacityMap,
                                    DefCardinalityMapTraits<T> > Create;
     };
-    
+
     template <class T>
     struct DefProcessedMapTraits : public Traits {
       typedef T ProcessedMap;
       static ProcessedMap *createProcessedMap(const Digraph &) {
-       	LEMON_ASSERT(false,"Uninitialized parameter.");
-	return 0;
-      }
-    };
-    /// \brief \ref named-templ-param "Named parameter" for setting 
+               LEMON_ASSERT(false,"Uninitialized parameter.");
+        return 0;
+      }
+    };
+    /// \brief \ref named-templ-param "Named parameter" for setting
     /// ProcessedMap type
     ///
@@ -329,11 +329,11 @@
     /// for the algorithm.
     template <class T>
-    struct SetProcessedMap 
-      : public MaxCardinalitySearch<Digraph, CapacityMap, 
-                                    DefProcessedMapTraits<T> > { 
-      typedef MaxCardinalitySearch<Digraph, CapacityMap, 
+    struct SetProcessedMap
+      : public MaxCardinalitySearch<Digraph, CapacityMap,
+                                    DefProcessedMapTraits<T> > {
+      typedef MaxCardinalitySearch<Digraph, CapacityMap,
                                    DefProcessedMapTraits<T> > Create;
     };
-    
+
     template <class H, class CR>
     struct DefHeapTraits : public Traits {
@@ -341,22 +341,22 @@
       typedef H Heap;
       static HeapCrossRef *createHeapCrossRef(const Digraph &) {
-     	LEMON_ASSERT(false,"Uninitialized parameter.");
-	return 0;
+             LEMON_ASSERT(false,"Uninitialized parameter.");
+        return 0;
       }
       static Heap *createHeap(HeapCrossRef &) {
-       	LEMON_ASSERT(false,"Uninitialized parameter.");
-	return 0;
-      }
-    };
-    /// \brief \ref named-templ-param "Named parameter" for setting heap 
+               LEMON_ASSERT(false,"Uninitialized parameter.");
+        return 0;
+      }
+    };
+    /// \brief \ref named-templ-param "Named parameter" for setting heap
     /// and cross reference type
     ///
-    /// \ref named-templ-param "Named parameter" for setting heap and cross 
+    /// \ref named-templ-param "Named parameter" for setting heap and cross
     /// reference type for the algorithm.
     template <class H, class CR = typename Digraph::template NodeMap<int> >
     struct SetHeap
-      : public MaxCardinalitySearch<Digraph, CapacityMap, 
-                                    DefHeapTraits<H, CR> > { 
-      typedef MaxCardinalitySearch< Digraph, CapacityMap, 
+      : public MaxCardinalitySearch<Digraph, CapacityMap,
+                                    DefHeapTraits<H, CR> > {
+      typedef MaxCardinalitySearch< Digraph, CapacityMap,
                                     DefHeapTraits<H, CR> > Create;
     };
@@ -367,27 +367,27 @@
       typedef H Heap;
       static HeapCrossRef *createHeapCrossRef(const Digraph &digraph) {
-	return new HeapCrossRef(digraph);
+        return new HeapCrossRef(digraph);
       }
       static Heap *createHeap(HeapCrossRef &crossref) {
-	return new Heap(crossref);
-      }
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting heap and 
+        return new Heap(crossref);
+      }
+    };
+
+    /// \brief \ref named-templ-param "Named parameter" for setting heap and
     /// cross reference type with automatic allocation
     ///
-    /// \ref named-templ-param "Named parameter" for setting heap and cross 
-    /// reference type. It can allocate the heap and the cross reference 
-    /// object if the cross reference's constructor waits for the digraph as 
+    /// \ref named-templ-param "Named parameter" for setting heap and cross
+    /// reference type. It can allocate the heap and the cross reference
+    /// object if the cross reference's constructor waits for the digraph as
     /// parameter and the heap's constructor waits for the cross reference.
     template <class H, class CR = typename Digraph::template NodeMap<int> >
     struct SetStandardHeap
-      : public MaxCardinalitySearch<Digraph, CapacityMap, 
-                                    DefStandardHeapTraits<H, CR> > { 
-      typedef MaxCardinalitySearch<Digraph, CapacityMap, 
-                                   DefStandardHeapTraits<H, CR> > 
+      : public MaxCardinalitySearch<Digraph, CapacityMap,
+                                    DefStandardHeapTraits<H, CR> > {
+      typedef MaxCardinalitySearch<Digraph, CapacityMap,
+                                   DefStandardHeapTraits<H, CR> >
       Create;
     };
-    
+
     ///@}
 
@@ -397,6 +397,6 @@
     MaxCardinalitySearch() {}
 
-  public:      
-    
+  public:
+
     /// \brief Constructor.
     ///
@@ -404,5 +404,5 @@
     ///\param capacity the capacity map used by the algorithm.
     MaxCardinalitySearch(const Digraph& digraph,
-			 const CapacityMap& capacity) :
+                         const CapacityMap& capacity) :
       _graph(&digraph),
       _capacity(&capacity), local_capacity(false),
@@ -442,6 +442,6 @@
     MaxCardinalitySearch &capacityMap(const CapacityMap &m) {
       if (local_capacity) {
-	delete _capacity;
-	local_capacity=false;
+        delete _capacity;
+        local_capacity=false;
       }
       _capacity=&m;
@@ -457,5 +457,5 @@
     }
 
-    /// \brief Sets the map storing the cardinalities calculated by the 
+    /// \brief Sets the map storing the cardinalities calculated by the
     /// algorithm.
     ///
@@ -467,6 +467,6 @@
     MaxCardinalitySearch &cardinalityMap(CardinalityMap &m) {
       if(local_cardinality) {
-	delete _cardinality;
-	local_cardinality=false;
+        delete _cardinality;
+        local_cardinality=false;
       }
       _cardinality = &m;
@@ -481,9 +481,9 @@
     /// automatically allocated map, of course.
     /// \return <tt> (*this) </tt>
-    MaxCardinalitySearch &processedMap(ProcessedMap &m) 
+    MaxCardinalitySearch &processedMap(ProcessedMap &m)
     {
       if(local_processed) {
-	delete _processed;
-	local_processed=false;
+        delete _processed;
+        local_processed=false;
       }
       _processed = &m;
@@ -508,11 +508,11 @@
     MaxCardinalitySearch &heap(Heap& hp, HeapCrossRef &cr) {
       if(local_heap_cross_ref) {
-	delete _heap_cross_ref;
-	local_heap_cross_ref = false;
+        delete _heap_cross_ref;
+        local_heap_cross_ref = false;
       }
       _heap_cross_ref = &cr;
       if(local_heap) {
-	delete _heap;
-	local_heap = false;
+        delete _heap;
+        local_heap = false;
       }
       _heap = &hp;
@@ -545,25 +545,25 @@
     void create_maps() {
       if(!_capacity) {
-	local_capacity = true;
-	_capacity = Traits::createCapacityMap(*_graph);
+        local_capacity = true;
+        _capacity = Traits::createCapacityMap(*_graph);
       }
       if(!_cardinality) {
-	local_cardinality = true;
-	_cardinality = Traits::createCardinalityMap(*_graph);
+        local_cardinality = true;
+        _cardinality = Traits::createCardinalityMap(*_graph);
       }
       if(!_processed) {
-	local_processed = true;
-	_processed = Traits::createProcessedMap(*_graph);
+        local_processed = true;
+        _processed = Traits::createProcessedMap(*_graph);
       }
       if (!_heap_cross_ref) {
-	local_heap_cross_ref = true;
-	_heap_cross_ref = Traits::createHeapCrossRef(*_graph);
+        local_heap_cross_ref = true;
+        _heap_cross_ref = Traits::createHeapCrossRef(*_graph);
       }
       if (!_heap) {
-	local_heap = true;
-	_heap = Traits::createHeap(*_heap_cross_ref);
-      }
-    }
-    
+        local_heap = true;
+        _heap = Traits::createHeap(*_heap_cross_ref);
+      }
+    }
+
     void finalizeNodeData(Node node, Value capacity) {
       _processed->set(node, true);
@@ -590,11 +590,11 @@
       _heap->clear();
       for (NodeIt it(*_graph) ; it != INVALID ; ++it) {
-	_processed->set(it, false);
-	_heap_cross_ref->set(it, Heap::PRE_HEAP);
-      }
-    }
-    
+        _processed->set(it, false);
+        _heap_cross_ref->set(it, Heap::PRE_HEAP);
+      }
+    }
+
     /// \brief Adds a new source node.
-    /// 
+    ///
     /// Adds a new source node to the priority heap.
     ///
@@ -602,8 +602,8 @@
     void addSource(Node source, Value capacity = 0) {
       if(_heap->state(source) == Heap::PRE_HEAP) {
-	_heap->push(source, capacity);
-      } 
-    }
-    
+        _heap->push(source, capacity);
+      }
+    }
+
     /// \brief Processes the next node in the priority heap
     ///
@@ -614,20 +614,20 @@
     /// \warning The priority heap must not be empty!
     Node processNextNode() {
-      Node node = _heap->top(); 
+      Node node = _heap->top();
       finalizeNodeData(node, _heap->prio());
       _heap->pop();
-      
+
       for (InArcIt it(*_graph, node); it != INVALID; ++it) {
-	Node source = _graph->source(it);
-	switch (_heap->state(source)) {
-	case Heap::PRE_HEAP:
-	  _heap->push(source, (*_capacity)[it]);
-	  break;
-	case Heap::IN_HEAP:
-	  _heap->decrease(source, (*_heap)[source] + (*_capacity)[it]);
-	  break;
-	case Heap::POST_HEAP:
-	  break;
-	}
+        Node source = _graph->source(it);
+        switch (_heap->state(source)) {
+        case Heap::PRE_HEAP:
+          _heap->push(source, (*_capacity)[it]);
+          break;
+        case Heap::IN_HEAP:
+          _heap->decrease(source, (*_heap)[source] + (*_capacity)[it]);
+          break;
+        case Heap::POST_HEAP:
+          break;
+        }
       }
       return node;
@@ -638,10 +638,10 @@
     /// Next node to be processed.
     ///
-    /// \return The next node to be processed or INVALID if the 
+    /// \return The next node to be processed or INVALID if the
     /// priority heap is empty.
-    Node nextNode() { 
+    Node nextNode() {
       return !_heap->empty() ? _heap->top() : INVALID;
     }
- 
+
     /// \brief Returns \c false if there are nodes
     /// to be processed in the priority heap
@@ -650,10 +650,10 @@
     /// to be processed in the priority heap
     bool emptyQueue() { return _heap->empty(); }
-    /// \brief Returns the number of the nodes to be processed 
+    /// \brief Returns the number of the nodes to be processed
     /// in the priority heap
     ///
     /// Returns the number of the nodes to be processed in the priority heap
     int emptySize() { return _heap->size(); }
-    
+
     /// \brief Executes the algorithm.
     ///
@@ -663,10 +663,10 @@
     /// with addSource() before using this function.
     ///
-    /// This method runs the Maximum Cardinality Search algorithm from the 
+    /// This method runs the Maximum Cardinality Search algorithm from the
     /// source node(s).
     void start() {
       while ( !_heap->empty() ) processNextNode();
     }
-    
+
     /// \brief Executes the algorithm until \c dest is reached.
     ///
@@ -676,5 +676,5 @@
     /// with addSource() before using this function.
     ///
-    /// This method runs the %MaxCardinalitySearch algorithm from the source 
+    /// This method runs the %MaxCardinalitySearch algorithm from the source
     /// nodes.
     void start(Node dest) {
@@ -682,5 +682,5 @@
       if ( !_heap->empty() ) finalizeNodeData(_heap->top(), _heap->prio());
     }
-    
+
     /// \brief Executes the algorithm until a condition is met.
     ///
@@ -697,8 +697,8 @@
       if ( !_heap->empty() ) finalizeNodeData(_heap->top(),_heap->prio());
     }
-    
+
     /// \brief Runs the maximum cardinality search algorithm from node \c s.
     ///
-    /// This method runs the %MaxCardinalitySearch algorithm from a root 
+    /// This method runs the %MaxCardinalitySearch algorithm from a root
     /// node \c s.
     ///
@@ -715,8 +715,8 @@
     }
 
-    /// \brief Runs the maximum cardinality search algorithm for the 
+    /// \brief Runs the maximum cardinality search algorithm for the
     /// whole digraph.
     ///
-    /// This method runs the %MaxCardinalitySearch algorithm from all 
+    /// This method runs the %MaxCardinalitySearch algorithm from all
     /// unprocessed node of the digraph.
     ///
@@ -740,14 +740,14 @@
       }
     }
-    
+
     ///@}
 
     /// \name Query Functions
-    /// The results of the maximum cardinality search algorithm can be 
+    /// The results of the maximum cardinality search algorithm can be
     /// obtained using these functions.
     /// \n
-    /// Before the use of these functions, either run() or start() must be 
+    /// Before the use of these functions, either run() or start() must be
     /// called.
-    
+
     ///@{
 
@@ -768,8 +768,8 @@
     /// \brief Returns a reference to the NodeMap of cardinalities.
     ///
-    /// Returns a reference to the NodeMap of cardinalities. \pre \ref run() 
+    /// Returns a reference to the NodeMap of cardinalities. \pre \ref run()
     /// must be called before using this function.
     const CardinalityMap &cardinalityMap() const { return *_cardinality;}
- 
+
     /// \brief Checks if a node is reachable from the root.
     ///
@@ -785,5 +785,5 @@
     /// \pre \ref run() must be called before using this function.
     bool processed(Node v) { return (*_heap_cross_ref)[v] == Heap::POST_HEAP; }
-    
+
     ///@}
   };
Index: lemon/min_cost_arborescence.h
===================================================================
--- lemon/min_cost_arborescence.h	(revision 1254)
+++ lemon/min_cost_arborescence.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/nagamochi_ibaraki.h
===================================================================
--- lemon/nagamochi_ibaraki.h	(revision 1130)
+++ lemon/nagamochi_ibaraki.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -304,6 +304,6 @@
     //This is here to avoid a gcc-3.3 compilation error.
     //It should never be called.
-    NagamochiIbaraki() {} 
-    
+    NagamochiIbaraki() {}
+
   public:
 
@@ -415,10 +415,10 @@
         for (typename Graph::OutArcIt a(_graph, n); a != INVALID; ++a) {
           typename Graph::Node m = _graph.target(a);
-          
+
           if (!(n < m)) continue;
 
           (*_nodes)[n].sum += (*_capacity)[a];
           (*_nodes)[m].sum += (*_capacity)[a];
-          
+
           int c = (*_nodes)[m].curr_arc;
           if (c != -1 && _arcs[c ^ 1].target == n) {
@@ -426,5 +426,5 @@
           } else {
             _edges[index].capacity = (*_capacity)[a];
-            
+
             _arcs[index << 1].prev = -1;
             if ((*_nodes)[n].first_arc != -1) {
@@ -436,5 +436,5 @@
 
             (*_nodes)[m].curr_arc = (index << 1);
-            
+
             _arcs[(index << 1) | 1].prev = -1;
             if ((*_nodes)[m].first_arc != -1) {
@@ -444,5 +444,5 @@
             (*_nodes)[m].first_arc = ((index << 1) | 1);
             _arcs[(index << 1) | 1].target = n;
-            
+
             ++index;
           }
@@ -453,5 +453,5 @@
       _min_cut = std::numeric_limits<Value>::max();
 
-      for (typename Graph::Node n = _first_node; 
+      for (typename Graph::Node n = _first_node;
            n != INVALID; n = (*_nodes)[n].next) {
         if ((*_nodes)[n].sum < _min_cut) {
@@ -478,5 +478,5 @@
 
       _heap->clear();
-      for (typename Graph::Node n = _first_node; 
+      for (typename Graph::Node n = _first_node;
            n != INVALID; n = (*_nodes)[n].next) {
         (*_heap_cross_ref)[n] = Heap::PRE_HEAP;
@@ -498,5 +498,5 @@
         for (int a = (*_nodes)[n].first_arc; a != -1; a = _arcs[a].next) {
           switch (_heap->state(_arcs[a].target)) {
-          case Heap::PRE_HEAP: 
+          case Heap::PRE_HEAP:
             {
               Value nv = _edges[a >> 1].capacity;
@@ -564,5 +564,5 @@
             if (!merged) {
               for (int b = (*_nodes)[n].first_arc; b != -1; b = _arcs[b].next) {
-                (*_nodes)[_arcs[b].target].curr_arc = b;          
+                (*_nodes)[_arcs[b].target].curr_arc = b;
               }
               merged = true;
@@ -574,5 +574,5 @@
               if ((b ^ a) == 1) continue;
               typename Graph::Node o = _arcs[b].target;
-              int c = (*_nodes)[o].curr_arc; 
+              int c = (*_nodes)[o].curr_arc;
               if (c != -1 && _arcs[c ^ 1].target == n) {
                 _edges[c >> 1].capacity += _edges[b >> 1].capacity;
@@ -607,5 +607,5 @@
             } else {
               (*_nodes)[n].first_arc = _arcs[a].next;
-            }            
+            }
             if (_arcs[a].next != -1) {
               _arcs[_arcs[a].next].prev = _arcs[a].prev;
@@ -615,5 +615,5 @@
             (*_next_rep)[(*_nodes)[n].last_rep] = m;
             (*_nodes)[n].last_rep = (*_nodes)[m].last_rep;
-            
+
             if ((*_nodes)[m].prev != INVALID) {
               (*_nodes)[(*_nodes)[m].prev].next = (*_nodes)[m].next;
Index: lemon/nearest_neighbor_tsp.h
===================================================================
--- lemon/nearest_neighbor_tsp.h	(revision 1250)
+++ lemon/nearest_neighbor_tsp.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/network_simplex.h
===================================================================
--- lemon/network_simplex.h	(revision 1254)
+++ lemon/network_simplex.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -1235,5 +1235,5 @@
       return true;
     }
-    
+
     // Check if the upper bound is greater or equal to the lower bound
     // on each arc.
Index: lemon/opt2_tsp.h
===================================================================
--- lemon/opt2_tsp.h	(revision 1250)
+++ lemon/opt2_tsp.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/path.h
===================================================================
--- lemon/path.h	(revision 1212)
+++ lemon/path.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/planarity.h
===================================================================
--- lemon/planarity.h	(revision 1160)
+++ lemon/planarity.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/preflow.h
===================================================================
--- lemon/preflow.h	(revision 1254)
+++ lemon/preflow.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -555,8 +555,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;
     }
@@ -586,5 +586,5 @@
           level = _level->highestActiveLevel();
           --num;
-          
+
           Value excess = (*_excess)[n];
           int new_level = _level->maxLevel();
Index: lemon/radix_sort.h
===================================================================
--- lemon/radix_sort.h	(revision 1210)
+++ lemon/radix_sort.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/smart_graph.h
===================================================================
--- lemon/smart_graph.h	(revision 1193)
+++ lemon/smart_graph.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -1264,5 +1264,5 @@
             max_red = -1;
           }
-          Parent::notifier(RedNode()).erase(asRedNodeUnsafe(node));          
+          Parent::notifier(RedNode()).erase(asRedNodeUnsafe(node));
         } else {
           first_blue = nodes[n].partition_next;
Index: lemon/soplex.cc
===================================================================
--- lemon/soplex.cc	(revision 956)
+++ lemon/soplex.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/soplex.h
===================================================================
--- lemon/soplex.h	(revision 956)
+++ lemon/soplex.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/suurballe.h
===================================================================
--- lemon/suurballe.h	(revision 1254)
+++ lemon/suurballe.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/time_measure.h
===================================================================
--- lemon/time_measure.h	(revision 1222)
+++ lemon/time_measure.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -99,5 +99,5 @@
     static Format format() { return _format; }
 
-    
+
     ///Read the current time values of the process
     void stamp()
@@ -523,5 +523,5 @@
     ///       on destruction.
     TimeReport(std::string title,std::ostream &os=std::cerr,bool run=true,
-	       bool active=true)
+               bool active=true)
       : Timer(run), _title(title), _os(os), _active(active) {}
     ///Destructor that prints the ellapsed time
@@ -530,5 +530,5 @@
       if(_active) _os << _title << *this << std::endl;
     }
-    
+
     ///Retrieve the activity status
 
Index: lemon/unionfind.h
===================================================================
--- lemon/unionfind.h	(revision 956)
+++ lemon/unionfind.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/adaptors_test.cc
===================================================================
--- test/adaptors_test.cc	(revision 1259)
+++ test/adaptors_test.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/arc_look_up_test.cc
===================================================================
--- test/arc_look_up_test.cc	(revision 1149)
+++ test/arc_look_up_test.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -69,15 +69,15 @@
   std::istringstream lgfs(lgf);
   DigraphReader<ListDigraph>(graph, lgfs).run();
-  
+
   AllArcLookUp<ListDigraph> lookup(graph);
-	
+
   int numArcs = countArcs(graph);
-	
+
   int arcCnt = 0;
   for(ListDigraph::NodeIt n1(graph); n1 != INVALID; ++n1)
     for(ListDigraph::NodeIt n2(graph); n2 != INVALID; ++n2)
       for(ListDigraph::Arc a = lookup(n1, n2); a != INVALID;
-	  a = lookup(n1, n2, a))
-	++arcCnt;
+          a = lookup(n1, n2, a))
+        ++arcCnt;
   check(arcCnt==numArcs, "Wrong total number of arcs");
 
Index: test/bellman_ford_test.cc
===================================================================
--- test/bellman_ford_test.cc	(revision 1260)
+++ test/bellman_ford_test.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/bfs_test.cc
===================================================================
--- test/bfs_test.cc	(revision 1259)
+++ test/bfs_test.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/bpgraph_test.cc
===================================================================
--- test/bpgraph_test.cc	(revision 1194)
+++ test/bpgraph_test.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -114,5 +114,5 @@
   BpGraph G;
   RedNode
-    n1 = G.addRedNode(), n4 = G.addRedNode(); 
+    n1 = G.addRedNode(), n4 = G.addRedNode();
   BlueNode
     n2 = G.addBlueNode(), n3 = G.addBlueNode();
@@ -162,5 +162,5 @@
   BpGraph G;
   RedNode
-    n1 = G.addRedNode(), n4 = G.addRedNode(); 
+    n1 = G.addRedNode(), n4 = G.addRedNode();
   BlueNode
     n2 = G.addBlueNode(), n3 = G.addBlueNode();
@@ -217,5 +217,5 @@
     n2 = G.addBlueNode(),
     n3 = G.addBlueNode();
-  Edge 
+  Edge
     e1 = G.addEdge(n1, n2),
     e2 = G.addEdge(n1, n3);
Index: test/circulation_test.cc
===================================================================
--- test/circulation_test.cc	(revision 1259)
+++ test/circulation_test.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/connectivity_test.cc
===================================================================
--- test/connectivity_test.cc	(revision 1268)
+++ test/connectivity_test.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/dfs_test.cc
===================================================================
--- test/dfs_test.cc	(revision 1261)
+++ test/dfs_test.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -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/digraph_test.cc
===================================================================
--- test/digraph_test.cc	(revision 1260)
+++ test/digraph_test.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/dijkstra_test.cc
===================================================================
--- test/dijkstra_test.cc	(revision 1259)
+++ test/dijkstra_test.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/edge_set_test.cc
===================================================================
--- test/edge_set_test.cc	(revision 1259)
+++ test/edge_set_test.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/euler_test.cc
===================================================================
--- test/euler_test.cc	(revision 1259)
+++ test/euler_test.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -103,5 +103,5 @@
     Digraph::Node n = d.addNode();
     ::lemon::ignore_unused_variable_warning(n);
-  
+
     checkDiEulerIt(d);
     checkDiEulerIt(g);
Index: test/fractional_matching_test.cc
===================================================================
--- test/fractional_matching_test.cc	(revision 1260)
+++ test/fractional_matching_test.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/gomory_hu_test.cc
===================================================================
--- test/gomory_hu_test.cc	(revision 1259)
+++ test/gomory_hu_test.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/graph_copy_test.cc
===================================================================
--- test/graph_copy_test.cc	(revision 1194)
+++ test/graph_copy_test.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -54,5 +54,5 @@
     }
   }
-  
+
   // Test digraph copy
   GR to;
@@ -73,5 +73,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.");
@@ -101,5 +101,5 @@
   // Test repeated copy
   digraphCopy(from, to).run();
-  
+
   check(countNodes(from) == countNodes(to), "Wrong copy.");
   check(countArcs(from) == countArcs(to), "Wrong copy.");
@@ -204,5 +204,5 @@
   // Test repeated copy
   graphCopy(from, to).run();
-  
+
   check(countNodes(from) == countNodes(to), "Wrong copy.");
   check(countEdges(from) == countEdges(to), "Wrong copy.");
@@ -367,5 +367,5 @@
   // Test repeated copy
   bpGraphCopy(from, to).run();
-  
+
   check(countNodes(from) == countNodes(to), "Wrong copy.");
   check(countRedNodes(from) == countRedNodes(to), "Wrong copy.");
Index: test/graph_test.cc
===================================================================
--- test/graph_test.cc	(revision 1259)
+++ test/graph_test.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/graph_test.h
===================================================================
--- test/graph_test.h	(revision 1195)
+++ test/graph_test.h	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/hao_orlin_test.cc
===================================================================
--- test/hao_orlin_test.cc	(revision 1259)
+++ test/hao_orlin_test.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/heap_test.cc
===================================================================
--- test/heap_test.cc	(revision 1065)
+++ test/heap_test.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/lgf_reader_writer_test.cc
===================================================================
--- test/lgf_reader_writer_test.cc	(revision 1198)
+++ test/lgf_reader_writer_test.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -386,5 +386,5 @@
   writer.arcMap("arc_map1", arc_map);
   writer.arcMap("arc_map2", arc_map, WriterConverter());
-  writer.node("node", n2); 
+  writer.node("node", n2);
   writer.edge("edge", e1);
   writer.arc("arc", graph.direct(e1, false));
@@ -493,5 +493,5 @@
   writer.arcMap("arc_map2", arc_map, WriterConverter());
   writer.node("node", n);
-  writer.redNode("red_node", rn1); 
+  writer.redNode("red_node", rn1);
   writer.blueNode("blue_node", bn2);
   writer.edge("edge", e1);
Index: test/lgf_test.cc
===================================================================
--- test/lgf_test.cc	(revision 1087)
+++ test/lgf_test.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2011
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -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 1247)
+++ test/lp_test.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/maps_test.cc
===================================================================
--- test/maps_test.cc	(revision 1261)
+++ test/maps_test.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/matching_test.cc
===================================================================
--- test/matching_test.cc	(revision 1259)
+++ test/matching_test.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/max_cardinality_search_test.cc
===================================================================
--- test/max_cardinality_search_test.cc	(revision 1088)
+++ test/max_cardinality_search_test.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -68,5 +68,5 @@
   ProcMap proc;
   HeapCrossRef crossref(g);
-  
+
   typedef MaxCardinalitySearch<Digraph,CapMap>
     ::SetCapacityMap<CapMap>
@@ -82,5 +82,5 @@
   MaxCardType::Heap& heap = const_cast<MaxCardType::Heap&>(heap_const);
   maxcard.heap(heap,crossref);
-  
+
   maxcard.capacityMap(cap).cardinalityMap(card).processedMap(proc);
 
Index: test/max_clique_test.cc
===================================================================
--- test/max_clique_test.cc	(revision 1022)
+++ test/max_clique_test.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -55,5 +55,5 @@
   "5 7    14\n"
   "6 7    15\n";
-      
+
 
 // Check with general graphs
@@ -63,5 +63,5 @@
   typedef GrossoLocatelliPullanMc<GR> McAlg;
   typedef McAlg::CliqueNodeIt CliqueIt;
-  
+
   // Basic tests
   {
@@ -82,5 +82,5 @@
     check(static_cast<GR::Node>(it1) == u && ++it1 == INVALID,
           "Wrong CliqueNodeIt");
-    
+
     GR::Node v = g.addNode();
     check(mc.run(rule) == McAlg::ITERATION_LIMIT, "Wrong termination cause");
@@ -110,5 +110,5 @@
       .nodeMap("max_clique", max_clique)
       .run();
-    
+
     McAlg mc(g);
     mc.iterationLimit(50);
@@ -134,5 +134,5 @@
   typedef GrossoLocatelliPullanMc<FullGraph> McAlg;
   typedef McAlg::CliqueNodeIt CliqueIt;
-  
+
   for (int size = 0; size <= 40; size = size * 3 + 1) {
     GR g(size);
@@ -157,5 +157,5 @@
   GridGraph::NodeMap<char> map(g);
   GrossoLocatelliPullanMc<GridGraph> mc(g);
-  
+
   mc.iterationLimit(100);
   check(mc.run(rule) == mc.ITERATION_LIMIT, "Wrong termination cause");
@@ -180,9 +180,9 @@
   checkMaxCliqueFullGraph(GrossoLocatelliPullanMc<FullGraph>::DEGREE_BASED);
   checkMaxCliqueFullGraph(GrossoLocatelliPullanMc<FullGraph>::PENALTY_BASED);
-                       
+
   checkMaxCliqueGridGraph(GrossoLocatelliPullanMc<GridGraph>::RANDOM);
   checkMaxCliqueGridGraph(GrossoLocatelliPullanMc<GridGraph>::DEGREE_BASED);
   checkMaxCliqueGridGraph(GrossoLocatelliPullanMc<GridGraph>::PENALTY_BASED);
-                       
+
   return 0;
 }
Index: test/max_flow_test.cc
===================================================================
--- test/max_flow_test.cc	(revision 1262)
+++ test/max_flow_test.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -223,5 +223,5 @@
 {
   DIGRAPH_TYPEDEFS(SmartDigraph);
-  
+
   SmartDigraph g;
   SmartDigraph::ArcMap<int> cap(g),iflow(g);
@@ -383,5 +383,5 @@
   checkMaxFlowAlg<PType2, PreflowStartFunctions<PType2> >();
   initFlowTest();
-  
+
   // Check EdmondsKarp
   typedef EdmondsKarp<SmartDigraph, SmartDigraph::ArcMap<int> > EKType1;
@@ -391,5 +391,5 @@
 
   initFlowTest();
-  
+
   return 0;
 }
Index: test/min_cost_arborescence_test.cc
===================================================================
--- test/min_cost_arborescence_test.cc	(revision 1259)
+++ test/min_cost_arborescence_test.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/min_cost_flow_test.cc
===================================================================
--- test/min_cost_flow_test.cc	(revision 956)
+++ test/min_cost_flow_test.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/min_mean_cycle_test.cc
===================================================================
--- test/min_mean_cycle_test.cc	(revision 1178)
+++ test/min_mean_cycle_test.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -211,5 +211,5 @@
     checkMmcAlg<HowardMmc<GR, IntArcMap> >(gr, l3, c3,  0, 1);
     checkMmcAlg<HowardMmc<GR, IntArcMap> >(gr, l4, c4, -1, 1);
-    
+
     // Howard with iteration limit
     HowardMmc<GR, IntArcMap> mmc(gr, l1);
Index: test/nagamochi_ibaraki_test.cc
===================================================================
--- test/nagamochi_ibaraki_test.cc	(revision 1262)
+++ test/nagamochi_ibaraki_test.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/path_test.cc
===================================================================
--- test/path_test.cc	(revision 1212)
+++ test/path_test.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/radix_sort_test.cc
===================================================================
--- test/radix_sort_test.cc	(revision 1211)
+++ test/radix_sort_test.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -53,5 +53,5 @@
 template<class T>
 T listsort(typename T::iterator b, typename T::iterator e)
-{ 
+{
   if(b==e) return T();
   typename T::iterator bn=b;
Index: test/suurballe_test.cc
===================================================================
--- test/suurballe_test.cc	(revision 1259)
+++ test/suurballe_test.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/time_measure_test.cc
===================================================================
--- test/time_measure_test.cc	(revision 1257)
+++ test/time_measure_test.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2009
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/tsp_test.cc
===================================================================
--- test/tsp_test.cc	(revision 1205)
+++ test/tsp_test.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -42,5 +42,5 @@
 //   check(checkMetricCost(g, constMap<Edge>(1)), "Wrong checkMetricCost()");
 //   check(!checkMetricCost(g, constMap<Edge>(-1)), "Wrong checkMetricCost()");
-//   
+//
 //   FullGraph::EdgeMap<float> cost(g);
 //   for (NodeIt u(g); u != INVALID; ++u) {
@@ -65,5 +65,5 @@
 bool checkTour(const FullGraph &gr, const Container &p) {
   FullGraph::NodeMap<bool> used(gr, false);
-  
+
   int node_cnt = 0;
   for (typename Container::const_iterator it = p.begin(); it != p.end(); ++it) {
@@ -73,5 +73,5 @@
     ++node_cnt;
   }
-  
+
   return (node_cnt == gr.nodeNum());
 }
@@ -80,5 +80,5 @@
 bool checkTourPath(const FullGraph &gr, const Path<FullGraph> &p) {
   FullGraph::NodeMap<bool> used(gr, false);
-  
+
   if (!checkPath(gr, p)) return false;
   if (gr.nodeNum() <= 1 && p.length() != 0) return false;
@@ -182,5 +182,5 @@
       }
     }
-    
+
     check(alg.run() > 0, alg_name + ": Wrong total cost");
 
@@ -196,5 +196,5 @@
     check(checkCost(g, path, cost, alg.tourCost()),
       alg_name + ": Wrong tour cost");
-    
+
     check(!Tolerance<double>().less(alg.tourCost(), opt2.run(alg.tourNodes())),
       "2-opt improvement: Wrong total cost");
@@ -203,5 +203,5 @@
     check(checkCost(g, opt2.tourNodes(), cost, opt2.tourCost()),
       "2-opt improvement: Wrong tour cost");
-    
+
     check(!Tolerance<double>().less(alg.tourCost(), opt2.run(path)),
       "2-opt improvement: Wrong total cost");
@@ -213,5 +213,5 @@
 }
 
-// Algorithm class for Nearest Insertion 
+// Algorithm class for Nearest Insertion
 template <typename CM>
 class NearestInsertionTsp : public InsertionTsp<CM> {
@@ -224,5 +224,5 @@
 };
 
-// Algorithm class for Farthest Insertion 
+// Algorithm class for Farthest Insertion
 template <typename CM>
 class FarthestInsertionTsp : public InsertionTsp<CM> {
@@ -235,5 +235,5 @@
 };
 
-// Algorithm class for Cheapest Insertion 
+// Algorithm class for Cheapest Insertion
 template <typename CM>
 class CheapestInsertionTsp : public InsertionTsp<CM> {
@@ -246,5 +246,5 @@
 };
 
-// Algorithm class for Random Insertion 
+// Algorithm class for Random Insertion
 template <typename CM>
 class RandomInsertionTsp : public InsertionTsp<CM> {
Index: tools/dimacs-solver.cc
===================================================================
--- tools/dimacs-solver.cc	(revision 1169)
+++ tools/dimacs-solver.cc	(revision 1270)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2013
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
