Index: lemon/bits/alteration_notifier.h
===================================================================
--- lemon/bits/alteration_notifier.h	(revision 157)
+++ lemon/bits/alteration_notifier.h	(revision 209)
@@ -1,5 +1,5 @@
-/* -*- 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-2008
@@ -33,5 +33,5 @@
   /// \ingroup graphbits
   ///
-  /// \brief Notifier class to notify observes about alterations in 
+  /// \brief Notifier class to notify observes about alterations in
   /// a container.
   ///
@@ -50,5 +50,5 @@
   /// alteration of the graph.
   ///
-  /// This class provides an interface to the container. The \e first() and \e 
+  /// This class provides an interface to the container. The \e first() and \e
   /// next() member functions make possible to iterate on the keys of the
   /// container. The \e id() function returns an integer id for each key.
@@ -61,5 +61,5 @@
   /// from the graph. If all items are erased from the graph or from an empty
   /// graph a new graph is builded then it can be signaled with the
-  /// clear() and build() members. Important rule that if we erase items 
+  /// clear() and build() members. Important rule that if we erase items
   /// from graph we should first signal the alteration and after that erase
   /// them from the container, on the other way on item addition we should
@@ -69,5 +69,5 @@
   /// \e ObserverBase nested class. The signals can be handled with
   /// overriding the virtual functions defined in the base class.  The
-  /// observer base can be attached to the notifier with the 
+  /// observer base can be attached to the notifier with the
   /// \e attach() member and can be detached with detach() function. The
   /// alteration handlers should not call any function which signals
@@ -80,5 +80,5 @@
   /// be rolled back by calling the \e erase() or \e clear()
   /// functions. Thence the \e erase() and \e clear() should not throw
-  /// exception. Actullay, it can be throw only 
+  /// exception. Actullay, it can be throw only
   /// \ref AlterationObserver::ImmediateDetach ImmediateDetach
   /// exception which detach the observer from the notifier.
@@ -86,5 +86,5 @@
   /// There are some place when the alteration observing is not completly
   /// reliable. If we want to carry out the node degree in the graph
-  /// as in the \ref InDegMap and we use the reverseEdge that cause 
+  /// as in the \ref InDegMap and we use the reverseEdge that cause
   /// unreliable functionality. Because the alteration observing signals
   /// only erasing and adding but not the reversing it will stores bad
@@ -105,5 +105,5 @@
     typedef _Item Item;
 
-    /// \brief Exception which can be called from \e clear() and 
+    /// \brief Exception which can be called from \e clear() and
     /// \e erase().
     ///
@@ -128,5 +128,5 @@
     /// The build() and clear() members are to notify the observer
     /// about the container is built from an empty container or
-    /// is cleared to an empty container. 
+    /// is cleared to an empty container.
 
     class ObserverBase {
@@ -139,5 +139,5 @@
       ///
       /// Default constructor for ObserverBase.
-      /// 
+      ///
       ObserverBase() : _notifier(0) {}
 
@@ -152,11 +152,11 @@
       ///
       /// Constructor which attach the obserever to the same notifier as
-      /// the other observer is attached to. 
+      /// the other observer is attached to.
       ObserverBase(const ObserverBase& copy) {
-	if (copy.attached()) {
+        if (copy.attached()) {
           attach(*copy.notifier());
-	}
-      }
-	
+        }
+      }
+
       /// \brief Destructor
       virtual ~ObserverBase() {
@@ -171,7 +171,7 @@
       ///
       void attach(AlterationNotifier& nf) {
-	nf.attach(*this);
-      }
-      
+        nf.attach(*this);
+      }
+
       /// \brief Detaches the observer into an AlterationNotifier.
       ///
@@ -181,6 +181,6 @@
         _notifier->detach(*this);
       }
-      
-      /// \brief Gives back a pointer to the notifier which the map 
+
+      /// \brief Gives back a pointer to the notifier which the map
       /// attached into.
       ///
@@ -189,5 +189,5 @@
       ///
       Notifier* notifier() const { return const_cast<Notifier*>(_notifier); }
-      
+
       /// Gives back true when the observer is attached into a notifier.
       bool attached() const { return _notifier != 0; }
@@ -198,5 +198,5 @@
 
     protected:
-      
+
       Notifier* _notifier;
       typename std::list<ObserverBase*>::iterator _index;
@@ -210,5 +210,5 @@
       virtual void add(const Item&) = 0;
 
-      /// \brief The member function to notificate the observer about 
+      /// \brief The member function to notificate the observer about
       /// more item is added to the container.
       ///
@@ -223,8 +223,8 @@
       /// The erase() member function notificates the observer about an
       /// item is erased from the container. It have to be overrided in
-      /// the subclasses.	
+      /// the subclasses.
       virtual void erase(const Item&) = 0;
 
-      /// \brief The member function to notificate the observer about 
+      /// \brief The member function to notificate the observer about
       /// more item is erased from the container.
       ///
@@ -248,24 +248,24 @@
       /// The clear() member function notificates the observer about all
       /// items are erased from the container. It have to be overrided in
-      /// the subclasses.      
+      /// the subclasses.
       virtual void clear() = 0;
 
     };
-	
+
   protected:
 
     const Container* container;
 
-    typedef std::list<ObserverBase*> Observers; 
+    typedef std::list<ObserverBase*> Observers;
     Observers _observers;
 
-		
+
   public:
 
     /// \brief Default constructor.
     ///
-    /// The default constructor of the AlterationNotifier. 
+    /// The default constructor of the AlterationNotifier.
     /// It creates an empty notifier.
-    AlterationNotifier() 
+    AlterationNotifier()
       : container(0) {}
 
@@ -273,17 +273,17 @@
     ///
     /// Constructor with the observed container parameter.
-    AlterationNotifier(const Container& _container) 
+    AlterationNotifier(const Container& _container)
       : container(&_container) {}
 
-    /// \brief Copy Constructor of the AlterationNotifier. 
-    ///
-    /// Copy constructor of the AlterationNotifier. 
+    /// \brief Copy Constructor of the AlterationNotifier.
+    ///
+    /// Copy constructor of the AlterationNotifier.
     /// It creates only an empty notifier because the copiable
     /// notifier's observers have to be registered still into that notifier.
-    AlterationNotifier(const AlterationNotifier& _notifier) 
+    AlterationNotifier(const AlterationNotifier& _notifier)
       : container(_notifier.container) {}
 
     /// \brief Destructor.
-    ///		
+    ///
     /// Destructor of the AlterationNotifier.
     ///
@@ -291,5 +291,5 @@
       typename Observers::iterator it;
       for (it = _observers.begin(); it != _observers.end(); ++it) {
-	(*it)->_notifier = 0;
+        (*it)->_notifier = 0;
       }
     }
@@ -339,5 +339,5 @@
       return container->maxId(Item());
     }
-		
+
   protected:
 
@@ -345,5 +345,5 @@
       observer._index = _observers.insert(_observers.begin(), &observer);
       observer._notifier = this;
-    } 
+    }
 
     void detach(ObserverBase& observer) {
@@ -354,11 +354,11 @@
 
   public:
-	
-    /// \brief Notifies all the registed observers about an item added to 
-    /// the container.
-    ///
-    /// It notifies all the registed observers about an item added to 
-    /// the container.
-    /// 
+
+    /// \brief Notifies all the registed observers about an item added to
+    /// the container.
+    ///
+    /// It notifies all the registed observers about an item added to
+    /// the container.
+    ///
     void add(const Item& item) {
       typename Observers::reverse_iterator it;
@@ -374,12 +374,12 @@
         throw;
       }
-    }	
-
-    /// \brief Notifies all the registed observers about more item added to 
-    /// the container.
-    ///
-    /// It notifies all the registed observers about more item added to 
-    /// the container.
-    /// 
+    }
+
+    /// \brief Notifies all the registed observers about more item added to
+    /// the container.
+    ///
+    /// It notifies all the registed observers about more item added to
+    /// the container.
+    ///
     void add(const std::vector<Item>& items) {
       typename Observers::reverse_iterator it;
@@ -395,12 +395,12 @@
         throw;
       }
-    }	
-
-    /// \brief Notifies all the registed observers about an item erased from 
-    /// the container.
-    ///	
-    /// It notifies all the registed observers about an item erased from 
-    /// the container.
-    /// 
+    }
+
+    /// \brief Notifies all the registed observers about an item erased from
+    /// the container.
+    ///
+    /// It notifies all the registed observers about an item erased from
+    /// the container.
+    ///
     void erase(const Item& item) throw() {
       typename Observers::iterator it = _observers.begin();
@@ -417,10 +417,10 @@
     }
 
-    /// \brief Notifies all the registed observers about more item erased  
+    /// \brief Notifies all the registed observers about more item erased
     /// from the container.
-    ///	
-    /// It notifies all the registed observers about more item erased from 
-    /// the container.
-    /// 
+    ///
+    /// It notifies all the registed observers about more item erased from
+    /// the container.
+    ///
     void erase(const std::vector<Item>& items) {
       typename Observers::iterator it = _observers.begin();
@@ -437,7 +437,7 @@
     }
 
-    /// \brief Notifies all the registed observers about the container is 
+    /// \brief Notifies all the registed observers about the container is
     /// built.
-    ///		
+    ///
     /// Notifies all the registed observers about the container is built
     /// from an empty container.
@@ -457,5 +457,5 @@
     }
 
-    /// \brief Notifies all the registed observers about all items are 
+    /// \brief Notifies all the registed observers about all items are
     /// erased.
     ///
Index: lemon/bits/array_map.h
===================================================================
--- lemon/bits/array_map.h	(revision 107)
+++ lemon/bits/array_map.h	(revision 209)
@@ -1,5 +1,5 @@
-/* -*- C++ -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library.
  *
  * Copyright (C) 2003-2008
@@ -39,5 +39,5 @@
   /// The ArrayMap template class is graph map structure what
   /// automatically updates the map when a key is added to or erased from
-  /// the map. This map uses the allocators to implement 
+  /// the map. This map uses the allocators to implement
   /// the container functionality.
   ///
@@ -45,8 +45,8 @@
   /// the Value type of the map.
   template <typename _Graph, typename _Item, typename _Value>
-  class ArrayMap 
+  class ArrayMap
     : public ItemSetTraits<_Graph, _Item>::ItemNotifier::ObserverBase {
   public:
-    /// The graph type of the maps. 
+    /// The graph type of the maps.
     typedef _Graph Graph;
     /// The item type of the map.
@@ -70,5 +70,5 @@
     /// The MapBase of the Map which imlements the core regisitry function.
     typedef typename Notifier::ObserverBase Parent;
-		
+
   private:
     typedef std::allocator<Value> Allocator;
@@ -85,12 +85,12 @@
       Item it;
       for (nf->first(it); it != INVALID; nf->next(it)) {
-	int id = nf->id(it);;
-	allocator.construct(&(values[id]), Value());
-      }								
-    }
-
-    /// \brief Constructor to use default value to initialize the map. 
-    ///
-    /// It constructs a map and initialize all of the the map. 
+        int id = nf->id(it);;
+        allocator.construct(&(values[id]), Value());
+      }
+    }
+
+    /// \brief Constructor to use default value to initialize the map.
+    ///
+    /// It constructs a map and initialize all of the the map.
     ArrayMap(const Graph& graph, const Value& value) {
       Parent::attach(graph.notifier(Item()));
@@ -99,15 +99,15 @@
       Item it;
       for (nf->first(it); it != INVALID; nf->next(it)) {
-	int id = nf->id(it);;
-	allocator.construct(&(values[id]), value);
-      }								
+        int id = nf->id(it);;
+        allocator.construct(&(values[id]), value);
+      }
     }
 
     /// \brief Constructor to copy a map of the same map type.
     ///
-    /// Constructor to copy a map of the same map type.     
+    /// Constructor to copy a map of the same map type.
     ArrayMap(const ArrayMap& copy) : Parent() {
       if (copy.attached()) {
-	attach(*copy.notifier());
+        attach(*copy.notifier());
       }
       capacity = copy.capacity;
@@ -117,6 +117,6 @@
       Item it;
       for (nf->first(it); it != INVALID; nf->next(it)) {
-	int id = nf->id(it);;
-	allocator.construct(&(values[id]), copy.values[id]);
+        int id = nf->id(it);;
+        allocator.construct(&(values[id]), copy.values[id]);
       }
     }
@@ -125,8 +125,8 @@
     ///
     /// This operator assigns for each item in the map the
-    /// value mapped to the same item in the copied map.  
+    /// value mapped to the same item in the copied map.
     /// The parameter map should be indiced with the same
     /// itemset because this assign operator does not change
-    /// the container of the map. 
+    /// the container of the map.
     ArrayMap& operator=(const ArrayMap& cmap) {
       return operator=<ArrayMap>(cmap);
@@ -139,5 +139,5 @@
     /// concecpt and could be indiced by the current item set of
     /// the NodeMap. In this case the value for each item
-    /// is assigned by the value of the given ReadMap. 
+    /// is assigned by the value of the given ReadMap.
     template <typename CMap>
     ArrayMap& operator=(const CMap& cmap) {
@@ -152,13 +152,13 @@
 
     /// \brief The destructor of the map.
-    ///     
+    ///
     /// The destructor of the map.
-    virtual ~ArrayMap() {      
+    virtual ~ArrayMap() {
       if (attached()) {
-	clear();
-	detach();
-      }
-    }
-		
+        clear();
+        detach();
+      }
+    }
+
   protected:
 
@@ -169,17 +169,17 @@
   public:
 
-    /// \brief The subscript operator. 
+    /// \brief The subscript operator.
     ///
     /// The subscript operator. The map can be subscripted by the
-    /// actual keys of the graph. 
+    /// actual keys of the graph.
     Value& operator[](const Key& key) {
       int id = Parent::notifier()->id(key);
       return values[id];
-    } 
-		
+    }
+
     /// \brief The const subscript operator.
     ///
     /// The const subscript operator. The map can be subscripted by the
-    /// actual keys of the graph. 
+    /// actual keys of the graph.
     const Value& operator[](const Key& key) const {
       int id = Parent::notifier()->id(key);
@@ -188,5 +188,5 @@
 
     /// \brief Setter function of the map.
-    ///	
+    ///
     /// Setter function of the map. Equivalent with map[key] = val.
     /// This is a compatibility feature with the not dereferable maps.
@@ -198,27 +198,27 @@
 
     /// \brief Adds a new key to the map.
-    ///		
+    ///
     /// It adds a new key to the map. It called by the observer notifier
-    /// and it overrides the add() member function of the observer base.     
+    /// and it overrides the add() member function of the observer base.
     virtual void add(const Key& key) {
       Notifier* nf = Parent::notifier();
       int id = nf->id(key);
       if (id >= capacity) {
-	int new_capacity = (capacity == 0 ? 1 : capacity);
-	while (new_capacity <= id) {
-	  new_capacity <<= 1;
-	}
-	Value* new_values = allocator.allocate(new_capacity);
-	Item it;
-	for (nf->first(it); it != INVALID; nf->next(it)) {
-	  int jd = nf->id(it);;
-	  if (id != jd) {
-	    allocator.construct(&(new_values[jd]), values[jd]);
-	    allocator.destroy(&(values[jd]));
-	  }
-	}
-	if (capacity != 0) allocator.deallocate(values, capacity);
-	values = new_values;
-	capacity = new_capacity;
+        int new_capacity = (capacity == 0 ? 1 : capacity);
+        while (new_capacity <= id) {
+          new_capacity <<= 1;
+        }
+        Value* new_values = allocator.allocate(new_capacity);
+        Item it;
+        for (nf->first(it); it != INVALID; nf->next(it)) {
+          int jd = nf->id(it);;
+          if (id != jd) {
+            allocator.construct(&(new_values[jd]), values[jd]);
+            allocator.destroy(&(values[jd]));
+          }
+        }
+        if (capacity != 0) allocator.deallocate(values, capacity);
+        values = new_values;
+        capacity = new_capacity;
       }
       allocator.construct(&(values[id]), Value());
@@ -226,51 +226,51 @@
 
     /// \brief Adds more new keys to the map.
-    ///		
+    ///
     /// It adds more new keys to the map. It called by the observer notifier
-    /// and it overrides the add() member function of the observer base.     
+    /// and it overrides the add() member function of the observer base.
     virtual void add(const std::vector<Key>& keys) {
       Notifier* nf = Parent::notifier();
       int max_id = -1;
       for (int i = 0; i < int(keys.size()); ++i) {
-	int id = nf->id(keys[i]);
-	if (id > max_id) {
-	  max_id = id;
-	}
+        int id = nf->id(keys[i]);
+        if (id > max_id) {
+          max_id = id;
+        }
       }
       if (max_id >= capacity) {
-	int new_capacity = (capacity == 0 ? 1 : capacity);
-	while (new_capacity <= max_id) {
-	  new_capacity <<= 1;
-	}
-	Value* new_values = allocator.allocate(new_capacity);
-	Item it;
-	for (nf->first(it); it != INVALID; nf->next(it)) {
-	  int id = nf->id(it);
-	  bool found = false;
-	  for (int i = 0; i < int(keys.size()); ++i) {
-	    int jd = nf->id(keys[i]);
-	    if (id == jd) {
-	      found = true;
-	      break;
-	    }
-	  }
-	  if (found) continue;
-	  allocator.construct(&(new_values[id]), values[id]);
-	  allocator.destroy(&(values[id]));
-	}
-	if (capacity != 0) allocator.deallocate(values, capacity);
-	values = new_values;
-	capacity = new_capacity;
+        int new_capacity = (capacity == 0 ? 1 : capacity);
+        while (new_capacity <= max_id) {
+          new_capacity <<= 1;
+        }
+        Value* new_values = allocator.allocate(new_capacity);
+        Item it;
+        for (nf->first(it); it != INVALID; nf->next(it)) {
+          int id = nf->id(it);
+          bool found = false;
+          for (int i = 0; i < int(keys.size()); ++i) {
+            int jd = nf->id(keys[i]);
+            if (id == jd) {
+              found = true;
+              break;
+            }
+          }
+          if (found) continue;
+          allocator.construct(&(new_values[id]), values[id]);
+          allocator.destroy(&(values[id]));
+        }
+        if (capacity != 0) allocator.deallocate(values, capacity);
+        values = new_values;
+        capacity = new_capacity;
       }
       for (int i = 0; i < int(keys.size()); ++i) {
-	int id = nf->id(keys[i]);
-	allocator.construct(&(values[id]), Value());
-      }
-    }
-		
+        int id = nf->id(keys[i]);
+        allocator.construct(&(values[id]), Value());
+      }
+    }
+
     /// \brief Erase a key from the map.
     ///
     /// Erase a key from the map. It called by the observer notifier
-    /// and it overrides the erase() member function of the observer base.     
+    /// and it overrides the erase() member function of the observer base.
     virtual void erase(const Key& key) {
       int id = Parent::notifier()->id(key);
@@ -281,16 +281,16 @@
     ///
     /// Erase more keys from the map. It called by the observer notifier
-    /// and it overrides the erase() member function of the observer base.     
+    /// and it overrides the erase() member function of the observer base.
     virtual void erase(const std::vector<Key>& keys) {
       for (int i = 0; i < int(keys.size()); ++i) {
-	int id = Parent::notifier()->id(keys[i]);
-	allocator.destroy(&(values[id]));
+        int id = Parent::notifier()->id(keys[i]);
+        allocator.destroy(&(values[id]));
       }
     }
 
     /// \brief Buildes the map.
-    ///	
+    ///
     /// It buildes the map. It called by the observer notifier
-    /// and it overrides the build() member function of the observer base. 
+    /// and it overrides the build() member function of the observer base.
     virtual void build() {
       Notifier* nf = Parent::notifier();
@@ -298,7 +298,7 @@
       Item it;
       for (nf->first(it); it != INVALID; nf->next(it)) {
-	int id = nf->id(it);;
-	allocator.construct(&(values[id]), Value());
-      }								
+        int id = nf->id(it);;
+        allocator.construct(&(values[id]), Value());
+      }
     }
 
@@ -306,33 +306,33 @@
     ///
     /// It erase all items from the map. It called by the observer notifier
-    /// and it overrides the clear() member function of the observer base.     
-    virtual void clear() {	
+    /// and it overrides the clear() member function of the observer base.
+    virtual void clear() {
       Notifier* nf = Parent::notifier();
       if (capacity != 0) {
-	Item it;
-	for (nf->first(it); it != INVALID; nf->next(it)) {
-	  int id = nf->id(it);
-	  allocator.destroy(&(values[id]));
-	}								
-	allocator.deallocate(values, capacity);
-	capacity = 0;
+        Item it;
+        for (nf->first(it); it != INVALID; nf->next(it)) {
+          int id = nf->id(it);
+          allocator.destroy(&(values[id]));
+        }
+        allocator.deallocate(values, capacity);
+        capacity = 0;
       }
     }
 
   private:
-      
+
     void allocate_memory() {
       int max_id = Parent::notifier()->maxId();
       if (max_id == -1) {
-	capacity = 0;
-	values = 0;
-	return;
+        capacity = 0;
+        values = 0;
+        return;
       }
       capacity = 1;
       while (capacity <= max_id) {
-	capacity <<= 1;
-      }
-      values = allocator.allocate(capacity);	
-    }      
+        capacity <<= 1;
+      }
+      values = allocator.allocate(capacity);
+    }
 
     int capacity;
@@ -340,7 +340,7 @@
     Allocator allocator;
 
-  };		
+  };
 
 }
 
-#endif 
+#endif
Index: lemon/bits/base_extender.h
===================================================================
--- lemon/bits/base_extender.h	(revision 107)
+++ lemon/bits/base_extender.h	(revision 209)
@@ -1,5 +1,5 @@
-/* -*- 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-2008
@@ -64,12 +64,12 @@
 
       bool operator==(const Arc &that) const {
-	return forward==that.forward && Edge(*this)==Edge(that);
+        return forward==that.forward && Edge(*this)==Edge(that);
       }
       bool operator!=(const Arc &that) const {
-	return forward!=that.forward || Edge(*this)!=Edge(that);
+        return forward!=that.forward || Edge(*this)!=Edge(that);
       }
       bool operator<(const Arc &that) const {
-	return forward<that.forward ||
-	  (!(that.forward<forward) && Edge(*this)<Edge(that));
+        return forward<that.forward ||
+          (!(that.forward<forward) && Edge(*this)<Edge(that));
       }
     };
@@ -118,9 +118,9 @@
     void next(Arc &e) const {
       if( e.forward ) {
-	e.forward = false;
+        e.forward = false;
       }
       else {
-	Parent::next(e);
-	e.forward = true;
+        Parent::next(e);
+        e.forward = true;
       }
     }
@@ -129,22 +129,22 @@
       Parent::firstIn(e,n);
       if( Edge(e) != INVALID ) {
-	e.forward = false;
+        e.forward = false;
       }
       else {
-	Parent::firstOut(e,n);
-	e.forward = true;
+        Parent::firstOut(e,n);
+        e.forward = true;
       }
     }
     void nextOut(Arc &e) const {
       if( ! e.forward ) {
-	Node n = Parent::target(e);
-	Parent::nextIn(e);
-	if( Edge(e) == INVALID ) {
-	  Parent::firstOut(e, n);
-	  e.forward = true;
-	}
+        Node n = Parent::target(e);
+        Parent::nextIn(e);
+        if( Edge(e) == INVALID ) {
+          Parent::firstOut(e, n);
+          e.forward = true;
+        }
       }
       else {
-	Parent::nextOut(e);
+        Parent::nextOut(e);
       }
     }
@@ -153,22 +153,22 @@
       Parent::firstOut(e,n);
       if( Edge(e) != INVALID ) {
-	e.forward = false;
+        e.forward = false;
       }
       else {
-	Parent::firstIn(e,n);
-	e.forward = true;
+        Parent::firstIn(e,n);
+        e.forward = true;
       }
     }
     void nextIn(Arc &e) const {
       if( ! e.forward ) {
-	Node n = Parent::source(e);
-	Parent::nextOut(e);
-	if( Edge(e) == INVALID ) {
-	  Parent::firstIn(e, n);
-	  e.forward = true;
-	}
+        Node n = Parent::source(e);
+        Parent::nextOut(e);
+        if( Edge(e) == INVALID ) {
+          Parent::firstIn(e, n);
+          e.forward = true;
+        }
       }
       else {
-	Parent::nextIn(e);
+        Parent::nextIn(e);
       }
     }
@@ -184,11 +184,11 @@
     void nextInc(Edge &e, bool &d) const {
       if (d) {
-	Node s = Parent::source(e);
-	Parent::nextOut(e);
-	if (e != INVALID) return;
-	d = false;
-	Parent::firstIn(e, s);
-      } else {
-	Parent::nextIn(e);
+        Node s = Parent::source(e);
+        Parent::nextOut(e);
+        if (e != INVALID) return;
+        d = false;
+        Parent::firstIn(e, s);
+      } else {
+        Parent::nextIn(e);
       }
     }
@@ -241,16 +241,16 @@
     Arc findArc(Node s, Node t, Arc p = INVALID) const {
       if (p == INVALID) {
-	Edge arc = Parent::findArc(s, t);
-	if (arc != INVALID) return direct(arc, true);
-	arc = Parent::findArc(t, s);
-	if (arc != INVALID) return direct(arc, false);
+        Edge arc = Parent::findArc(s, t);
+        if (arc != INVALID) return direct(arc, true);
+        arc = Parent::findArc(t, s);
+        if (arc != INVALID) return direct(arc, false);
       } else if (direction(p)) {
-	Edge arc = Parent::findArc(s, t, p);
-	if (arc != INVALID) return direct(arc, true);
-	arc = Parent::findArc(t, s);
-	if (arc != INVALID) return direct(arc, false);	
-      } else {
-	Edge arc = Parent::findArc(t, s, p);
-	if (arc != INVALID) return direct(arc, false);	      
+        Edge arc = Parent::findArc(s, t, p);
+        if (arc != INVALID) return direct(arc, true);
+        arc = Parent::findArc(t, s);
+        if (arc != INVALID) return direct(arc, false);
+      } else {
+        Edge arc = Parent::findArc(t, s, p);
+        if (arc != INVALID) return direct(arc, false);
       }
       return INVALID;
@@ -268,8 +268,8 @@
           if (arc != INVALID) return arc;
           arc = Parent::findArc(t, s);
-          if (arc != INVALID) return arc;	
+          if (arc != INVALID) return arc;
         } else {
           Edge arc = Parent::findArc(t, s, p);
-          if (arc != INVALID) return arc;	      
+          if (arc != INVALID) return arc;
         }
       } else {
@@ -300,10 +300,10 @@
       Red() {}
       Red(const Node& node) : Node(node) {
-	LEMON_ASSERT(Parent::red(node) || node == INVALID, 
-		     typename Parent::NodeSetError());
+        LEMON_ASSERT(Parent::red(node) || node == INVALID,
+                     typename Parent::NodeSetError());
       }
       Red& operator=(const Node& node) {
-	LEMON_ASSERT(Parent::red(node) || node == INVALID, 
-		     typename Parent::NodeSetError());
+        LEMON_ASSERT(Parent::red(node) || node == INVALID,
+                     typename Parent::NodeSetError());
         Node::operator=(node);
         return *this;
@@ -332,10 +332,10 @@
       Blue() {}
       Blue(const Node& node) : Node(node) {
-	LEMON_ASSERT(Parent::blue(node) || node == INVALID,
-		     typename Parent::NodeSetError());
+        LEMON_ASSERT(Parent::blue(node) || node == INVALID,
+                     typename Parent::NodeSetError());
       }
       Blue& operator=(const Node& node) {
-	LEMON_ASSERT(Parent::blue(node) || node == INVALID, 
-		     typename Parent::NodeSetError());
+        LEMON_ASSERT(Parent::blue(node) || node == INVALID,
+                     typename Parent::NodeSetError());
         Node::operator=(node);
         return *this;
@@ -354,5 +354,5 @@
       Parent::nextBlue(static_cast<Node&>(node));
     }
-  
+
     int id(const Blue& node) const {
       return Parent::redId(node);
@@ -368,17 +368,17 @@
     void firstInc(Edge& arc, bool& dir, const Node& node) const {
       if (Parent::red(node)) {
-	Parent::firstFromRed(arc, node);
-	dir = true;
-      } else {
-	Parent::firstFromBlue(arc, node);
-	dir = static_cast<Edge&>(arc) == INVALID;
+        Parent::firstFromRed(arc, node);
+        dir = true;
+      } else {
+        Parent::firstFromBlue(arc, node);
+        dir = static_cast<Edge&>(arc) == INVALID;
       }
     }
     void nextInc(Edge& arc, bool& dir) const {
       if (dir) {
-	Parent::nextFromRed(arc);
-      } else {
-	Parent::nextFromBlue(arc);
-	if (arc == INVALID) dir = true;
+        Parent::nextFromRed(arc);
+      } else {
+        Parent::nextFromBlue(arc);
+        if (arc == INVALID) dir = true;
       }
     }
@@ -390,5 +390,5 @@
 
       Arc(const Edge& arc, bool _forward)
-	: Edge(arc), forward(_forward) {}
+        : Edge(arc), forward(_forward) {}
 
     public:
@@ -396,12 +396,12 @@
       Arc (Invalid) : Edge(INVALID), forward(true) {}
       bool operator==(const Arc& i) const {
-	return Edge::operator==(i) && forward == i.forward;
+        return Edge::operator==(i) && forward == i.forward;
       }
       bool operator!=(const Arc& i) const {
-	return Edge::operator!=(i) || forward != i.forward;
+        return Edge::operator!=(i) || forward != i.forward;
       }
       bool operator<(const Arc& i) const {
-	return Edge::operator<(i) || 
-	  (!(i.forward<forward) && Edge(*this)<Edge(i));
+        return Edge::operator<(i) ||
+          (!(i.forward<forward) && Edge(*this)<Edge(i));
       }
     };
@@ -414,5 +414,5 @@
     void next(Arc& arc) const {
       if (!arc.forward) {
-	Parent::next(static_cast<Edge&>(arc));
+        Parent::next(static_cast<Edge&>(arc));
       }
       arc.forward = !arc.forward;
@@ -421,16 +421,16 @@
     void firstOut(Arc& arc, const Node& node) const {
       if (Parent::red(node)) {
-	Parent::firstFromRed(arc, node);
-	arc.forward = true;
-      } else {
-	Parent::firstFromBlue(arc, node);
-	arc.forward = static_cast<Edge&>(arc) == INVALID;
+        Parent::firstFromRed(arc, node);
+        arc.forward = true;
+      } else {
+        Parent::firstFromBlue(arc, node);
+        arc.forward = static_cast<Edge&>(arc) == INVALID;
       }
     }
     void nextOut(Arc& arc) const {
       if (arc.forward) {
-	Parent::nextFromRed(arc);
-      } else {
-	Parent::nextFromBlue(arc);
+        Parent::nextFromRed(arc);
+      } else {
+        Parent::nextFromBlue(arc);
         arc.forward = static_cast<Edge&>(arc) == INVALID;
       }
@@ -439,17 +439,17 @@
     void firstIn(Arc& arc, const Node& node) const {
       if (Parent::blue(node)) {
-	Parent::firstFromBlue(arc, node);
-	arc.forward = true;	
-      } else {
-	Parent::firstFromRed(arc, node);
-	arc.forward = static_cast<Edge&>(arc) == INVALID;
+        Parent::firstFromBlue(arc, node);
+        arc.forward = true;
+      } else {
+        Parent::firstFromRed(arc, node);
+        arc.forward = static_cast<Edge&>(arc) == INVALID;
       }
     }
     void nextIn(Arc& arc) const {
       if (arc.forward) {
-	Parent::nextFromBlue(arc);
-      } else {
-	Parent::nextFromRed(arc);
-	arc.forward = static_cast<Edge&>(arc) == INVALID;
+        Parent::nextFromBlue(arc);
+      } else {
+        Parent::nextFromRed(arc);
+        arc.forward = static_cast<Edge&>(arc) == INVALID;
       }
     }
@@ -463,5 +463,5 @@
 
     int id(const Arc& arc) const {
-      return (Parent::id(static_cast<const Edge&>(arc)) << 1) + 
+      return (Parent::id(static_cast<const Edge&>(arc)) << 1) +
         (arc.forward ? 0 : 1);
     }
Index: lemon/bits/bezier.h
===================================================================
--- lemon/bits/bezier.h	(revision 184)
+++ lemon/bits/bezier.h	(revision 209)
@@ -1,5 +1,5 @@
-/* -*- 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-2008
@@ -45,5 +45,5 @@
   Bezier1() {}
   Bezier1(Point _p1, Point _p2) :p1(_p1), p2(_p2) {}
-  
+
   Point operator()(double t) const
   {
@@ -55,5 +55,5 @@
     return Bezier1(p1,conv(p1,p2,t));
   }
-  
+
   Bezier1 after(double t) const
   {
@@ -88,5 +88,5 @@
     return Bezier2(p1,q,conv(q,r,t));
   }
-  
+
   Bezier2 after(double t) const
   {
@@ -111,14 +111,14 @@
   Bezier3(Point _p1, Point _p2, Point _p3, Point _p4)
     : p1(_p1), p2(_p2), p3(_p3), p4(_p4) {}
-  Bezier3(const Bezier1 &b) : p1(b.p1), p2(conv(b.p1,b.p2,1.0/3.0)), 
-			      p3(conv(b.p1,b.p2,2.0/3.0)), p4(b.p2) {}
+  Bezier3(const Bezier1 &b) : p1(b.p1), p2(conv(b.p1,b.p2,1.0/3.0)),
+                              p3(conv(b.p1,b.p2,2.0/3.0)), p4(b.p2) {}
   Bezier3(const Bezier2 &b) : p1(b.p1), p2(conv(b.p1,b.p2,2.0/3.0)),
-			      p3(conv(b.p2,b.p3,1.0/3.0)), p4(b.p3) {}
-  
-  Point operator()(double t) const 
+                              p3(conv(b.p2,b.p3,1.0/3.0)), p4(b.p3) {}
+
+  Point operator()(double t) const
     {
       //    return Bezier2(conv(p1,p2,t),conv(p2,p3,t),conv(p3,p4,t))(t);
       return ((1-t)*(1-t)*(1-t))*p1+(3*t*(1-t)*(1-t))*p2+
-	(3*t*t*(1-t))*p3+(t*t*t)*p4;
+        (3*t*t*(1-t))*p3+(t*t*t)*p4;
     }
   Bezier3 before(double t) const
@@ -132,5 +132,5 @@
       return Bezier3(p1,p,a,c);
     }
-  
+
   Bezier3 after(double t) const
     {
@@ -147,11 +147,11 @@
   Bezier2 grad() const { return Bezier2(3.0*(p2-p1),3.0*(p3-p2),3.0*(p4-p3)); }
   Bezier2 norm() const { return Bezier2(3.0*rot90(p2-p1),
-				  3.0*rot90(p3-p2),
-				  3.0*rot90(p4-p3)); }
+                                  3.0*rot90(p3-p2),
+                                  3.0*rot90(p4-p3)); }
   Point grad(double t) const { return grad()(t); }
   Point norm(double t) const { return rot90(grad(t)); }
 
   template<class R,class F,class S,class D>
-  R recSplit(F &_f,const S &_s,D _d) const 
+  R recSplit(F &_f,const S &_s,D _d) const
   {
     const Point a=(p1+p2)/2;
@@ -165,5 +165,5 @@
     return _s(f1,f2);
   }
-  
+
 };
 
Index: lemon/bits/default_map.h
===================================================================
--- lemon/bits/default_map.h	(revision 107)
+++ lemon/bits/default_map.h	(revision 209)
@@ -1,5 +1,5 @@
-/* -*- 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-2008
@@ -30,6 +30,6 @@
 
 namespace lemon {
-  
-  
+
+
   //#ifndef LEMON_USE_DEBUG_MAP
 
@@ -141,5 +141,5 @@
   };
 
-// #else 
+// #else
 
 //   template <typename _Graph, typename _Item, typename _Value>
@@ -148,19 +148,19 @@
 //   };
 
-// #endif  
+// #endif
 
   /// \e
   template <typename _Graph, typename _Item, typename _Value>
-  class DefaultMap 
+  class DefaultMap
     : public DefaultMapSelector<_Graph, _Item, _Value>::Map {
   public:
     typedef typename DefaultMapSelector<_Graph, _Item, _Value>::Map Parent;
     typedef DefaultMap<_Graph, _Item, _Value> Map;
-    
+
     typedef typename Parent::Graph Graph;
     typedef typename Parent::Value Value;
 
     explicit DefaultMap(const Graph& graph) : Parent(graph) {}
-    DefaultMap(const Graph& graph, const Value& value) 
+    DefaultMap(const Graph& graph, const Value& value)
       : Parent(graph, value) {}
 
Index: lemon/bits/graph_extender.h
===================================================================
--- lemon/bits/graph_extender.h	(revision 125)
+++ lemon/bits/graph_extender.h	(revision 209)
@@ -1,5 +1,5 @@
-/* -*- 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-2008
@@ -67,9 +67,9 @@
     Node oppositeNode(const Node &node, const Arc &arc) const {
       if (node == Parent::source(arc))
-	return Parent::target(arc);
+        return Parent::target(arc);
       else if(node == Parent::target(arc))
-	return Parent::source(arc);
+        return Parent::source(arc);
       else
-	return INVALID;
+        return INVALID;
     }
 
@@ -90,10 +90,10 @@
       return node_notifier;
     }
-    
+
     ArcNotifier& notifier(Arc) const {
       return arc_notifier;
     }
 
-    class NodeIt : public Node { 
+    class NodeIt : public Node {
       const Digraph* _digraph;
     public:
@@ -104,19 +104,19 @@
 
       explicit NodeIt(const Digraph& digraph) : _digraph(&digraph) {
-	_digraph->first(static_cast<Node&>(*this));
-      }
-
-      NodeIt(const Digraph& digraph, const Node& node) 
-	: Node(node), _digraph(&digraph) {}
-
-      NodeIt& operator++() { 
-	_digraph->next(*this);
-	return *this; 
-      }
-
-    };
-
-
-    class ArcIt : public Arc { 
+        _digraph->first(static_cast<Node&>(*this));
+      }
+
+      NodeIt(const Digraph& digraph, const Node& node)
+        : Node(node), _digraph(&digraph) {}
+
+      NodeIt& operator++() {
+        _digraph->next(*this);
+        return *this;
+      }
+
+    };
+
+
+    class ArcIt : public Arc {
       const Digraph* _digraph;
     public:
@@ -127,19 +127,19 @@
 
       explicit ArcIt(const Digraph& digraph) : _digraph(&digraph) {
-	_digraph->first(static_cast<Arc&>(*this));
-      }
-
-      ArcIt(const Digraph& digraph, const Arc& arc) : 
-	Arc(arc), _digraph(&digraph) { }
-
-      ArcIt& operator++() { 
-	_digraph->next(*this);
-	return *this; 
-      }
-
-    };
-
-
-    class OutArcIt : public Arc { 
+        _digraph->first(static_cast<Arc&>(*this));
+      }
+
+      ArcIt(const Digraph& digraph, const Arc& arc) :
+        Arc(arc), _digraph(&digraph) { }
+
+      ArcIt& operator++() {
+        _digraph->next(*this);
+        return *this;
+      }
+
+    };
+
+
+    class OutArcIt : public Arc {
       const Digraph* _digraph;
     public:
@@ -149,21 +149,21 @@
       OutArcIt(Invalid i) : Arc(i) { }
 
-      OutArcIt(const Digraph& digraph, const Node& node) 
-	: _digraph(&digraph) {
-	_digraph->firstOut(*this, node);
-      }
-
-      OutArcIt(const Digraph& digraph, const Arc& arc) 
-	: Arc(arc), _digraph(&digraph) {}
-
-      OutArcIt& operator++() { 
-	_digraph->nextOut(*this);
-	return *this; 
-      }
-
-    };
-
-
-    class InArcIt : public Arc { 
+      OutArcIt(const Digraph& digraph, const Node& node)
+        : _digraph(&digraph) {
+        _digraph->firstOut(*this, node);
+      }
+
+      OutArcIt(const Digraph& digraph, const Arc& arc)
+        : Arc(arc), _digraph(&digraph) {}
+
+      OutArcIt& operator++() {
+        _digraph->nextOut(*this);
+        return *this;
+      }
+
+    };
+
+
+    class InArcIt : public Arc {
       const Digraph* _digraph;
     public:
@@ -173,15 +173,15 @@
       InArcIt(Invalid i) : Arc(i) { }
 
-      InArcIt(const Digraph& digraph, const Node& node) 
-	: _digraph(&digraph) {
-	_digraph->firstIn(*this, node);
-      }
-
-      InArcIt(const Digraph& digraph, const Arc& arc) : 
-	Arc(arc), _digraph(&digraph) {}
-
-      InArcIt& operator++() { 
-	_digraph->nextIn(*this);
-	return *this; 
+      InArcIt(const Digraph& digraph, const Node& node)
+        : _digraph(&digraph) {
+        _digraph->firstIn(*this, node);
+      }
+
+      InArcIt(const Digraph& digraph, const Arc& arc) :
+        Arc(arc), _digraph(&digraph) {}
+
+      InArcIt& operator++() {
+        _digraph->nextIn(*this);
+        return *this;
       }
 
@@ -216,7 +216,7 @@
     }
 
-    
+
     template <typename _Value>
-    class NodeMap 
+    class NodeMap
       : public MapExtender<DefaultMap<Digraph, Node, _Value> > {
     public:
@@ -224,11 +224,11 @@
       typedef MapExtender<DefaultMap<Digraph, Node, _Value> > Parent;
 
-      explicit NodeMap(const Digraph& digraph) 
-	: Parent(digraph) {}
-      NodeMap(const Digraph& digraph, const _Value& value) 
-	: Parent(digraph, value) {}
+      explicit NodeMap(const Digraph& digraph)
+        : Parent(digraph) {}
+      NodeMap(const Digraph& digraph, const _Value& value)
+        : Parent(digraph, value) {}
 
       NodeMap& operator=(const NodeMap& cmap) {
-	return operator=<NodeMap>(cmap);
+        return operator=<NodeMap>(cmap);
       }
 
@@ -236,5 +236,5 @@
       NodeMap& operator=(const CMap& cmap) {
         Parent::operator=(cmap);
-	return *this;
+        return *this;
       }
 
@@ -242,5 +242,5 @@
 
     template <typename _Value>
-    class ArcMap 
+    class ArcMap
       : public MapExtender<DefaultMap<Digraph, Arc, _Value> > {
     public:
@@ -248,11 +248,11 @@
       typedef MapExtender<DefaultMap<Digraph, Arc, _Value> > Parent;
 
-      explicit ArcMap(const Digraph& digraph) 
-	: Parent(digraph) {}
-      ArcMap(const Digraph& digraph, const _Value& value) 
-	: Parent(digraph, value) {}
+      explicit ArcMap(const Digraph& digraph)
+        : Parent(digraph) {}
+      ArcMap(const Digraph& digraph, const _Value& value)
+        : Parent(digraph, value) {}
 
       ArcMap& operator=(const ArcMap& cmap) {
-	return operator=<ArcMap>(cmap);
+        return operator=<ArcMap>(cmap);
       }
 
@@ -260,5 +260,5 @@
       ArcMap& operator=(const CMap& cmap) {
         Parent::operator=(cmap);
-	return *this;
+        return *this;
       }
     };
@@ -270,5 +270,5 @@
       return node;
     }
-    
+
     Arc addArc(const Node& from, const Node& to) {
       Arc arc = Parent::addArc(from, to);
@@ -294,12 +294,12 @@
       Parent::firstOut(arc, node);
       while (arc != INVALID ) {
-	erase(arc);
-	Parent::firstOut(arc, node);
-      } 
+        erase(arc);
+        Parent::firstOut(arc, node);
+      }
 
       Parent::firstIn(arc, node);
       while (arc != INVALID ) {
-	erase(arc);
-	Parent::firstIn(arc, node);
+        erase(arc);
+        Parent::firstIn(arc, node);
       }
 
@@ -307,5 +307,5 @@
       Parent::erase(node);
     }
-    
+
     void erase(const Arc& arc) {
       notifier(Arc()).erase(arc);
@@ -316,6 +316,6 @@
       node_notifier.setContainer(*this);
       arc_notifier.setContainer(*this);
-    } 
-    
+    }
+
 
     ~DigraphExtender() {
@@ -328,8 +328,8 @@
   ///
   /// \brief Extender for the Graphs
-  template <typename Base> 
+  template <typename Base>
   class GraphExtender : public Base {
   public:
-    
+
     typedef Base Parent;
     typedef GraphExtender Graph;
@@ -341,5 +341,5 @@
     typedef typename Parent::Edge Edge;
 
-    // Graph extension    
+    // Graph extension
 
     int maxId(Node) const {
@@ -369,9 +369,9 @@
     Node oppositeNode(const Node &n, const Edge &e) const {
       if( n == Parent::u(e))
-	return Parent::v(e);
+        return Parent::v(e);
       else if( n == Parent::v(e))
-	return Parent::u(e);
+        return Parent::u(e);
       else
-	return INVALID;
+        return INVALID;
     }
 
@@ -403,5 +403,5 @@
       return node_notifier;
     }
-    
+
     ArcNotifier& notifier(Arc) const {
       return arc_notifier;
@@ -414,5 +414,5 @@
 
 
-    class NodeIt : public Node { 
+    class NodeIt : public Node {
       const Graph* _graph;
     public:
@@ -423,19 +423,19 @@
 
       explicit NodeIt(const Graph& graph) : _graph(&graph) {
-	_graph->first(static_cast<Node&>(*this));
-      }
-
-      NodeIt(const Graph& graph, const Node& node) 
-	: Node(node), _graph(&graph) {}
-
-      NodeIt& operator++() { 
-	_graph->next(*this);
-	return *this; 
-      }
-
-    };
-
-
-    class ArcIt : public Arc { 
+        _graph->first(static_cast<Node&>(*this));
+      }
+
+      NodeIt(const Graph& graph, const Node& node)
+        : Node(node), _graph(&graph) {}
+
+      NodeIt& operator++() {
+        _graph->next(*this);
+        return *this;
+      }
+
+    };
+
+
+    class ArcIt : public Arc {
       const Graph* _graph;
     public:
@@ -446,19 +446,19 @@
 
       explicit ArcIt(const Graph& graph) : _graph(&graph) {
-	_graph->first(static_cast<Arc&>(*this));
-      }
-
-      ArcIt(const Graph& graph, const Arc& arc) : 
-	Arc(arc), _graph(&graph) { }
-
-      ArcIt& operator++() { 
-	_graph->next(*this);
-	return *this; 
-      }
-
-    };
-
-
-    class OutArcIt : public Arc { 
+        _graph->first(static_cast<Arc&>(*this));
+      }
+
+      ArcIt(const Graph& graph, const Arc& arc) :
+        Arc(arc), _graph(&graph) { }
+
+      ArcIt& operator++() {
+        _graph->next(*this);
+        return *this;
+      }
+
+    };
+
+
+    class OutArcIt : public Arc {
       const Graph* _graph;
     public:
@@ -468,21 +468,21 @@
       OutArcIt(Invalid i) : Arc(i) { }
 
-      OutArcIt(const Graph& graph, const Node& node) 
-	: _graph(&graph) {
-	_graph->firstOut(*this, node);
-      }
-
-      OutArcIt(const Graph& graph, const Arc& arc) 
-	: Arc(arc), _graph(&graph) {}
-
-      OutArcIt& operator++() { 
-	_graph->nextOut(*this);
-	return *this; 
-      }
-
-    };
-
-
-    class InArcIt : public Arc { 
+      OutArcIt(const Graph& graph, const Node& node)
+        : _graph(&graph) {
+        _graph->firstOut(*this, node);
+      }
+
+      OutArcIt(const Graph& graph, const Arc& arc)
+        : Arc(arc), _graph(&graph) {}
+
+      OutArcIt& operator++() {
+        _graph->nextOut(*this);
+        return *this;
+      }
+
+    };
+
+
+    class InArcIt : public Arc {
       const Graph* _graph;
     public:
@@ -492,21 +492,21 @@
       InArcIt(Invalid i) : Arc(i) { }
 
-      InArcIt(const Graph& graph, const Node& node) 
-	: _graph(&graph) {
-	_graph->firstIn(*this, node);
-      }
-
-      InArcIt(const Graph& graph, const Arc& arc) : 
-	Arc(arc), _graph(&graph) {}
-
-      InArcIt& operator++() { 
-	_graph->nextIn(*this);
-	return *this; 
-      }
-
-    };
-
-
-    class EdgeIt : public Parent::Edge { 
+      InArcIt(const Graph& graph, const Node& node)
+        : _graph(&graph) {
+        _graph->firstIn(*this, node);
+      }
+
+      InArcIt(const Graph& graph, const Arc& arc) :
+        Arc(arc), _graph(&graph) {}
+
+      InArcIt& operator++() {
+        _graph->nextIn(*this);
+        return *this;
+      }
+
+    };
+
+
+    class EdgeIt : public Parent::Edge {
       const Graph* _graph;
     public:
@@ -517,13 +517,13 @@
 
       explicit EdgeIt(const Graph& graph) : _graph(&graph) {
-	_graph->first(static_cast<Edge&>(*this));
-      }
-
-      EdgeIt(const Graph& graph, const Edge& edge) : 
-	Edge(edge), _graph(&graph) { }
-
-      EdgeIt& operator++() { 
-	_graph->next(*this);
-	return *this; 
+        _graph->first(static_cast<Edge&>(*this));
+      }
+
+      EdgeIt(const Graph& graph, const Edge& edge) :
+        Edge(edge), _graph(&graph) { }
+
+      EdgeIt& operator++() {
+        _graph->next(*this);
+        return *this;
       }
 
@@ -541,15 +541,15 @@
 
       IncEdgeIt(const Graph& graph, const Node &node) : _graph(&graph) {
-	_graph->firstInc(*this, _direction, node);
+        _graph->firstInc(*this, _direction, node);
       }
 
       IncEdgeIt(const Graph& graph, const Edge &edge, const Node &node)
-	: _graph(&graph), Edge(edge) {
-	_direction = (_graph->source(edge) == node);
+        : _graph(&graph), Edge(edge) {
+        _direction = (_graph->source(edge) == node);
       }
 
       IncEdgeIt& operator++() {
-	_graph->nextInc(*this, _direction);
-	return *this; 
+        _graph->nextInc(*this, _direction);
+        return *this;
       }
     };
@@ -599,5 +599,5 @@
 
     template <typename _Value>
-    class NodeMap 
+    class NodeMap
       : public MapExtender<DefaultMap<Graph, Node, _Value> > {
     public:
@@ -605,11 +605,11 @@
       typedef MapExtender<DefaultMap<Graph, Node, _Value> > Parent;
 
-      NodeMap(const Graph& graph) 
-	: Parent(graph) {}
-      NodeMap(const Graph& graph, const _Value& value) 
-	: Parent(graph, value) {}
+      NodeMap(const Graph& graph)
+        : Parent(graph) {}
+      NodeMap(const Graph& graph, const _Value& value)
+        : Parent(graph, value) {}
 
       NodeMap& operator=(const NodeMap& cmap) {
-	return operator=<NodeMap>(cmap);
+        return operator=<NodeMap>(cmap);
       }
 
@@ -617,5 +617,5 @@
       NodeMap& operator=(const CMap& cmap) {
         Parent::operator=(cmap);
-	return *this;
+        return *this;
       }
 
@@ -623,5 +623,5 @@
 
     template <typename _Value>
-    class ArcMap 
+    class ArcMap
       : public MapExtender<DefaultMap<Graph, Arc, _Value> > {
     public:
@@ -629,11 +629,11 @@
       typedef MapExtender<DefaultMap<Graph, Arc, _Value> > Parent;
 
-      ArcMap(const Graph& graph) 
-	: Parent(graph) {}
-      ArcMap(const Graph& graph, const _Value& value) 
-	: Parent(graph, value) {}
+      ArcMap(const Graph& graph)
+        : Parent(graph) {}
+      ArcMap(const Graph& graph, const _Value& value)
+        : Parent(graph, value) {}
 
       ArcMap& operator=(const ArcMap& cmap) {
-	return operator=<ArcMap>(cmap);
+        return operator=<ArcMap>(cmap);
       }
 
@@ -641,5 +641,5 @@
       ArcMap& operator=(const CMap& cmap) {
         Parent::operator=(cmap);
-	return *this;
+        return *this;
       }
     };
@@ -647,5 +647,5 @@
 
     template <typename _Value>
-    class EdgeMap 
+    class EdgeMap
       : public MapExtender<DefaultMap<Graph, Edge, _Value> > {
     public:
@@ -653,12 +653,12 @@
       typedef MapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
 
-      EdgeMap(const Graph& graph) 
-	: Parent(graph) {}
-
-      EdgeMap(const Graph& graph, const _Value& value) 
-	: Parent(graph, value) {}
+      EdgeMap(const Graph& graph)
+        : Parent(graph) {}
+
+      EdgeMap(const Graph& graph, const _Value& value)
+        : Parent(graph, value) {}
 
       EdgeMap& operator=(const EdgeMap& cmap) {
-	return operator=<EdgeMap>(cmap);
+        return operator=<EdgeMap>(cmap);
       }
 
@@ -666,5 +666,5 @@
       EdgeMap& operator=(const CMap& cmap) {
         Parent::operator=(cmap);
-	return *this;
+        return *this;
       }
 
@@ -684,9 +684,9 @@
       std::vector<Arc> ev;
       ev.push_back(Parent::direct(edge, true));
-      ev.push_back(Parent::direct(edge, false));      
+      ev.push_back(Parent::direct(edge, false));
       notifier(Arc()).add(ev);
       return edge;
     }
-    
+
     void clear() {
       notifier(Arc()).clear();
@@ -697,5 +697,5 @@
 
     template <typename Graph, typename NodeRefMap, typename EdgeRefMap>
-    void build(const Graph& graph, NodeRefMap& nodeRef, 
+    void build(const Graph& graph, NodeRefMap& nodeRef,
                EdgeRefMap& edgeRef) {
       Parent::build(graph, nodeRef, edgeRef);
@@ -709,12 +709,12 @@
       Parent::firstOut(arc, node);
       while (arc != INVALID ) {
-	erase(arc);
-	Parent::firstOut(arc, node);
-      } 
+        erase(arc);
+        Parent::firstOut(arc, node);
+      }
 
       Parent::firstIn(arc, node);
       while (arc != INVALID ) {
-	erase(arc);
-	Parent::firstIn(arc, node);
+        erase(arc);
+        Parent::firstIn(arc, node);
       }
 
@@ -726,5 +726,5 @@
       std::vector<Arc> av;
       av.push_back(Parent::direct(edge, true));
-      av.push_back(Parent::direct(edge, false));      
+      av.push_back(Parent::direct(edge, false));
       notifier(Arc()).erase(av);
       notifier(Edge()).erase(edge);
@@ -733,14 +733,14 @@
 
     GraphExtender() {
-      node_notifier.setContainer(*this); 
+      node_notifier.setContainer(*this);
       arc_notifier.setContainer(*this);
       edge_notifier.setContainer(*this);
-    } 
+    }
 
     ~GraphExtender() {
       edge_notifier.clear();
       arc_notifier.clear();
-      node_notifier.clear(); 
-    } 
+      node_notifier.clear();
+    }
 
   };
Index: lemon/bits/invalid.h
===================================================================
--- lemon/bits/invalid.h	(revision 49)
+++ lemon/bits/invalid.h	(revision 209)
@@ -1,5 +1,5 @@
-/* -*- 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-2008
@@ -35,5 +35,5 @@
     bool operator< (Invalid) { return false; }
   };
-  
+
   /// \brief Invalid iterators.
   ///
@@ -53,3 +53,3 @@
 
 #endif
-  
+
Index: lemon/bits/map_extender.h
===================================================================
--- lemon/bits/map_extender.h	(revision 107)
+++ lemon/bits/map_extender.h	(revision 209)
@@ -1,5 +1,5 @@
-/* -*- C++ -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library.
  *
  * Copyright (C) 2003-2008
@@ -33,5 +33,5 @@
 
   /// \ingroup graphbits
-  /// 
+  ///
   /// \brief Extender for maps
   template <typename _Map>
@@ -57,8 +57,8 @@
   public:
 
-    MapExtender(const Graph& graph) 
+    MapExtender(const Graph& graph)
       : Parent(graph) {}
 
-    MapExtender(const Graph& graph, const Value& value) 
+    MapExtender(const Graph& graph, const Value& value)
       : Parent(graph, value) {}
 
@@ -71,12 +71,12 @@
       Parent::operator=(cmap);
       return *this;
-    } 
+    }
 
     class MapIt : public Item {
     public:
-      
+
       typedef Item Parent;
       typedef typename Map::Value Value;
-      
+
       MapIt() {}
 
@@ -87,27 +87,27 @@
       }
 
-      MapIt(const Map& _map, const Item& item) 
-	: Parent(item), map(_map) {}
-
-      MapIt& operator++() { 
-	map.notifier()->next(*this);
-	return *this; 
-      }
-      
+      MapIt(const Map& _map, const Item& item)
+        : Parent(item), map(_map) {}
+
+      MapIt& operator++() {
+        map.notifier()->next(*this);
+        return *this;
+      }
+
       typename MapTraits<Map>::ConstReturnValue operator*() const {
-	return map[*this];
+        return map[*this];
       }
 
       typename MapTraits<Map>::ReturnValue operator*() {
-	return map[*this];
-      }
-      
+        return map[*this];
+      }
+
       void set(const Value& value) {
-	map.set(*this, value);
-      }
-      
+        map.set(*this, value);
+      }
+
     protected:
       Map& map;
-      
+
     };
 
@@ -118,5 +118,5 @@
 
       typedef typename Map::Value Value;
-      
+
       ConstMapIt() {}
 
@@ -127,14 +127,14 @@
       }
 
-      ConstMapIt(const Map& _map, const Item& item) 
-	: Parent(item), map(_map) {}
-
-      ConstMapIt& operator++() { 
-	map.notifier()->next(*this);
-	return *this; 
+      ConstMapIt(const Map& _map, const Item& item)
+        : Parent(item), map(_map) {}
+
+      ConstMapIt& operator++() {
+        map.notifier()->next(*this);
+        return *this;
       }
 
       typename MapTraits<Map>::ConstReturnValue operator*() const {
-	return map[*this];
+        return map[*this];
       }
 
@@ -145,7 +145,7 @@
     class ItemIt : public Item {
     public:
-      
-      typedef Item Parent;
-      
+
+      typedef Item Parent;
+
       ItemIt() {}
 
@@ -156,20 +156,20 @@
       }
 
-      ItemIt(const Map& _map, const Item& item) 
-	: Parent(item), map(_map) {}
-
-      ItemIt& operator++() { 
-	map.notifier()->next(*this);
-	return *this; 
+      ItemIt(const Map& _map, const Item& item)
+        : Parent(item), map(_map) {}
+
+      ItemIt& operator++() {
+        map.notifier()->next(*this);
+        return *this;
       }
 
     protected:
       const Map& map;
-      
+
     };
   };
 
   /// \ingroup graphbits
-  /// 
+  ///
   /// \brief Extender for maps which use a subset of the items.
   template <typename _Graph, typename _Map>
@@ -195,8 +195,8 @@
   public:
 
-    SubMapExtender(const Graph& _graph) 
+    SubMapExtender(const Graph& _graph)
       : Parent(_graph), graph(_graph) {}
 
-    SubMapExtender(const Graph& _graph, const Value& _value) 
+    SubMapExtender(const Graph& _graph, const Value& _value)
       : Parent(_graph, _value), graph(_graph) {}
 
@@ -213,12 +213,12 @@
       }
       return *this;
-    } 
+    }
 
     class MapIt : public Item {
     public:
-      
+
       typedef Item Parent;
       typedef typename Map::Value Value;
-      
+
       MapIt() {}
 
@@ -229,27 +229,27 @@
       }
 
-      MapIt(const Map& _map, const Item& item) 
-	: Parent(item), map(_map) {}
-
-      MapIt& operator++() { 
-	map.graph.next(*this);
-	return *this; 
-      }
-      
+      MapIt(const Map& _map, const Item& item)
+        : Parent(item), map(_map) {}
+
+      MapIt& operator++() {
+        map.graph.next(*this);
+        return *this;
+      }
+
       typename MapTraits<Map>::ConstReturnValue operator*() const {
-	return map[*this];
+        return map[*this];
       }
 
       typename MapTraits<Map>::ReturnValue operator*() {
-	return map[*this];
-      }
-      
+        return map[*this];
+      }
+
       void set(const Value& value) {
-	map.set(*this, value);
-      }
-      
+        map.set(*this, value);
+      }
+
     protected:
       Map& map;
-      
+
     };
 
@@ -260,5 +260,5 @@
 
       typedef typename Map::Value Value;
-      
+
       ConstMapIt() {}
 
@@ -269,14 +269,14 @@
       }
 
-      ConstMapIt(const Map& _map, const Item& item) 
-	: Parent(item), map(_map) {}
-
-      ConstMapIt& operator++() { 
-	map.graph.next(*this);
-	return *this; 
+      ConstMapIt(const Map& _map, const Item& item)
+        : Parent(item), map(_map) {}
+
+      ConstMapIt& operator++() {
+        map.graph.next(*this);
+        return *this;
       }
 
       typename MapTraits<Map>::ConstReturnValue operator*() const {
-	return map[*this];
+        return map[*this];
       }
 
@@ -287,7 +287,7 @@
     class ItemIt : public Item {
     public:
-      
-      typedef Item Parent;
-      
+
+      typedef Item Parent;
+
       ItemIt() {}
 
@@ -298,21 +298,21 @@
       }
 
-      ItemIt(const Map& _map, const Item& item) 
-	: Parent(item), map(_map) {}
-
-      ItemIt& operator++() { 
-	map.graph.next(*this);
-	return *this; 
+      ItemIt(const Map& _map, const Item& item)
+        : Parent(item), map(_map) {}
+
+      ItemIt& operator++() {
+        map.graph.next(*this);
+        return *this;
       }
 
     protected:
       const Map& map;
-      
-    };
-    
+
+    };
+
   private:
 
     const Graph& graph;
-    
+
   };
 
Index: lemon/bits/path_dump.h
===================================================================
--- lemon/bits/path_dump.h	(revision 100)
+++ lemon/bits/path_dump.h	(revision 209)
@@ -1,5 +1,5 @@
-/* -*- 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-2008
@@ -54,5 +54,5 @@
       RevArcIt() {}
       RevArcIt(Invalid) : path(0), current(INVALID) {}
-      RevArcIt(const PredMapPath& _path) 
+      RevArcIt(const PredMapPath& _path)
         : path(&_path), current(_path.target) {
         if (path->predMap[current] == INVALID) current = INVALID;
@@ -69,16 +69,16 @@
       }
 
-      bool operator==(const RevArcIt& e) const { 
-        return current == e.current; 
+      bool operator==(const RevArcIt& e) const {
+        return current == e.current;
       }
 
       bool operator!=(const RevArcIt& e) const {
-        return current != e.current; 
+        return current != e.current;
       }
 
-      bool operator<(const RevArcIt& e) const { 
-        return current < e.current; 
+      bool operator<(const RevArcIt& e) const {
+        return current < e.current;
       }
-      
+
     private:
       const PredMapPath* path;
@@ -102,9 +102,9 @@
     typedef _PredMatrixMap PredMatrixMap;
 
-    PredMatrixMapPath(const Digraph& _digraph, 
+    PredMatrixMapPath(const Digraph& _digraph,
                       const PredMatrixMap& _predMatrixMap,
-                      typename Digraph::Node _source, 
+                      typename Digraph::Node _source,
                       typename Digraph::Node _target)
-      : digraph(_digraph), predMatrixMap(_predMatrixMap), 
+      : digraph(_digraph), predMatrixMap(_predMatrixMap),
         source(_source), target(_target) {}
 
@@ -128,7 +128,7 @@
       RevArcIt() {}
       RevArcIt(Invalid) : path(0), current(INVALID) {}
-      RevArcIt(const PredMatrixMapPath& _path) 
+      RevArcIt(const PredMatrixMapPath& _path)
         : path(&_path), current(_path.target) {
-        if (path->predMatrixMap(path->source, current) == INVALID) 
+        if (path->predMatrixMap(path->source, current) == INVALID)
           current = INVALID;
       }
@@ -139,23 +139,23 @@
 
       RevArcIt& operator++() {
-        current = 
+        current =
           path->digraph.source(path->predMatrixMap(path->source, current));
-        if (path->predMatrixMap(path->source, current) == INVALID) 
+        if (path->predMatrixMap(path->source, current) == INVALID)
           current = INVALID;
         return *this;
       }
 
-      bool operator==(const RevArcIt& e) const { 
-        return current == e.current; 
+      bool operator==(const RevArcIt& e) const {
+        return current == e.current;
       }
 
       bool operator!=(const RevArcIt& e) const {
-        return current != e.current; 
+        return current != e.current;
       }
 
-      bool operator<(const RevArcIt& e) const { 
-        return current < e.current; 
+      bool operator<(const RevArcIt& e) const {
+        return current < e.current;
       }
-      
+
     private:
       const PredMatrixMapPath* path;
Index: lemon/bits/traits.h
===================================================================
--- lemon/bits/traits.h	(revision 184)
+++ lemon/bits/traits.h	(revision 209)
@@ -1,6 +1,5 @@
-
-/* -*- C++ -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library.
  *
  * Copyright (C) 2003-2008
@@ -30,5 +29,5 @@
   template <typename _Graph, typename _Item>
   class ItemSetTraits {};
-  
+
 
   template <typename Graph, typename Enable = void>
@@ -38,7 +37,7 @@
   template <typename Graph>
   struct NodeNotifierIndicator<
-    Graph, 
+    Graph,
     typename enable_if<typename Graph::NodeNotifier::Notifier, void>::type
-  > { 
+  > {
     typedef typename Graph::NodeNotifier Type;
   };
@@ -47,5 +46,5 @@
   class ItemSetTraits<_Graph, typename _Graph::Node> {
   public:
-    
+
     typedef _Graph Graph;
 
@@ -58,11 +57,11 @@
     class Map : public Graph::template NodeMap<_Value> {
     public:
-      typedef typename Graph::template NodeMap<_Value> Parent; 
-      typedef typename Graph::template NodeMap<_Value> Type; 
+      typedef typename Graph::template NodeMap<_Value> Parent;
+      typedef typename Graph::template NodeMap<_Value> Type;
       typedef typename Parent::Value Value;
 
       Map(const Graph& _digraph) : Parent(_digraph) {}
-      Map(const Graph& _digraph, const Value& _value) 
-	: Parent(_digraph, _value) {}
+      Map(const Graph& _digraph, const Value& _value)
+        : Parent(_digraph, _value) {}
 
      };
@@ -76,7 +75,7 @@
   template <typename Graph>
   struct ArcNotifierIndicator<
-    Graph, 
+    Graph,
     typename enable_if<typename Graph::ArcNotifier::Notifier, void>::type
-  > { 
+  > {
     typedef typename Graph::ArcNotifier Type;
   };
@@ -85,5 +84,5 @@
   class ItemSetTraits<_Graph, typename _Graph::Arc> {
   public:
-    
+
     typedef _Graph Graph;
 
@@ -96,11 +95,11 @@
     class Map : public Graph::template ArcMap<_Value> {
     public:
-      typedef typename Graph::template ArcMap<_Value> Parent; 
-      typedef typename Graph::template ArcMap<_Value> Type; 
+      typedef typename Graph::template ArcMap<_Value> Parent;
+      typedef typename Graph::template ArcMap<_Value> Type;
       typedef typename Parent::Value Value;
 
       Map(const Graph& _digraph) : Parent(_digraph) {}
-      Map(const Graph& _digraph, const Value& _value) 
-	: Parent(_digraph, _value) {}
+      Map(const Graph& _digraph, const Value& _value)
+        : Parent(_digraph, _value) {}
     };
 
@@ -113,7 +112,7 @@
   template <typename Graph>
   struct EdgeNotifierIndicator<
-    Graph, 
+    Graph,
     typename enable_if<typename Graph::EdgeNotifier::Notifier, void>::type
-  > { 
+  > {
     typedef typename Graph::EdgeNotifier Type;
   };
@@ -122,5 +121,5 @@
   class ItemSetTraits<_Graph, typename _Graph::Edge> {
   public:
-    
+
     typedef _Graph Graph;
 
@@ -133,11 +132,11 @@
     class Map : public Graph::template EdgeMap<_Value> {
     public:
-      typedef typename Graph::template EdgeMap<_Value> Parent; 
-      typedef typename Graph::template EdgeMap<_Value> Type; 
+      typedef typename Graph::template EdgeMap<_Value> Parent;
+      typedef typename Graph::template EdgeMap<_Value> Type;
       typedef typename Parent::Value Value;
 
       Map(const Graph& _digraph) : Parent(_digraph) {}
-      Map(const Graph& _digraph, const Value& _value) 
-	: Parent(_digraph, _value) {}
+      Map(const Graph& _digraph, const Value& _value)
+        : Parent(_digraph, _value) {}
     };
 
@@ -157,8 +156,8 @@
   template <typename Map>
   struct MapTraits<
-    Map, typename enable_if<typename Map::ReferenceMapTag, void>::type > 
+    Map, typename enable_if<typename Map::ReferenceMapTag, void>::type >
   {
     typedef True ReferenceMapTag;
-    
+
     typedef typename Map::Key Key;
     typedef typename Map::Value Value;
@@ -167,5 +166,5 @@
     typedef typename Map::Reference ReturnValue;
 
-    typedef typename Map::ConstReference ConstReference; 
+    typedef typename Map::ConstReference ConstReference;
     typedef typename Map::Reference Reference;
  };
@@ -185,9 +184,9 @@
   template <typename MatrixMap>
   struct MatrixMapTraits<
-    MatrixMap, typename enable_if<typename MatrixMap::ReferenceMapTag, 
-                                  void>::type > 
+    MatrixMap, typename enable_if<typename MatrixMap::ReferenceMapTag,
+                                  void>::type >
   {
     typedef True ReferenceMapTag;
-    
+
     typedef typename MatrixMap::FirstKey FirstKey;
     typedef typename MatrixMap::SecondKey SecondKey;
@@ -197,5 +196,5 @@
     typedef typename MatrixMap::Reference ReturnValue;
 
-    typedef typename MatrixMap::ConstReference ConstReference; 
+    typedef typename MatrixMap::ConstReference ConstReference;
     typedef typename MatrixMap::Reference Reference;
  };
@@ -210,5 +209,5 @@
   template <typename Graph>
   struct NodeNumTagIndicator<
-    Graph, 
+    Graph,
     typename enable_if<typename Graph::NodeNumTag, void>::type
   > {
@@ -223,5 +222,5 @@
   template <typename Graph>
   struct EdgeNumTagIndicator<
-    Graph, 
+    Graph,
     typename enable_if<typename Graph::EdgeNumTag, void>::type
   > {
@@ -236,5 +235,5 @@
   template <typename Graph>
   struct FindEdgeTagIndicator<
-    Graph, 
+    Graph,
     typename enable_if<typename Graph::FindEdgeTag, void>::type
   > {
@@ -249,5 +248,5 @@
   template <typename Graph>
   struct UndirectedTagIndicator<
-    Graph, 
+    Graph,
     typename enable_if<typename Graph::UndirectedTag, void>::type
   > {
@@ -262,5 +261,5 @@
   template <typename Graph>
   struct BuildTagIndicator<
-    Graph, 
+    Graph,
     typename enable_if<typename Graph::BuildTag, void>::type
   > {
Index: lemon/bits/utility.h
===================================================================
--- lemon/bits/utility.h	(revision 117)
+++ lemon/bits/utility.h	(revision 209)
@@ -1,5 +1,5 @@
-/* -*- 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-2008
@@ -84,5 +84,5 @@
 
   /**************** enable_if from BOOST ****************/
