Index: lemon/bits/alteration_notifier.h
===================================================================
--- lemon/bits/alteration_notifier.h	(revision 1909)
+++ lemon/bits/alteration_notifier.h	(revision 1910)
@@ -3,5 +3,5 @@
  *
  * Copyright (C) 2006 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ * (Egervary Research Groin on Combinatorial Optimization, EGRES).
  *
  * Permission to use, modify and distribute this software is granted
@@ -21,5 +21,5 @@
 #include <algorithm>
 
-///\ingroup graphmapfactory
+///\ingroin graphmapfactory
 ///\file
 ///\brief Observer registry for graph alteration observers.
@@ -27,5 +27,5 @@
 namespace lemon {
 
-  /// \addtogroup graphmapfactory
+  /// \addtogroin graphmapfactory
   /// @{
 
@@ -502,13 +502,13 @@
 
   template <typename _Base>
-  class AlterableUBipartiteGraphExtender : public _Base {
+  class AlterableBpUGraphExtender : public _Base {
   public:
 
     typedef _Base Parent;
-    typedef AlterableUBipartiteGraphExtender Graph;
+    typedef AlterableBpUGraphExtender Graph;
   
     typedef typename Parent::Node Node;
-    typedef typename Parent::LowerNode LowerNode;
-    typedef typename Parent::UpperNode UpperNode;
+    typedef typename Parent::BNode BNode;
+    typedef typename Parent::ANode ANode;
     typedef typename Parent::Edge Edge;
     typedef typename Parent::UEdge UEdge;
@@ -516,6 +516,6 @@
   
     typedef AlterationNotifier<Node> NodeNotifier;
-    typedef AlterationNotifier<LowerNode> LowerNodeNotifier;
-    typedef AlterationNotifier<UpperNode> UpperNodeNotifier;
+    typedef AlterationNotifier<BNode> BNodeNotifier;
+    typedef AlterationNotifier<ANode> ANodeNotifier;
     typedef AlterationNotifier<Edge> EdgeNotifier;
     typedef AlterationNotifier<UEdge> UEdgeNotifier;
@@ -524,6 +524,6 @@
 
     mutable NodeNotifier nodeNotifier;
-    mutable LowerNodeNotifier lowerNodeNotifier;
-    mutable UpperNodeNotifier upperNodeNotifier;
+    mutable BNodeNotifier bNodeNotifier;
+    mutable ANodeNotifier aNodeNotifier;
     mutable EdgeNotifier edgeNotifier;
     mutable UEdgeNotifier uEdgeNotifier;
@@ -535,10 +535,10 @@
     }
 
-    LowerNodeNotifier& getNotifier(LowerNode) const {
-      return lowerNodeNotifier;
-    }
-
-    UpperNodeNotifier& getNotifier(UpperNode) const {
-      return upperNodeNotifier;
+    BNodeNotifier& getNotifier(BNode) const {
+      return bNodeNotifier;
+    }
+
+    ANodeNotifier& getNotifier(ANode) const {
+      return aNodeNotifier;
     }
 
@@ -551,8 +551,8 @@
     }
 
-    ~AlterableUBipartiteGraphExtender() {
+    ~AlterableBpUGraphExtender() {
       nodeNotifier.clear();
-      lowerNodeNotifier.clear();
-      upperNodeNotifier.clear();
+      bNodeNotifier.clear();
+      aNodeNotifier.clear();
       edgeNotifier.clear();
       uEdgeNotifier.clear();
Index: lemon/bits/array_map.h
===================================================================
--- lemon/bits/array_map.h	(revision 1875)
+++ lemon/bits/array_map.h	(revision 1910)
@@ -3,5 +3,5 @@
  *
  * Copyright (C) 2006 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ * (Egervary Research Groin on Combinatorial Optimization, EGRES).
  *
  * Permission to use, modify and distribute this software is granted
@@ -24,5 +24,5 @@
 #include <lemon/concept/maps.h>
 
-/// \ingroup graphmapfactory
+/// \ingroin graphmapfactory
 /// \file
 /// \brief Graph maps that construct and destruct
@@ -31,10 +31,10 @@
 namespace lemon {
 
-  /// \ingroup graphmapfactory
+  /// \ingroin graphmapfactory
   ///
   /// \brief Graph map based on the array storage.
   ///
   /// The ArrayMap template class is graph map structure what
-  /// automatically updates the map when a key is added to or erased from
+  /// automatically indates the map when a key is added to or erased from
   /// the map. This map uses the allocators to implement 
   /// the container functionality.
Index: lemon/bits/clearable_graph_extender.h
===================================================================
--- lemon/bits/clearable_graph_extender.h	(revision 1909)
+++ lemon/bits/clearable_graph_extender.h	(revision 1910)
@@ -80,13 +80,13 @@
 
   template <typename _Base>
-  class ClearableUBipartiteGraphExtender : public _Base {
+  class ClearableBpUGraphExtender : public _Base {
   public:
 
     typedef _Base Parent;
-    typedef ClearableUBipartiteGraphExtender Graph;
+    typedef ClearableBpUGraphExtender Graph;
 
     typedef typename Parent::Node Node;
-    typedef typename Parent::LowerNode LowerNode;
-    typedef typename Parent::UpperNode UpperNode;
+    typedef typename Parent::BNode BNode;
+    typedef typename Parent::ANode ANode;
     typedef typename Parent::Edge Edge;
     typedef typename Parent::UEdge UEdge;
@@ -96,6 +96,6 @@
       Parent::getNotifier(UEdge()).clear();
       Parent::getNotifier(Node()).clear();
-      Parent::getNotifier(LowerNode()).clear();
-      Parent::getNotifier(UpperNode()).clear();
+      Parent::getNotifier(BNode()).clear();
+      Parent::getNotifier(ANode()).clear();
       Parent::clear();
     }
Index: lemon/bits/default_map.h
===================================================================
--- lemon/bits/default_map.h	(revision 1909)
+++ lemon/bits/default_map.h	(revision 1910)
@@ -3,5 +3,5 @@
  *
  * Copyright (C) 2006 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ * (Egervary Research Groin on Combinatorial Optimization, EGRES).
  *
  * Permission to use, modify and distribute this software is granted
@@ -22,5 +22,5 @@
 #include <lemon/bits/vector_map.h>
 
-///\ingroup graphmapfactory
+///\ingroin graphmapfactory
 ///\file
 ///\brief Graph maps that construct and destruct
@@ -353,31 +353,31 @@
 
   template <typename _Base>
-  class MappableUBipartiteGraphExtender : public _Base {
+  class MappableBpUGraphExtender : public _Base {
   public:
 
     typedef _Base Parent;
-    typedef MappableUBipartiteGraphExtender Graph;
+    typedef MappableBpUGraphExtender Graph;
 
     typedef typename Parent::Node Node;
-    typedef typename Parent::UpperNode UpperNode;
-    typedef typename Parent::LowerNode LowerNode;
+    typedef typename Parent::ANode ANode;
+    typedef typename Parent::BNode BNode;
     typedef typename Parent::Edge Edge;
     typedef typename Parent::UEdge UEdge;
     
     template <typename _Value>
-    class UpperNodeMap 
-      : public IterableMapExtender<DefaultMap<Graph, UpperNode, _Value> > {
-    public:
-      typedef MappableUBipartiteGraphExtender Graph;
-      typedef IterableMapExtender<DefaultMap<Graph, UpperNode, _Value> > 
+    class ANodeMap 
+      : public IterableMapExtender<DefaultMap<Graph, ANode, _Value> > {
+    public:
+      typedef MappableBpUGraphExtender Graph;
+      typedef IterableMapExtender<DefaultMap<Graph, ANode, _Value> > 
       Parent;
     
-      UpperNodeMap(const Graph& _g) 
-	: Parent(_g) {}
-      UpperNodeMap(const Graph& _g, const _Value& _v) 
-	: Parent(_g, _v) {}
-    
-      UpperNodeMap& operator=(const UpperNodeMap& cmap) {
-	return operator=<UpperNodeMap>(cmap);
+      ANodeMap(const Graph& _g) 
+	: Parent(_g) {}
+      ANodeMap(const Graph& _g, const _Value& _v) 
+	: Parent(_g, _v) {}
+    
+      ANodeMap& operator=(const ANodeMap& cmap) {
+	return operator=<ANodeMap>(cmap);
       }
     
@@ -387,34 +387,34 @@
       /// The given parameter should be conform to the ReadMap
       /// concept and could be indiced by the current item set of
-      /// the UpperNodeMap. In this case the value for each item
+      /// the ANodeMap. In this case the value for each item
       /// is assigned by the value of the given ReadMap. 
       template <typename CMap>
-      UpperNodeMap& operator=(const CMap& cmap) {
-	checkConcept<concept::ReadMap<UpperNode, _Value>, CMap>();
-	const typename Parent::Graph* graph = Parent::getGraph();
-	UpperNode it;
-	for (graph->first(it); it != INVALID; graph->next(it)) {
-	  Parent::set(it, cmap[it]);
-	}
-	return *this;
-      }
-    
-    };
-
-    template <typename _Value>
-    class LowerNodeMap 
-      : public IterableMapExtender<DefaultMap<Graph, LowerNode, _Value> > {
-    public:
-      typedef MappableUBipartiteGraphExtender Graph;
-      typedef IterableMapExtender<DefaultMap<Graph, LowerNode, _Value> > 
+      ANodeMap& operator=(const CMap& cmap) {
+	checkConcept<concept::ReadMap<ANode, _Value>, CMap>();
+	const typename Parent::Graph* graph = Parent::getGraph();
+	ANode it;
+	for (graph->first(it); it != INVALID; graph->next(it)) {
+	  Parent::set(it, cmap[it]);
+	}
+	return *this;
+      }
+    
+    };
+
+    template <typename _Value>
+    class BNodeMap 
+      : public IterableMapExtender<DefaultMap<Graph, BNode, _Value> > {
+    public:
+      typedef MappableBpUGraphExtender Graph;
+      typedef IterableMapExtender<DefaultMap<Graph, BNode, _Value> > 
       Parent;
     
-      LowerNodeMap(const Graph& _g) 
-	: Parent(_g) {}
-      LowerNodeMap(const Graph& _g, const _Value& _v) 
-	: Parent(_g, _v) {}
-    
-      LowerNodeMap& operator=(const LowerNodeMap& cmap) {
-	return operator=<LowerNodeMap>(cmap);
+      BNodeMap(const Graph& _g) 
+	: Parent(_g) {}
+      BNodeMap(const Graph& _g, const _Value& _v) 
+	: Parent(_g, _v) {}
+    
+      BNodeMap& operator=(const BNodeMap& cmap) {
+	return operator=<BNodeMap>(cmap);
       }
     
@@ -424,11 +424,11 @@
       /// The given parameter should be conform to the ReadMap
       /// concept and could be indiced by the current item set of
-      /// the LowerNodeMap. In this case the value for each item
+      /// the BNodeMap. In this case the value for each item
       /// is assigned by the value of the given ReadMap. 
       template <typename CMap>
-      LowerNodeMap& operator=(const CMap& cmap) {
-	checkConcept<concept::ReadMap<LowerNode, _Value>, CMap>();
-	const typename Parent::Graph* graph = Parent::getGraph();
-	LowerNode it;
+      BNodeMap& operator=(const CMap& cmap) {
+	checkConcept<concept::ReadMap<BNode, _Value>, CMap>();
+	const typename Parent::Graph* graph = Parent::getGraph();
+	BNode it;
 	for (graph->first(it); it != INVALID; graph->next(it)) {
 	  Parent::set(it, cmap[it]);
@@ -444,5 +444,5 @@
     class NodeMapBase : public Parent::NodeNotifier::ObserverBase {
     public:
-      typedef MappableUBipartiteGraphExtender Graph;
+      typedef MappableBpUGraphExtender Graph;
 
       typedef Node Key;
@@ -450,24 +450,24 @@
 
       /// The reference type of the map;
-      typedef typename LowerNodeMap<_Value>::Reference Reference;
+      typedef typename BNodeMap<_Value>::Reference Reference;
       /// The pointer type of the map;
-      typedef typename LowerNodeMap<_Value>::Pointer Pointer;
+      typedef typename BNodeMap<_Value>::Pointer Pointer;
       
       /// The const value type of the map.
       typedef const Value ConstValue;
       /// The const reference type of the map;
-      typedef typename LowerNodeMap<_Value>::ConstReference ConstReference;
+      typedef typename BNodeMap<_Value>::ConstReference ConstReference;
       /// The pointer type of the map;
-      typedef typename LowerNodeMap<_Value>::ConstPointer ConstPointer;
+      typedef typename BNodeMap<_Value>::ConstPointer ConstPointer;
 
       typedef True ReferenceMapTag;
 
       NodeMapBase(const Graph& _g) 
-	: graph(&_g), lowerMap(_g), upperMap(_g) {
+	: graph(&_g), bNodeMap(_g), aNodeMap(_g) {
 	Parent::NodeNotifier::ObserverBase::attach(_g.getNotifier(Node()));
       }
       NodeMapBase(const Graph& _g, const _Value& _v) 
-	: graph(&_g), lowerMap(_g, _v), 
-	  upperMap(_g, _v) {
+	: graph(&_g), bNodeMap(_g, _v), 
+	  aNodeMap(_g, _v) {
 	Parent::NodeNotifier::ObserverBase::attach(_g.getNotifier(Node()));
       }
@@ -480,24 +480,24 @@
     
       ConstReference operator[](const Key& node) const {
-	if (Parent::upper(node)) {
-	  return upperMap[node];
+	if (Parent::aNode(node)) {
+	  return aNodeMap[node];
 	} else {
-	  return lowerMap[node];
+	  return bNodeMap[node];
 	}
       } 
 
       Reference operator[](const Key& node) {
-	if (Parent::upper(node)) {
-	  return upperMap[node];
+	if (Parent::aNode(node)) {
+	  return aNodeMap[node];
 	} else {
-	  return lowerMap[node];
+	  return bNodeMap[node];
 	}
       }
 
       void set(const Key& node, const Value& value) {
-	if (Parent::upper(node)) {
-	  upperMap.set(node, value);
+	if (Parent::aNode(node)) {
+	  aNodeMap.set(node, value);
 	} else {
-	  lowerMap.set(node, value);
+	  bNodeMap.set(node, value);
 	}
       }
@@ -514,6 +514,6 @@
     private:
       const Graph* graph;
-      LowerNodeMap<_Value> lowerMap;
-      UpperNodeMap<_Value> upperMap;
+      BNodeMap<_Value> bNodeMap;
+      ANodeMap<_Value> aNodeMap;
     };
     
@@ -524,5 +524,5 @@
       : public IterableMapExtender<NodeMapBase<_Value> > {
     public:
-      typedef MappableUBipartiteGraphExtender Graph;
+      typedef MappableBpUGraphExtender Graph;
       typedef IterableMapExtender< NodeMapBase<_Value> > Parent;
     
@@ -562,5 +562,5 @@
       : public IterableMapExtender<DefaultMap<Graph, Edge, _Value> > {
     public:
-      typedef MappableUBipartiteGraphExtender Graph;
+      typedef MappableBpUGraphExtender Graph;
       typedef IterableMapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
     
@@ -590,5 +590,5 @@
       : public IterableMapExtender<DefaultMap<Graph, UEdge, _Value> > {
     public:
-      typedef MappableUBipartiteGraphExtender Graph;
+      typedef MappableBpUGraphExtender Graph;
       typedef IterableMapExtender<DefaultMap<Graph, UEdge, _Value> > 
       Parent;
Index: lemon/bits/extendable_graph_extender.h
===================================================================
--- lemon/bits/extendable_graph_extender.h	(revision 1909)
+++ lemon/bits/extendable_graph_extender.h	(revision 1910)
@@ -106,26 +106,26 @@
 
   template <typename _Base>
-  class ExtendableUBipartiteGraphExtender : public _Base {
+  class ExtendableBpUGraphExtender : public _Base {
   public:
 
     typedef _Base Parent;
-    typedef ExtendableUBipartiteGraphExtender Graph;
+    typedef ExtendableBpUGraphExtender Graph;
   
     typedef typename Parent::Node Node;
-    typedef typename Parent::LowerNode LowerNode;
-    typedef typename Parent::UpperNode UpperNode;
+    typedef typename Parent::BNode BNode;
+    typedef typename Parent::ANode ANode;
     typedef typename Parent::Edge Edge;
     typedef typename Parent::UEdge UEdge;
   
-    Node addUpperNode() {
-      Node node = Parent::addUpperNode();
-      Parent::getNotifier(UpperNode()).add(node);
+    Node addANode() {
+      Node node = Parent::addANode();
+      Parent::getNotifier(ANode()).add(node);
       Parent::getNotifier(Node()).add(node);
       return node;
     }
 
-    Node addLowerNode() {
-      Node node = Parent::addLowerNode();
-      Parent::getNotifier(LowerNode()).add(node);
+    Node addBNode() {
+      Node node = Parent::addBNode();
+      Parent::getNotifier(BNode()).add(node);
       Parent::getNotifier(Node()).add(node);
       return node;
Index: lemon/bits/graph_extender.h
===================================================================
--- lemon/bits/graph_extender.h	(revision 1909)
+++ lemon/bits/graph_extender.h	(revision 1910)
@@ -3,5 +3,5 @@
  *
  * Copyright (C) 2006 Egervary Jeno Kombinatorikus Optimalizalasi
- * Kutatocsoport (Egervary Research Group on Combinatorial Optimization,
+ * Kutatocsoport (Egervary Research Groin on Combinatorial Optimization,
  * EGRES).
  *
@@ -380,8 +380,8 @@
 
   template <typename _Base>
-  class UBipartiteGraphExtender : public _Base {
+  class BpUGraphExtender : public _Base {
   public:
     typedef _Base Parent;
-    typedef UBipartiteGraphExtender Graph;
+    typedef BpUGraphExtender Graph;
 
     typedef typename Parent::Node Node;
@@ -394,16 +394,16 @@
 
     Node source(const UEdge& edge) const {
-      return upperNode(edge);
+      return aNode(edge);
     }
     Node target(const UEdge& edge) const {
-      return lowerNode(edge);
+      return bNode(edge);
     }
 
     void firstInc(UEdge& edge, bool& direction, const Node& node) const {
-      if (Parent::upper(node)) {
-	Parent::firstDown(edge, node);
+      if (Parent::aNode(node)) {
+	Parent::firstOut(edge, node);
 	direction = true;
       } else {
-	Parent::firstUp(edge, node);
+	Parent::firstIn(edge, node);
 	direction = static_cast<UEdge&>(edge) == INVALID;
       }
@@ -411,7 +411,7 @@
     void nextInc(UEdge& edge, bool& direction) const {
       if (direction) {
-	Parent::nextDown(edge);
-      } else {
-	Parent::nextUp(edge);
+	Parent::nextOut(edge);
+      } else {
+	Parent::nextIn(edge);
 	if (edge == INVALID) direction = true;
       }
@@ -427,5 +427,5 @@
 
     class Edge : public UEdge {
-      friend class UBipartiteGraphExtender;
+      friend class BpUGraphExtender;
     protected:
       bool forward;
@@ -462,9 +462,9 @@
 
     void firstOut(Edge& edge, const Node& node) const {
-      if (Parent::upper(node)) {
-	Parent::firstDown(edge, node);
+      if (Parent::aNode(node)) {
+	Parent::firstOut(edge, node);
 	edge.forward = true;
       } else {
-	Parent::firstUp(edge, node);
+	Parent::firstIn(edge, node);
 	edge.forward = static_cast<UEdge&>(edge) == INVALID;
       }
@@ -472,7 +472,7 @@
     void nextOut(Edge& edge) const {
       if (edge.forward) {
-	Parent::nextDown(edge);
-      } else {
-	Parent::nextUp(edge);
+	Parent::nextOut(edge);
+      } else {
+	Parent::nextIn(edge);
         edge.forward = static_cast<UEdge&>(edge) == INVALID;
       }
@@ -480,9 +480,9 @@
 
     void firstIn(Edge& edge, const Node& node) const {
-      if (Parent::lower(node)) {
-	Parent::firstUp(edge, node);
+      if (Parent::bNode(node)) {
+	Parent::firstIn(edge, node);
 	edge.forward = true;	
       } else {
-	Parent::firstDown(edge, node);
+	Parent::firstOut(edge, node);
 	edge.forward = static_cast<UEdge&>(edge) == INVALID;
       }
@@ -490,7 +490,7 @@
     void nextIn(Edge& edge) const {
       if (edge.forward) {
-	Parent::nextUp(edge);
-      } else {
-	Parent::nextDown(edge);
+	Parent::nextIn(edge);
+      } else {
+	Parent::nextOut(edge);
 	edge.forward = static_cast<UEdge&>(edge) == INVALID;
       }
@@ -498,8 +498,8 @@
 
     Node source(const Edge& edge) const {
-      return edge.forward ? Parent::upperNode(edge) : Parent::lowerNode(edge);
+      return edge.forward ? Parent::aNode(edge) : Parent::bNode(edge);
     }
     Node target(const Edge& edge) const {
-      return edge.forward ? Parent::lowerNode(edge) : Parent::upperNode(edge);
+      return edge.forward ? Parent::bNode(edge) : Parent::aNode(edge);
     }
 
@@ -535,46 +535,46 @@
     }
 
-    class UpperNode : public Node {
-      friend class UBipartiteGraphExtender;
+    class ANode : public Node {
+      friend class BpUGraphExtender;
     public:
-      UpperNode() {}
-      UpperNode(const Node& node) : Node(node) {
-	LEMON_ASSERT(Parent::upper(node) || node == INVALID, 
+      ANode() {}
+      ANode(const Node& node) : Node(node) {
+	LEMON_ASSERT(Parent::aNode(node) || node == INVALID, 
 		     typename Parent::NodeSetError());
       }
-      UpperNode(Invalid) : Node(INVALID) {}
+      ANode(Invalid) : Node(INVALID) {}
     };
 
-    void first(UpperNode& node) const {
-      Parent::firstUpper(static_cast<Node&>(node));
-    }
-    void next(UpperNode& node) const {
-      Parent::nextUpper(static_cast<Node&>(node));
-    }
-
-    int id(const UpperNode& node) const {
-      return Parent::upperId(node);
-    }
-
-    class LowerNode : public Node {
-      friend class UBipartiteGraphExtender;
+    void first(ANode& node) const {
+      Parent::firstANode(static_cast<Node&>(node));
+    }
+    void next(ANode& node) const {
+      Parent::nextANode(static_cast<Node&>(node));
+    }
+
+    int id(const ANode& node) const {
+      return Parent::aNodeId(node);
+    }
+
+    class BNode : public Node {
+      friend class BpUGraphExtender;
     public:
-      LowerNode() {}
-      LowerNode(const Node& node) : Node(node) {
-	LEMON_ASSERT(Parent::lower(node) || node == INVALID,
+      BNode() {}
+      BNode(const Node& node) : Node(node) {
+	LEMON_ASSERT(Parent::bNode(node) || node == INVALID,
 		     typename Parent::NodeSetError());
       }
-      LowerNode(Invalid) : Node(INVALID) {}
+      BNode(Invalid) : Node(INVALID) {}
     };
 
-    void first(LowerNode& node) const {
-      Parent::firstLower(static_cast<Node&>(node));
-    }
-    void next(LowerNode& node) const {
-      Parent::nextLower(static_cast<Node&>(node));
+    void first(BNode& node) const {
+      Parent::firstBNode(static_cast<Node&>(node));
+    }
+    void next(BNode& node) const {
+      Parent::nextBNode(static_cast<Node&>(node));
     }
   
-    int id(const LowerNode& node) const {
-      return Parent::upperId(node);
+    int id(const BNode& node) const {
+      return Parent::aNodeId(node);
     }
 
@@ -584,9 +584,9 @@
       return Parent::maxNodeId();
     }
-    int maxId(LowerNode) const {
-      return Parent::maxLowerId();
-    }
-    int maxId(UpperNode) const {
-      return Parent::maxUpperId();
+    int maxId(BNode) const {
+      return Parent::maxBNodeId();
+    }
+    int maxId(ANode) const {
+      return Parent::maxANodeId();
     }
     int maxId(Edge) const {
@@ -601,9 +601,9 @@
       return Parent::nodeFromId(id);
     }
-    UpperNode fromId(int id, UpperNode) const {
-      return Parent::fromUpperId(id);
-    }
-    LowerNode fromId(int id, LowerNode) const {
-      return Parent::fromLowerId(id);
+    ANode fromId(int id, ANode) const {
+      return Parent::fromANodeId(id);
+    }
+    BNode fromId(int id, BNode) const {
+      return Parent::fromBNodeId(id);
     }
     Edge fromId(int id, Edge) const {
Index: lemon/bits/item_reader.h
===================================================================
--- lemon/bits/item_reader.h	(revision 1875)
+++ lemon/bits/item_reader.h	(revision 1910)
@@ -3,5 +3,5 @@
  *
  * Copyright (C) 2006 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ * (Egervary Research Groin on Combinatorial Optimization, EGRES).
  *
  * Permission to use, modify and distribute this software is granted
@@ -15,6 +15,6 @@
  */
 
-/// @defgroup item_io Item Readers and Writers
-/// @ingroup io_group
+/// @defgroin item_io Item Readers and Writers
+/// @ingroin io_groin
 /// \brief Item Readers and Writers
 /// 
@@ -23,5 +23,5 @@
 /// read some way. The module make possible to do this.  
 
-/// \ingroup item_io
+/// \ingroin item_io
 /// \file
 /// \brief Item reader bits for lemon input.
@@ -43,5 +43,5 @@
   class DefaultReader;
 
-  /// \ingroup item_io
+  /// \ingroin item_io
   ///
   /// \brief Reader class for quoted strings.
@@ -158,5 +158,5 @@
   };
 
-  /// \ingroup item_io
+  /// \ingroin item_io
   /// \brief Reader for standard containers.
   ///
@@ -205,5 +205,5 @@
   };
 
-  /// \ingroup item_io
+  /// \ingroin item_io
   ///
   /// \brief Reader for standard containers.
@@ -253,5 +253,5 @@
   };
 
-  /// \ingroup item_io
+  /// \ingroin item_io
   /// \brief Reader for parsed string.
   ///
@@ -301,5 +301,5 @@
   };
 
-  /// \ingroup item_io
+  /// \ingroin item_io
   /// \brief Reader for read the whole line.
   ///
@@ -331,5 +331,5 @@
   };
 
-  /// \ingroup item_io
+  /// \ingroin item_io
   /// \brief Reader for std::pair.
   ///
@@ -385,5 +385,5 @@
   };
 
-  /// \ingroup item_io
+  /// \ingroin item_io
   /// 
   /// \brief The default item reader template class.
@@ -472,5 +472,5 @@
     : public PairReader<std::pair<First, Second> > {};
 
-  /// \ingroup item_io
+  /// \ingroin item_io
   /// 
   /// \brief The default item reader for skipping a value in the stream.
@@ -481,5 +481,5 @@
   class DefaultSkipper : public DefaultReader<std::string> {};
 
-  /// \ingroup item_io  
+  /// \ingroin item_io  
   /// \brief Standard ReaderTraits for the GraphReader class.
   ///
Index: lemon/bits/item_writer.h
===================================================================
--- lemon/bits/item_writer.h	(revision 1875)
+++ lemon/bits/item_writer.h	(revision 1910)
@@ -3,5 +3,5 @@
  *
  * Copyright (C) 2006 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ * (Egervary Research Groin on Combinatorial Optimization, EGRES).
  *
  * Permission to use, modify and distribute this software is granted
@@ -15,5 +15,5 @@
  */
 
-/// \ingroup item_io
+/// \ingroin item_io
 /// \file
 /// \brief Item writer bits for lemon output.
@@ -35,5 +35,5 @@
   class DefaultWriter;
 
-  /// \ingroup item_io
+  /// \ingroin item_io
   /// \brief Writer class for quoted strings.
   ///
@@ -118,5 +118,5 @@
   };
 
-  /// \ingroup item_io
+  /// \ingroin item_io
   /// \brief Writer class for quoted char array.
   ///
@@ -146,5 +146,5 @@
 
 
-  /// \ingroup item_io
+  /// \ingroin item_io
   ///
   /// \brief Writer for standard containers.
@@ -188,5 +188,5 @@
   };
 
-  /// \ingroup item_io
+  /// \ingroin item_io
   ///
   /// \brief Writer for standard pairs.
@@ -235,5 +235,5 @@
   };
 
-  /// \ingroup item_io
+  /// \ingroin item_io
   /// 
   /// \brief The default item writer template class.
@@ -308,5 +308,5 @@
     : public PairWriter<std::pair<First, Second> > {};
 
-  /// \ingroup item_io
+  /// \ingroin item_io
   /// \brief Standard WriterTraits for the section writers.
   ///
Index: lemon/bits/iterable_graph_extender.h
===================================================================
--- lemon/bits/iterable_graph_extender.h	(revision 1909)
+++ lemon/bits/iterable_graph_extender.h	(revision 1910)
@@ -271,12 +271,12 @@
 
   template <typename _Base>
-  class IterableUBipartiteGraphExtender : public _Base {
+  class IterableBpUGraphExtender : public _Base {
   public:
     typedef _Base Parent;
-    typedef IterableUBipartiteGraphExtender Graph;
+    typedef IterableBpUGraphExtender Graph;
    
     typedef typename Parent::Node Node;
-    typedef typename Parent::UpperNode UpperNode;
-    typedef typename Parent::LowerNode LowerNode;
+    typedef typename Parent::ANode ANode;
+    typedef typename Parent::BNode BNode;
     typedef typename Parent::Edge Edge;
     typedef typename Parent::UEdge UEdge;
@@ -304,44 +304,44 @@
     };
 
-    class UpperNodeIt : public Node { 
-      friend class IterableUBipartiteGraphExtender;
-      const Graph* graph;
-    public:
-    
-      UpperNodeIt() { }
-    
-      UpperNodeIt(Invalid i) : Node(INVALID) { }
-    
-      explicit UpperNodeIt(const Graph& _graph) : graph(&_graph) {
-	graph->firstUpper(static_cast<Node&>(*this));
-      }
-
-      UpperNodeIt(const Graph& _graph, const Node& node) 
+    class ANodeIt : public Node { 
+      friend class IterableBpUGraphExtender;
+      const Graph* graph;
+    public:
+    
+      ANodeIt() { }
+    
+      ANodeIt(Invalid i) : Node(INVALID) { }
+    
+      explicit ANodeIt(const Graph& _graph) : graph(&_graph) {
+	graph->firstANode(static_cast<Node&>(*this));
+      }
+
+      ANodeIt(const Graph& _graph, const Node& node) 
 	: Node(node), graph(&_graph) {}
     
-      UpperNodeIt& operator++() { 
-	graph->nextUpper(*this);
-	return *this; 
-      }
-    };
-
-    class LowerNodeIt : public Node { 
-      friend class IterableUBipartiteGraphExtender;
-      const Graph* graph;
-    public:
-    
-      LowerNodeIt() { }
-    
-      LowerNodeIt(Invalid i) : Node(INVALID) { }
-    
-      explicit LowerNodeIt(const Graph& _graph) : graph(&_graph) {
-	graph->firstLower(static_cast<Node&>(*this));
-      }
-
-      LowerNodeIt(const Graph& _graph, const Node& node) 
+      ANodeIt& operator++() { 
+	graph->nextANode(*this);
+	return *this; 
+      }
+    };
+
+    class BNodeIt : public Node { 
+      friend class IterableBpUGraphExtender;
+      const Graph* graph;
+    public:
+    
+      BNodeIt() { }
+    
+      BNodeIt(Invalid i) : Node(INVALID) { }
+    
+      explicit BNodeIt(const Graph& _graph) : graph(&_graph) {
+	graph->firstBNode(static_cast<Node&>(*this));
+      }
+
+      BNodeIt(const Graph& _graph, const Node& node) 
 	: Node(node), graph(&_graph) {}
     
-      LowerNodeIt& operator++() { 
-	graph->nextLower(*this);
+      BNodeIt& operator++() { 
+	graph->nextBNode(*this);
 	return *this; 
       }
@@ -349,5 +349,5 @@
 
     class EdgeIt : public Edge { 
-      friend class IterableUBipartiteGraphExtender;
+      friend class IterableBpUGraphExtender;
       const Graph* graph;
     public:
@@ -372,5 +372,5 @@
 
     class UEdgeIt : public UEdge { 
-      friend class IterableUBipartiteGraphExtender;
+      friend class IterableBpUGraphExtender;
       const Graph* graph;
     public:
@@ -394,5 +394,5 @@
 
     class OutEdgeIt : public Edge { 
-      friend class IterableUBipartiteGraphExtender;
+      friend class IterableBpUGraphExtender;
       const Graph* graph;
     public:
@@ -419,5 +419,5 @@
 
     class InEdgeIt : public Edge { 
-      friend class IterableUBipartiteGraphExtender;
+      friend class IterableBpUGraphExtender;
       const Graph* graph;
     public:
@@ -471,5 +471,5 @@
   
     class IncEdgeIt : public Parent::UEdge { 
-      friend class IterableUBipartiteGraphExtender;
+      friend class IterableBpUGraphExtender;
       const Graph* graph;
       bool direction;
Index: lemon/bits/map_extender.h
===================================================================
--- lemon/bits/map_extender.h	(revision 1875)
+++ lemon/bits/map_extender.h	(revision 1910)
@@ -3,5 +3,5 @@
  *
  * Copyright (C) 2006 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ * (Egervary Research Groin on Combinatorial Optimization, EGRES).
  *
  * Permission to use, modify and distribute this software is granted
Index: lemon/bits/static_map.h
===================================================================
--- lemon/bits/static_map.h	(revision 1909)
+++ lemon/bits/static_map.h	(revision 1910)
@@ -3,5 +3,5 @@
  *
  * Copyright (C) 2006 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ * (Egervary Research Groin on Combinatorial Optimization, EGRES).
  *
  * Permission to use, modify and distribute this software is granted
@@ -28,5 +28,5 @@
 #include <lemon/concept/maps.h>
 
-/// \ingroup graphmaps
+/// \ingroin graphmaps
 ///
 ///\file
@@ -35,10 +35,10 @@
 namespace lemon {
 
-  /// \ingroup graphmaps
+  /// \ingroin graphmaps
   ///
   /// \brief Graph map with static sized storage.
   ///
   /// The StaticMap template class is graph map structure what
-  /// does not update automatically the map when a key is added to or 
+  /// does not indate automatically the map when a key is added to or 
   /// erased from the map rather it throws an exception. This map factory 
   /// uses the allocators to implement the container functionality.
@@ -55,9 +55,9 @@
   public:
 
-    /// \brief Exception class for unsupported exceptions.
-    class UnsupportedOperation : public lemon::LogicError {
+    /// \brief Exception class for unsinported exceptions.
+    class UnsinportedOperation : public lemon::LogicError {
     public:
       virtual const char* exceptionName() const {
-	return "lemon::StaticMap::UnsupportedOperation";
+	return "lemon::StaticMap::UnsinportedOperation";
       }
     };
@@ -186,5 +186,5 @@
      
     void add(const Key&) {
-      throw UnsupportedOperation();
+      throw UnsinportedOperation();
     }
 
@@ -194,5 +194,5 @@
     /// and it overrides the erase() member function of the observer base.     
     void erase(const Key&) {
-      throw UnsupportedOperation();
+      throw UnsinportedOperation();
     }
 
@@ -347,31 +347,31 @@
 
   template <typename _Base>
-  class StaticMappableUBipartiteGraphExtender : public _Base {
+  class StaticMappableBpUGraphExtender : public _Base {
   public:
 
     typedef _Base Parent;
-    typedef StaticMappableUBipartiteGraphExtender Graph;
+    typedef StaticMappableBpUGraphExtender Graph;
 
     typedef typename Parent::Node Node;
-    typedef typename Parent::UpperNode UpperNode;
-    typedef typename Parent::LowerNode LowerNode;
+    typedef typename Parent::ANode ANode;
+    typedef typename Parent::BNode BNode;
     typedef typename Parent::Edge Edge;
     typedef typename Parent::UEdge UEdge;
     
     template <typename _Value>
-    class UpperNodeMap 
-      : public IterableMapExtender<StaticMap<Graph, UpperNode, _Value> > {
-    public:
-      typedef StaticMappableUBipartiteGraphExtender Graph;
-      typedef IterableMapExtender<StaticMap<Graph, UpperNode, _Value> > 
+    class ANodeMap 
+      : public IterableMapExtender<StaticMap<Graph, ANode, _Value> > {
+    public:
+      typedef StaticMappableBpUGraphExtender Graph;
+      typedef IterableMapExtender<StaticMap<Graph, ANode, _Value> > 
       Parent;
     
-      UpperNodeMap(const Graph& _g) 
-	: Parent(_g) {}
-      UpperNodeMap(const Graph& _g, const _Value& _v) 
-	: Parent(_g, _v) {}
-    
-      UpperNodeMap& operator=(const UpperNodeMap& cmap) {
-	return operator=<UpperNodeMap>(cmap);
+      ANodeMap(const Graph& _g) 
+	: Parent(_g) {}
+      ANodeMap(const Graph& _g, const _Value& _v) 
+	: Parent(_g, _v) {}
+    
+      ANodeMap& operator=(const ANodeMap& cmap) {
+	return operator=<ANodeMap>(cmap);
       }
     
@@ -381,34 +381,34 @@
       /// The given parameter should be conform to the ReadMap
       /// concept and could be indiced by the current item set of
-      /// the UpperNodeMap. In this case the value for each item
+      /// the ANodeMap. In this case the value for each item
       /// is assigned by the value of the given ReadMap. 
       template <typename CMap>
-      UpperNodeMap& operator=(const CMap& cmap) {
-	checkConcept<concept::ReadMap<UpperNode, _Value>, CMap>();
-	const typename Parent::Graph* graph = Parent::getGraph();
-	UpperNode it;
-	for (graph->first(it); it != INVALID; graph->next(it)) {
-	  Parent::set(it, cmap[it]);
-	}
-	return *this;
-      }
-    
-    };
-
-    template <typename _Value>
-    class LowerNodeMap 
-      : public IterableMapExtender<StaticMap<Graph, LowerNode, _Value> > {
-    public:
-      typedef StaticMappableUBipartiteGraphExtender Graph;
-      typedef IterableMapExtender<StaticMap<Graph, LowerNode, _Value> > 
+      ANodeMap& operator=(const CMap& cmap) {
+	checkConcept<concept::ReadMap<ANode, _Value>, CMap>();
+	const typename Parent::Graph* graph = Parent::getGraph();
+	ANode it;
+	for (graph->first(it); it != INVALID; graph->next(it)) {
+	  Parent::set(it, cmap[it]);
+	}
+	return *this;
+      }
+    
+    };
+
+    template <typename _Value>
+    class BNodeMap 
+      : public IterableMapExtender<StaticMap<Graph, BNode, _Value> > {
+    public:
+      typedef StaticMappableBpUGraphExtender Graph;
+      typedef IterableMapExtender<StaticMap<Graph, BNode, _Value> > 
       Parent;
     
-      LowerNodeMap(const Graph& _g) 
-	: Parent(_g) {}
-      LowerNodeMap(const Graph& _g, const _Value& _v) 
-	: Parent(_g, _v) {}
-    
-      LowerNodeMap& operator=(const LowerNodeMap& cmap) {
-	return operator=<LowerNodeMap>(cmap);
+      BNodeMap(const Graph& _g) 
+	: Parent(_g) {}
+      BNodeMap(const Graph& _g, const _Value& _v) 
+	: Parent(_g, _v) {}
+    
+      BNodeMap& operator=(const BNodeMap& cmap) {
+	return operator=<BNodeMap>(cmap);
       }
     
@@ -418,11 +418,11 @@
       /// The given parameter should be conform to the ReadMap
       /// concept and could be indiced by the current item set of
-      /// the LowerNodeMap. In this case the value for each item
+      /// the BNodeMap. In this case the value for each item
       /// is assigned by the value of the given ReadMap. 
       template <typename CMap>
-      LowerNodeMap& operator=(const CMap& cmap) {
-	checkConcept<concept::ReadMap<LowerNode, _Value>, CMap>();
-	const typename Parent::Graph* graph = Parent::getGraph();
-	LowerNode it;
+      BNodeMap& operator=(const CMap& cmap) {
+	checkConcept<concept::ReadMap<BNode, _Value>, CMap>();
+	const typename Parent::Graph* graph = Parent::getGraph();
+	BNode it;
 	for (graph->first(it); it != INVALID; graph->next(it)) {
 	  Parent::set(it, cmap[it]);
@@ -438,5 +438,5 @@
     class NodeMapBase : public Parent::NodeNotifier::ObserverBase {
     public:
-      typedef StaticMappableUBipartiteGraphExtender Graph;
+      typedef StaticMappableBpUGraphExtender Graph;
 
       typedef Node Key;
@@ -444,24 +444,24 @@
 
       /// The reference type of the map;
-      typedef typename LowerNodeMap<_Value>::Reference Reference;
+      typedef typename BNodeMap<_Value>::Reference Reference;
       /// The pointer type of the map;
-      typedef typename LowerNodeMap<_Value>::Pointer Pointer;
+      typedef typename BNodeMap<_Value>::Pointer Pointer;
       
       /// The const value type of the map.
       typedef const Value ConstValue;
       /// The const reference type of the map;
-      typedef typename LowerNodeMap<_Value>::ConstReference ConstReference;
+      typedef typename BNodeMap<_Value>::ConstReference ConstReference;
       /// The pointer type of the map;
-      typedef typename LowerNodeMap<_Value>::ConstPointer ConstPointer;
+      typedef typename BNodeMap<_Value>::ConstPointer ConstPointer;
 
       typedef True ReferenceMapTag;
 
       NodeMapBase(const Graph& _g) 
-	: graph(&_g), lowerMap(_g), upperMap(_g) {
+	: graph(&_g), bNodeMap(_g), aNodeMap(_g) {
 	Parent::NodeNotifier::ObserverBase::attach(_g.getNotifier(Node()));
       }
       NodeMapBase(const Graph& _g, const _Value& _v) 
-	: graph(&_g), lowerMap(_g, _v), 
-	  upperMap(_g, _v) {
+	: graph(&_g), bNodeMap(_g, _v), 
+	  aNodeMap(_g, _v) {
 	Parent::NodeNotifier::ObserverBase::attach(_g.getNotifier(Node()));
       }
@@ -474,24 +474,24 @@
     
       ConstReference operator[](const Key& node) const {
-	if (Parent::upper(node)) {
-	  return upperMap[node];
+	if (Parent::aNode(node)) {
+	  return aNodeMap[node];
 	} else {
-	  return lowerMap[node];
+	  return bNodeMap[node];
 	}
       } 
 
       Reference operator[](const Key& node) {
-	if (Parent::upper(node)) {
-	  return upperMap[node];
+	if (Parent::aNode(node)) {
+	  return aNodeMap[node];
 	} else {
-	  return lowerMap[node];
+	  return bNodeMap[node];
 	}
       }
 
       void set(const Key& node, const Value& value) {
-	if (Parent::upper(node)) {
-	  upperMap.set(node, value);
+	if (Parent::aNode(node)) {
+	  aNodeMap.set(node, value);
 	} else {
-	  lowerMap.set(node, value);
+	  bNodeMap.set(node, value);
 	}
       }
@@ -508,6 +508,6 @@
     private:
       const Graph* graph;
-      LowerNodeMap<_Value> lowerMap;
-      UpperNodeMap<_Value> upperMap;
+      BNodeMap<_Value> bNodeMap;
+      ANodeMap<_Value> aNodeMap;
     };
     
@@ -518,5 +518,5 @@
       : public IterableMapExtender<NodeMapBase<_Value> > {
     public:
-      typedef StaticMappableUBipartiteGraphExtender Graph;
+      typedef StaticMappableBpUGraphExtender Graph;
       typedef IterableMapExtender< NodeMapBase<_Value> > Parent;
     
@@ -556,5 +556,5 @@
       : public IterableMapExtender<StaticMap<Graph, Edge, _Value> > {
     public:
-      typedef StaticMappableUBipartiteGraphExtender Graph;
+      typedef StaticMappableBpUGraphExtender Graph;
       typedef IterableMapExtender<StaticMap<Graph, Edge, _Value> > Parent;
     
@@ -584,5 +584,5 @@
       : public IterableMapExtender<StaticMap<Graph, UEdge, _Value> > {
     public:
-      typedef StaticMappableUBipartiteGraphExtender Graph;
+      typedef StaticMappableBpUGraphExtender Graph;
       typedef IterableMapExtender<StaticMap<Graph, UEdge, _Value> > 
       Parent;
Index: lemon/bits/vector_map.h
===================================================================
--- lemon/bits/vector_map.h	(revision 1875)
+++ lemon/bits/vector_map.h	(revision 1910)
@@ -3,5 +3,5 @@
  *
  * Copyright (C) 2006 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
+ * (Egervary Research Groin on Combinatorial Optimization, EGRES).
  *
  * Permission to use, modify and distribute this software is granted
@@ -27,5 +27,5 @@
 #include <lemon/concept/maps.h>
 
-/// \ingroup graphmapfactory
+/// \ingroin graphmapfactory
 ///
 ///\file
@@ -34,10 +34,10 @@
 namespace lemon {
 
-  /// \ingroup graphmapfactory
+  /// \ingroin graphmapfactory
   ///
   /// \brief Graph map based on the std::vector storage.
   ///
   /// The VectorMap template class is graph map structure what
-  /// automatically updates the map when a key is added to or erased from
+  /// automatically indates the map when a key is added to or erased from
   /// the map. This map factory uses the allocators to implement 
   /// the container functionality. This map factory
