diff -r 4317d277ba21 -r 765619b7cbb2 lemon/bits/base_extender.h
--- a/lemon/bits/base_extender.h	Sun Jul 13 16:46:56 2008 +0100
+++ b/lemon/bits/base_extender.h	Sun Jul 13 19:51:02 2008 +0100
@@ -1,6 +1,6 @@
-/* -*- 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
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
@@ -63,14 +63,14 @@
       Arc(Invalid i) : Edge(i), forward(true) {}
 
       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));
       }
     };
 
@@ -117,59 +117,59 @@
 
     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;
       }
     }
 
     void firstOut(Arc &e, const Node &n) const {
       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);
       }
     }
 
     void firstIn(Arc &e, const Node &n) const {
       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);
       }
     }
 
@@ -183,13 +183,13 @@
 
     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);
+        Node s = Parent::source(e);
+        Parent::nextOut(e);
+        if (e != INVALID) return;
+        d = false;
+        Parent::firstIn(e, s);
       } else {
-	Parent::nextIn(e);
+        Parent::nextIn(e);
       }
     }
 
@@ -240,18 +240,18 @@
 
     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);	
+        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(t, s, p);
+        if (arc != INVALID) return direct(arc, false);
       }
       return INVALID;
     }
@@ -267,10 +267,10 @@
           Edge arc = Parent::findArc(s, t, p);
           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 {
         return Parent::findArc(s, t, p);
@@ -299,12 +299,12 @@
     public:
       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;
       }
@@ -331,12 +331,12 @@
     public:
       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;
       }
@@ -353,7 +353,7 @@
     void next(Blue& node) const {
       Parent::nextBlue(static_cast<Node&>(node));
     }
-  
+
     int id(const Blue& node) const {
       return Parent::redId(node);
     }
@@ -367,19 +367,19 @@
 
     void firstInc(Edge& arc, bool& dir, const Node& node) const {
       if (Parent::red(node)) {
-	Parent::firstFromRed(arc, node);
-	dir = true;
+        Parent::firstFromRed(arc, node);
+        dir = true;
       } else {
-	Parent::firstFromBlue(arc, node);
-	dir = static_cast<Edge&>(arc) == INVALID;
+        Parent::firstFromBlue(arc, node);
+        dir = static_cast<Edge&>(arc) == INVALID;
       }
     }
     void nextInc(Edge& arc, bool& dir) const {
       if (dir) {
-	Parent::nextFromRed(arc);
+        Parent::nextFromRed(arc);
       } else {
-	Parent::nextFromBlue(arc);
-	if (arc == INVALID) dir = true;
+        Parent::nextFromBlue(arc);
+        if (arc == INVALID) dir = true;
       }
     }
 
@@ -389,20 +389,20 @@
       bool forward;
 
       Arc(const Edge& arc, bool _forward)
-	: Edge(arc), forward(_forward) {}
+        : Edge(arc), forward(_forward) {}
 
     public:
       Arc() {}
       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));
       }
     };
 
@@ -413,44 +413,44 @@
 
     void next(Arc& arc) const {
       if (!arc.forward) {
-	Parent::next(static_cast<Edge&>(arc));
+        Parent::next(static_cast<Edge&>(arc));
       }
       arc.forward = !arc.forward;
     }
 
     void firstOut(Arc& arc, const Node& node) const {
       if (Parent::red(node)) {
-	Parent::firstFromRed(arc, node);
-	arc.forward = true;
+        Parent::firstFromRed(arc, node);
+        arc.forward = true;
       } else {
-	Parent::firstFromBlue(arc, node);
-	arc.forward = static_cast<Edge&>(arc) == INVALID;
+        Parent::firstFromBlue(arc, node);
+        arc.forward = static_cast<Edge&>(arc) == INVALID;
       }
     }
     void nextOut(Arc& arc) const {
       if (arc.forward) {
-	Parent::nextFromRed(arc);
+        Parent::nextFromRed(arc);
       } else {
-	Parent::nextFromBlue(arc);
+        Parent::nextFromBlue(arc);
         arc.forward = static_cast<Edge&>(arc) == INVALID;
       }
     }
 
     void firstIn(Arc& arc, const Node& node) const {
       if (Parent::blue(node)) {
-	Parent::firstFromBlue(arc, node);
-	arc.forward = true;	
+        Parent::firstFromBlue(arc, node);
+        arc.forward = true;
       } else {
-	Parent::firstFromRed(arc, node);
-	arc.forward = static_cast<Edge&>(arc) == INVALID;
+        Parent::firstFromRed(arc, node);
+        arc.forward = static_cast<Edge&>(arc) == INVALID;
       }
     }
     void nextIn(Arc& arc) const {
       if (arc.forward) {
-	Parent::nextFromBlue(arc);
+        Parent::nextFromBlue(arc);
       } else {
-	Parent::nextFromRed(arc);
-	arc.forward = static_cast<Edge&>(arc) == INVALID;
+        Parent::nextFromRed(arc);
+        arc.forward = static_cast<Edge&>(arc) == INVALID;
       }
     }
 
@@ -462,7 +462,7 @@
     }
 
     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);
     }
     Arc arcFromId(int ix) const {