-  
+
   template <typename Type, typename T = void>
   struct exists {
@@ -90,5 +90,5 @@
   };
 
- 
+
   template <bool B, class T = void>
   struct enable_if_c {
@@ -99,5 +99,5 @@
   struct enable_if_c<false, T> {};
 
-  template <class Cond, class T = void> 
+  template <class Cond, class T = void>
   struct enable_if : public enable_if_c<Cond::value, T> {};
 
@@ -110,5 +110,5 @@
   struct lazy_enable_if_c<false, T> {};
 
-  template <class Cond, class T> 
+  template <class Cond, class T>
   struct lazy_enable_if : public lazy_enable_if_c<Cond::value, T> {};
 
@@ -122,5 +122,5 @@
   struct disable_if_c<true, T> {};
 
-  template <class Cond, class T = void> 
+  template <class Cond, class T = void>
   struct disable_if : public disable_if_c<Cond::value, T> {};
 
@@ -133,5 +133,5 @@
   struct lazy_disable_if_c<true, T> {};
 
-  template <class Cond, class T> 
+  template <class Cond, class T>
   struct lazy_disable_if : public lazy_disable_if_c<Cond::value, T> {};
 
Index: lemon/bits/vector_map.h
===================================================================
--- lemon/bits/vector_map.h	(revision 157)
+++ lemon/bits/vector_map.h	(revision 209)
@@ -1,5 +1,5 @@
-/* -*- C++ -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library.
  *
  * Copyright (C) 2003-2008
@@ -50,14 +50,14 @@
   /// \todo Fix the doc: there is _Graph parameter instead of _Notifier.
   template <typename _Graph, typename _Item, typename _Value>
-  class VectorMap 
+  class VectorMap
     : public ItemSetTraits<_Graph, _Item>::ItemNotifier::ObserverBase {
   private:
-		
+
     /// The container type of the map.
-    typedef std::vector<_Value> Container;	
+    typedef std::vector<_Value> Container;
 
   public:
 
-    /// The graph type of the map. 
+    /// The graph type of the map.
     typedef _Graph Graph;
     /// The item type of the map.
@@ -94,7 +94,7 @@
     }
 
-    /// \brief Constructor uses given value to initialize the map. 
-    ///
-    /// It constructs a map uses a given value to initialize the map. 
+    /// \brief Constructor uses given value to initialize the map.
+    ///
+    /// It constructs a map uses a given value to initialize the map.
     /// It adds all the items of the graph to the map.
     VectorMap(const Graph& graph, const Value& value) {
@@ -108,6 +108,6 @@
     VectorMap(const VectorMap& _copy) : Parent() {
       if (_copy.attached()) {
-	Parent::attach(*_copy.notifier());
-	container = _copy.container;
+        Parent::attach(*_copy.notifier());
+        container = _copy.container;
       }
     }
@@ -116,8 +116,8 @@
     ///
     /// This operator assigns for each item in the map the
-    /// value mapped to the same item in the copied map.  
+    /// value mapped to the same item in the copied map.
     /// The parameter map should be indiced with the same
     /// itemset because this assign operator does not change
-    /// the container of the map. 
+    /// the container of the map.
     VectorMap& operator=(const VectorMap& cmap) {
       return operator=<VectorMap>(cmap);
@@ -130,5 +130,5 @@
     /// concecpt and could be indiced by the current item set of
     /// the NodeMap. In this case the value for each item
-    /// is assigned by the value of the given ReadMap. 
+    /// is assigned by the value of the given ReadMap.
     template <typename CMap>
     VectorMap& operator=(const CMap& cmap) {
@@ -141,5 +141,5 @@
       return *this;
     }
-    
+
   public:
 
@@ -147,13 +147,13 @@
     ///
     /// The subscript operator. The map can be subscripted by the
-    /// actual items of the graph.      
+    /// actual items of the graph.
     Reference operator[](const Key& key) {
       return container[Parent::notifier()->id(key)];
-    } 
-		
+    }
+
     /// \brief The const subcript operator.
     ///
     /// The const subscript operator. The map can be subscripted by the
-    /// actual items of the graph. 
+    /// actual items of the graph.
     ConstReference operator[](const Key& key) const {
       return container[Parent::notifier()->id(key)];
@@ -171,18 +171,18 @@
 
     /// \brief Adds a new key to the map.
-    ///		
+    ///
     /// It adds a new key to the map. It called by the observer notifier
-    /// and it overrides the add() member function of the observer base.     
+    /// and it overrides the add() member function of the observer base.
     virtual void add(const Key& key) {
       int id = Parent::notifier()->id(key);
       if (id >= int(container.size())) {
-	container.resize(id + 1);
+        container.resize(id + 1);
       }
     }
 
     /// \brief Adds more new keys to the map.
-    ///		
+    ///
     /// It adds more new keys to the map. It called by the observer notifier
-    /// and it overrides the add() member function of the observer base.     
+    /// and it overrides the add() member function of the observer base.
     virtual void add(const std::vector<Key>& keys) {
       int max = container.size() - 1;
@@ -199,5 +199,5 @@
     ///
     /// Erase a key from the map. It called by the observer notifier
-    /// and it overrides the erase() member function of the observer base.     
+    /// and it overrides the erase() member function of the observer base.
     virtual void erase(const Key& key) {
       container[Parent::notifier()->id(key)] = Value();
@@ -207,16 +207,16 @@
     ///
     /// Erase more keys from the map. It called by the observer notifier
-    /// and it overrides the erase() member function of the observer base.     
+    /// and it overrides the erase() member function of the observer base.
     virtual void erase(const std::vector<Key>& keys) {
       for (int i = 0; i < int(keys.size()); ++i) {
-	container[Parent::notifier()->id(keys[i])] = Value();
-      }
-    }
-    
+        container[Parent::notifier()->id(keys[i])] = Value();
+      }
+    }
+
     /// \brief Buildes the map.
-    ///	
+    ///
     /// It buildes the map. It called by the observer notifier
     /// and it overrides the build() member function of the observer base.
-    virtual void build() { 
+    virtual void build() {
       int size = Parent::notifier()->maxId() + 1;
       container.reserve(size);
@@ -227,11 +227,11 @@
     ///
     /// It erase all items from the map. It called by the observer notifier
-    /// and it overrides the clear() member function of the observer base.     
-    virtual void clear() { 
+    /// and it overrides the clear() member function of the observer base.
+    virtual void clear() {
       container.clear();
     }
-    
+
   private:
-		
+
     Container container;
 
