Index: doc/coding_style.dox
===================================================================
--- doc/coding_style.dox	(revision 811)
+++ doc/coding_style.dox	(revision 921)
@@ -1,5 +1,5 @@
 /*!
 
-\page coding_style Hugo Coding Style 
+\page coding_style LEMON Coding Style 
 
 \section naming_conv Naming Conventions
@@ -10,5 +10,5 @@
 are met in one's code then it is easier to read and maintain
 it. Please comply with these conventions if you want to contribute
-developing Hugo library.
+developing LEMON library.
 
 \subsection cs-class Classes and other types
Index: doc/graphs.dox
===================================================================
--- doc/graphs.dox	(revision 911)
+++ doc/graphs.dox	(revision 921)
@@ -3,5 +3,5 @@
 \page graphs How to use graphs
 
-The primary data structures of HugoLib are the graph classes. They all
+The primary data structures of LEMON are the graph classes. They all
 provide a node list - edge list interface, i.e. they have
 functionalities to list the nodes and the edges of the graph as well
@@ -10,5 +10,5 @@
 
 Each graph should meet the
-\ref hugo::skeleton::StaticGraph "StaticGraph" concept.
+\ref lemon::skeleton::StaticGraph "StaticGraph" concept.
 This concept does not
 makes it possible to change the graph (i.e. it is not possible to add
@@ -17,5 +17,5 @@
 
 The graphs meeting the
-\ref hugo::skeleton::ExtendableGraph "ExtendableGraph"
+\ref lemon::skeleton::ExtendableGraph "ExtendableGraph"
 concept allow node and
 edge addition. You can also "clear" (i.e. erase all edges and nodes)
@@ -23,20 +23,20 @@
 
 In case of graphs meeting the full feature
-\ref hugo::skeleton::ErasableGraph "ErasableGraph"
+\ref lemon::skeleton::ErasableGraph "ErasableGraph"
 concept
 you can also erase individual edges and node in arbitrary order.
 
 The implemented graph structures are the following.
-\li \ref hugo::ListGraph "ListGraph" is the most versatile graph class. It meets
-the \ref hugo::skeleton::ErasableGraph "ErasableGraph" concept
+\li \ref lemon::ListGraph "ListGraph" is the most versatile graph class. It meets
+the \ref lemon::skeleton::ErasableGraph "ErasableGraph" concept
 and it also have some convenience features.
-\li \ref hugo::SmartGraph "SmartGraph" is a more memory
-efficient version of \ref hugo::ListGraph "ListGraph". The
+\li \ref lemon::SmartGraph "SmartGraph" is a more memory
+efficient version of \ref lemon::ListGraph "ListGraph". The
 price of it is that it only meets the
-\ref hugo::skeleton::ExtendableGraph "ExtendableGraph" concept,
+\ref lemon::skeleton::ExtendableGraph "ExtendableGraph" concept,
 so you cannot delete individual edges or nodes.
-\li \ref hugo::SymListGraph "SymListGraph" and
-\ref hugo::SymSmartGraph "SymSmartGraph" classes are very similar to
-\ref hugo::ListGraph "ListGraph" and \ref hugo::SmartGraph "SmartGraph".
+\li \ref lemon::SymListGraph "SymListGraph" and
+\ref lemon::SymSmartGraph "SymSmartGraph" classes are very similar to
+\ref lemon::ListGraph "ListGraph" and \ref lemon::SmartGraph "SmartGraph".
 The difference is that whenever you add a
 new edge to the graph, it actually adds a pair of oppositely directed edges.
@@ -45,6 +45,6 @@
 attach data to the edges in such a way that the stored data
 are shared by the edge pairs. 
-\li \ref hugo::FullGraph "FullGraph"
-implements a full graph. It is a \ref hugo::skeleton::StaticGraph, so you cannot
+\li \ref lemon::FullGraph "FullGraph"
+implements a full graph. It is a \ref lemon::skeleton::StaticGraph, so you cannot
 change the number of nodes once it is constructed. It is extremely memory
 efficient: it uses constant amount of memory independently from the number of
@@ -52,9 +52,9 @@
 \ref maps "EdgeMap"'s will depend on the number of nodes.
 
-\li \ref hugo::NodeSet "NodeSet" implements a graph with no edges. This class
-can be used as a base class of \ref hugo::EdgeSet "EdgeSet".
-\li \ref hugo::EdgeSet "EdgeSet" can be used to create a new graph on
+\li \ref lemon::NodeSet "NodeSet" implements a graph with no edges. This class
+can be used as a base class of \ref lemon::EdgeSet "EdgeSet".
+\li \ref lemon::EdgeSet "EdgeSet" can be used to create a new graph on
 the node set of another graph. The base graph can be an arbitrary graph and it
-is possible to attach several \ref hugo::EdgeSet "EdgeSet"'s to a base graph.
+is possible to attach several \ref lemon::EdgeSet "EdgeSet"'s to a base graph.
 
 \todo Don't we need SmartNodeSet and SmartEdgeSet?
@@ -66,12 +66,12 @@
 to dynamically attach data the to graph components.
 
-The following program demonstrates the basic features of HugoLib's graph
+The following program demonstrates the basic features of LEMON's graph
 structures.
 
 \code
 #include <iostream>
-#include <hugo/list_graph.h>
+#include <lemon/list_graph.h>
 
-using namespace hugo;
+using namespace lemon;
 
 int main()
@@ -80,5 +80,5 @@
 \endcode
 
-ListGraph is one of HugoLib's graph classes. It is based on linked lists,
+ListGraph is one of LEMON's graph classes. It is based on linked lists,
 therefore iterating throuh its edges and nodes is fast.
 
@@ -115,5 +115,5 @@
 step to the next node. Using operator++ on the iterator pointing to the last
 node invalidates the iterator i.e. sets its value to
-\ref hugo::INVALID "INVALID". This is what we exploit in the stop condition.
+\ref lemon::INVALID "INVALID". This is what we exploit in the stop condition.
 
 The previous code fragment prints out the following:
@@ -182,5 +182,5 @@
 
 As we mentioned above, graphs are not containers rather
-incidence structures which are iterable in many ways. HugoLib introduces
+incidence structures which are iterable in many ways. LEMON introduces
 concepts that allow us to attach containers to graphs. These containers are
 called maps.
Index: doc/groups.dox
===================================================================
--- doc/groups.dox	(revision 814)
+++ doc/groups.dox	(revision 921)
@@ -2,5 +2,5 @@
 /**
 @defgroup datas Data Structures
-This group describes the several graph structures implemented in HugoLib.
+This group describes the several graph structures implemented in LEMON.
 */
 
