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);
     }
