Index: lemon/bits/base_extender.h
===================================================================
--- lemon/bits/base_extender.h	(revision 2260)
+++ lemon/bits/base_extender.h	(revision 2386)
@@ -194,14 +194,14 @@
     }
 
-    Node nodeFromId(int id) const {
-      return Parent::nodeFromId(id);
-    }
-
-    Edge edgeFromId(int id) const {
-      return direct(Parent::edgeFromId(id >> 1), bool(id & 1));
-    }
-
-    UEdge uEdgeFromId(int id) const {
-      return Parent::edgeFromId(id);
+    Node nodeFromId(int ix) const {
+      return Parent::nodeFromId(ix);
+    }
+
+    Edge edgeFromId(int ix) const {
+      return direct(Parent::edgeFromId(ix >> 1), bool(ix & 1));
+    }
+
+    UEdge uEdgeFromId(int ix) const {
+      return Parent::edgeFromId(ix);
     }
 
@@ -239,17 +239,17 @@
     }
 
-    Edge findEdge(Node source, Node target, Edge prev = INVALID) const {
-      if (prev == INVALID) {
-	UEdge edge = Parent::findEdge(source, target);
+    Edge findEdge(Node s, Node t, Edge p = INVALID) const {
+      if (p == INVALID) {
+	UEdge edge = Parent::findEdge(s, t);
 	if (edge != INVALID) return direct(edge, true);
-	edge = Parent::findEdge(target, source);
+	edge = Parent::findEdge(t, s);
 	if (edge != INVALID) return direct(edge, false);
-      } else if (direction(prev)) {
-	UEdge edge = Parent::findEdge(source, target, prev);
+      } else if (direction(p)) {
+	UEdge edge = Parent::findEdge(s, t, p);
 	if (edge != INVALID) return direct(edge, true);
-	edge = Parent::findEdge(target, source);
+	edge = Parent::findEdge(t, s);
 	if (edge != INVALID) return direct(edge, false);	
       } else {
-	UEdge edge = Parent::findEdge(target, source, prev);
+	UEdge edge = Parent::findEdge(t, s, p);
 	if (edge != INVALID) return direct(edge, false);	      
       }
@@ -257,22 +257,22 @@
     }
 
-    UEdge findUEdge(Node source, Node target, UEdge prev = INVALID) const {
-      if (source != target) {
-        if (prev == INVALID) {
-          UEdge edge = Parent::findEdge(source, target);
+    UEdge findUEdge(Node s, Node t, UEdge p = INVALID) const {
+      if (s != t) {
+        if (p == INVALID) {
+          UEdge edge = Parent::findEdge(s, t);
           if (edge != INVALID) return edge;
-          edge = Parent::findEdge(target, source);
+          edge = Parent::findEdge(t, s);
           if (edge != INVALID) return edge;
-        } else if (Parent::source(prev) == source) {
-          UEdge edge = Parent::findEdge(source, target, prev);
+        } else if (Parent::s(p) == s) {
+          UEdge edge = Parent::findEdge(s, t, p);
           if (edge != INVALID) return edge;
-          edge = Parent::findEdge(target, source);
+          edge = Parent::findEdge(t, s);
           if (edge != INVALID) return edge;	
         } else {
-          UEdge edge = Parent::findEdge(target, source, prev);
+          UEdge edge = Parent::findEdge(t, s, p);
           if (edge != INVALID) return edge;	      
         }
       } else {
-        return Parent::findEdge(source, target, prev);
+        return Parent::findEdge(s, t, p);
       }
       return INVALID;
@@ -358,19 +358,19 @@
     }
 
-    void firstInc(UEdge& edge, bool& direction, const Node& node) const {
+    void firstInc(UEdge& edge, bool& dir, const Node& node) const {
       if (Parent::aNode(node)) {
 	Parent::firstFromANode(edge, node);
-	direction = true;
+	dir = true;
       } else {
 	Parent::firstFromBNode(edge, node);
-	direction = static_cast<UEdge&>(edge) == INVALID;
-      }
-    }
-    void nextInc(UEdge& edge, bool& direction) const {
-      if (direction) {
+	dir = static_cast<UEdge&>(edge) == INVALID;
+      }
+    }
+    void nextInc(UEdge& edge, bool& dir) const {
+      if (dir) {
 	Parent::nextFromANode(edge);
       } else {
 	Parent::nextFromBNode(edge);
-	if (edge == INVALID) direction = true;
+	if (edge == INVALID) dir = true;
       }
     }
@@ -458,6 +458,6 @@
         (edge.forward ? 0 : 1);
     }
-    Edge edgeFromId(int id) const {
-      return Edge(Parent::fromUEdgeId(id >> 1), (id & 1) == 0);
+    Edge edgeFromId(int ix) const {
+      return Edge(Parent::fromUEdgeId(ix >> 1), (ix & 1) == 0);
     }
     int maxEdgeId() const {
@@ -469,6 +469,6 @@
     }
 
-    Edge direct(const UEdge& edge, bool direction) const {
-      return Edge(edge, direction);
+    Edge direct(const UEdge& edge, bool dir) const {
+      return Edge(edge, dir);
     }
 