@@ -8,7 +8,7 @@
 @defgroup graphs Graph Structures
 @ingroup datas
-\brief Graph structures implemented in Hugo.
+\brief Graph structures implemented in LEMON.
 
-Hugolib provides several data structures to meet the diverging requirements
+LEMON provides several data structures to meet the diverging requirements
 of the possible users.
 In order to save on running time or on memory usage, some structures may
@@ -16,7 +16,7 @@
 some graph features like edge or node deletion.
 
-Hugolib also offers special graphs that cannot be used alone but only
+LEMON also offers special graphs that cannot be used alone but only
 in conjunction with other graph representation. The examples for this are
-\ref hugo::EdgeSet "EdgeSet", \ref hugo::NodeSet "NodeSet"
+\ref lemon::EdgeSet "EdgeSet", \ref lemon::NodeSet "NodeSet"
 and the large variety of \ref gwrappers "graph wrappers".
 
@@ -29,7 +29,7 @@
 @defgroup auxdat Auxiliary Data Structures
 @ingroup datas
-\brief Some data structures implemented in HugoLib.
+\brief Some data structures implemented in LEMON.
 
-This group describes the data structures implemented in HugoLib in
+This group describes the data structures implemented in LEMON in
 order to make it easier to implement combinatorial algorithms.
 */
@@ -53,5 +53,5 @@
 @defgroup galgs Graph Algorithms
 \brief This group describes the several graph algorithms
-implemented in HugoLib.
+implemented in LEMON.
 */
 
@@ -73,5 +73,5 @@
 \brief Skeletons (a.k.a. concept checking classes)
 
-This group describes the data/algorithm skeletons implemented in HugoLib in
+This group describes the data/algorithm skeletons implemented in LEMON in
 order to make it easier to check if a certain template class or
 template function is correctly implemented.
Index: doc/mainpage.dox
===================================================================
--- doc/mainpage.dox	(revision 678)
+++ doc/mainpage.dox	(revision 921)
@@ -4,7 +4,9 @@
 \section intro Introduction
 
-\subsection whatis What is HugoLib
+\subsection whatis What is LEMON
 
-HugoLib stands for Hungarian Graph Optimization Library.
+LEMON stands for
+<it>L</it>ibrary of <it>E</it>fficient <it>M</it>odels
+and <it>O</it>ptimization in <it>N</it>etworks.
 It is a C++ template
 library aimed at combinatorial optimization tasks which
@@ -15,5 +17,5 @@
 \subsection howtoread How to read this document
 
-Graph structures play central role in HugoLib, so if you are new to it,
+Graph structures play central role in LEMON, so if you are new to it,
 you probably should start \ref graphs "here".
 You can also find this page along with others under
Index: doc/maps.dox
===================================================================
--- doc/maps.dox	(revision 697)
+++ doc/maps.dox	(revision 921)
@@ -5,5 +5,5 @@
 \page maps Maps
 
-Maps play central role in HUGOlib. As their name suggests, they map a
+Maps play central role in LEMON. As their name suggests, they map a
 certain range of \e keys to certain \e values. Each map has two
 <tt>typedef</tt>'s to determine the types of keys and values, like this:
@@ -22,5 +22,5 @@
 where it is stored.
 
-Each graph structure in HUGOlib provides two standard map templates called
+Each graph structure in LEMON provides two standard map templates called
 \c EdgeMap and \c NodeMap. Both are reference maps and you can easily
 assign data to the nodes and to the edges of the graph. For example if you
@@ -70,5 +70,5 @@
 The readable maps are very frequently used as the input of the
 algorithms.  For this purpose the most straightforward way is the use of the
-default maps provided by Hugo's graph structures.
+default maps provided by LEMON's graph structures.
 Very often however, it is more
 convenient and/or more efficient to write your own readable map.
Index: doc/namespaces.dox
===================================================================
--- doc/namespaces.dox	(revision 882)
+++ doc/namespaces.dox	(revision 921)
@@ -1,9 +1,9 @@
-/// The namespace of HugoLib
+/// The namespace of LEMON
 
 /// \todo Some more detailed description would be nice here.
 ///
-namespace hugo {
+namespace lemon {
 
-  /// The namespace of HUGOlib concepts and concept checking classes
+  /// The namespace of LEMON concepts and concept checking classes
 
   /// \todo Some more detailed description would be nice here.
