Index: CMakeLists.txt
===================================================================
--- CMakeLists.txt	(revision 1346)
+++ CMakeLists.txt	(revision 1264)
@@ -1,16 +1,3 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
-
-IF(POLICY CMP0048) 
-  CMAKE_POLICY(SET CMP0048 OLD) 
-ENDIF(POLICY CMP0048)
-
-IF(POLICY CMP0043) 
-  CMAKE_POLICY(SET CMP0043 OLD) 
-ENDIF(POLICY CMP0043)
-
-IF(POLICY CMP0026)
-  #This is for copying the dll's needed by glpk (in lp_test and mip_test)
-  CMAKE_POLICY(SET CMP0026 OLD) 
-ENDIF(POLICY CMP0026)
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
 
 SET(PROJECT_NAME "LEMON")
@@ -75,8 +62,4 @@
 FIND_PACKAGE(Doxygen)
 FIND_PACKAGE(Ghostscript)
-
-IF(WIN32)
-  SET(LEMON_WIN32 TRUE)
-ENDIF(WIN32)
 
 SET(LEMON_ENABLE_GLPK YES CACHE STRING "Enable GLPK solver backend.")
@@ -139,7 +122,4 @@
   SET(LEMON_DEFAULT_LP ${DEFAULT_LP} CACHE STRING
     "Default LP solver backend (GLPK, CPLEX, CLP or SOPLEX)" FORCE)
-ELSE()
-  SET(LEMON_DEFAULT_LP ${DEFAULT_LP} CACHE STRING
-    "Default LP solver backend (GLPK, CPLEX, CLP or SOPLEX)")
 ENDIF()
 IF(NOT LEMON_DEFAULT_MIP OR
@@ -149,7 +129,4 @@
   SET(LEMON_DEFAULT_MIP ${DEFAULT_MIP} CACHE STRING
     "Default MIP solver backend (GLPK, CPLEX or CBC)" FORCE)
-ELSE()
-  SET(LEMON_DEFAULT_MIP ${DEFAULT_MIP} CACHE STRING
-    "Default MIP solver backend (GLPK, CPLEX or CBC)")
 ENDIF()
 
@@ -164,11 +141,8 @@
   ELSEIF(MSVC)
     # This part is unnecessary 'casue the same is set by the lemon/core.h.
-    # Still kept as an example.
-
-    # SET(CXX_WARNING "/wd4250 /wd4267 /wd4355 /wd4503 /wd4800 /wd4996")
-
+    # Still keep it as an example.
+    SET(CXX_WARNING "/wd4250 /wd4355 /wd4503 /wd4800 /wd4996")
     # Suppressed warnings:
     # C4250: 'class1' : inherits 'class2::member' via dominance
-    # C4267: conversion from 'size_t' to 'type', possible loss of data
     # C4355: 'this' : used in base member initializer list
     # C4503: 'function' : decorated name length exceeded, name was truncated
@@ -185,5 +159,4 @@
 
 IF(MSVC)
-  SET(CMAKE_CXX_FLAGS "/bigobj ${CMAKE_CXX_FLAGS}")
   SET( CMAKE_CXX_FLAGS_MAINTAINER "/WX ${CMAKE_CXX_FLAGS_DEBUG}" CACHE STRING
     "Flags used by the C++ compiler during maintainer builds."
@@ -208,9 +181,9 @@
     )
   SET( CMAKE_EXE_LINKER_FLAGS_MAINTAINER
-    "${CMAKE_EXE_LINKER_FLAGS_DEBUG}" CACHE STRING
+    "-Wl,--warn-unresolved-symbols,--warn-once" CACHE STRING
     "Flags used for linking binaries during maintainer builds."
     )
   SET( CMAKE_SHARED_LINKER_FLAGS_MAINTAINER
-    "${CMAKE_SHARED_LINKER_FLAGS_DEBUG}" CACHE STRING
+    "-Wl,--warn-unresolved-symbols,--warn-once" CACHE STRING
     "Flags used by the shared libraries linker during maintainer builds."
     )
@@ -239,8 +212,4 @@
     FORCE )
 
-SET_DIRECTORY_PROPERTIES(PROPERTIES
-  COMPILE_DEFINITIONS_DEBUG "LEMON_ENABLE_DEBUG"
-  COMPILE_DEFINITIONS_MAINTAINER "LEMON_ENABLE_DEBUG"
-)
 
 INCLUDE(CheckTypeSize)
@@ -271,12 +240,4 @@
 
 ENABLE_TESTING()
-
-
-INCLUDE(CheckCXXCompilerFlag)
-CHECK_CXX_COMPILER_FLAG("-std=c++11" LEMON_CXX11)
-IF(LEMON_CXX11)
-  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
-ENDIF()
-
 
 IF(${CMAKE_BUILD_TYPE} STREQUAL "Maintainer")
Index: NEWS
===================================================================
--- NEWS	(revision 1281)
+++ NEWS	(revision 962)
@@ -1,100 +1,2 @@
-2013-08-10 Version 1.3 released
-
-        This is major feature release
-
-        * New data structures
-
-          #69 : Bipartite graph concepts and implementations
-
-        * New algorithms
-
-          #177: Port Edmonds-Karp algorithm
-          #380, #405: Heuristic algorithm for the max clique problem
-          #386: Heuristic algorithms for symmetric TSP
-          ----: Nagamochi-Ibaraki algorithm [5087694945e4]
-          #397, #56: Max. cardinality search
-
-        * Other new features
-
-          #223: Thread safe graph and graph map implementations
-          #442: Different TimeStamp print formats
-          #457: File export functionality to LpBase
-          #362: Bidirectional iterator support for radixSort()
-
-        * Implementation improvements
-
-          ----: Network Simplex
-                #391: Better update process, pivot rule and arc mixing
-                #435: Improved Altering List pivot rule
-          #417: Various fine tunings in CostScaling
-          #438: Optional iteration limit in HowardMmc
-          #436: Ensure strongly polynomial running time for CycleCanceling
-                while keeping the same performance
-          ----: Make the CBC interface be compatible with latest CBC releases
-                [ee581a0ecfbf]
-
-        * CMAKE has become the default build environment (#434)
-
-          ----: Autotool support has been dropped
-          ----: Improved LP/MIP configuration
-                #465: Enable/disable options for LP/MIP backends
-                #446: Better CPLEX discovery
-                #460: Add cmake config to find SoPlex
-          ----: Allow CPACK configuration on all platforms
-          #390: Add 'Maintainer' CMAKE build type
-          #388: Add 'check' target.
-          #401: Add contrib dir
-          #389: Better version string setting in CMAKE
-          #433: Support shared library build    
-          #416: Support testing with valgrind
-  
-        * Doc improvements
-
-          #395: SOURCE_BROWSER Doxygen switch is configurable from CMAKE
-                update-external-tags CMAKE target
-          #455: Optionally use MathJax for rendering the math formulae
-          #402, #437, #459, #456, #463: Various doc improvements
-
-        * Bugfixes (compared to release 1.2):
-
-          #432: Add missing doc/template.h and doc/references.bib to release
-                tarball
-          ----: Intel C++ compatibility fixes
-          #441: Fix buggy reinitialization in _solver_bits::VarIndex::clear()
-          #444: Bugfix in path copy constructors and assignment operators
-          #447: Bugfix in AllArcLookUp<>
-          #448: Bugfix in adaptor_test.cc
-          #449: Fix clang compilation warnings and errors
-          #440: Fix a bug + remove redundant typedefs in dimacs-solver
-          #453: Avoid GCC 4.7 compiler warnings
-          #445: Fix missing initialization in CplexEnv::CplexEnv()
-          #428: Add missing lemon/lemon.pc.cmake to the release tarball
-          #393: Create and install lemon.pc
-          #429: Fix VS warnings
-          #430: Fix LpBase::Constr two-side limit bug
-          #392: Bug fix in Dfs::start(s,t)
-          #414: Fix wrong initialization in Preflow
-          #418: Better Win CodeBlock/MinGW support
-          #419: Build environment improvements
-                - Build of mip_test and lp_test precede the running of the tests
-                - Also search for coin libs under ${COIN_ROOT_DIR}/lib/coin
-                - Do not look for COIN_VOL libraries
-          #382: Allow lgf file without Arc maps
-          #417: Bug fix in CostScaling
-          #366: Fix Pred[Matrix]MapPath::empty()
-          #371: Bug fix in (di)graphCopy()
-                The target graph is cleared before adding nodes and arcs/edges.
-          #364: Add missing UndirectedTags
-          #368: Fix the usage of std::numeric_limits<>::min() in Network Simplex
-          #372: Fix a critical bug in preflow
-          #461: Bugfix in assert.h
-          #470: Fix compilation issues related to various gcc versions
-          #446: Fix #define indicating CPLEX availability
-          #294: Add explicit namespace to
-                ignore_unused_variable_warning() usages
-          #420: Bugfix in IterableValueMap
-          #439: Bugfix in biNodeConnected()
-
-
 2010-03-19 Version 1.2 released
 
Index: cmake/FindILOG.cmake
===================================================================
--- cmake/FindILOG.cmake	(revision 1331)
+++ cmake/FindILOG.cmake	(revision 1232)
@@ -63,6 +63,4 @@
   ${ILOG_CPLEX_ROOT_DIR}/lib/x86_debian4.0_4.1/static_pic
   ${ILOG_CPLEX_ROOT_DIR}/lib/x86-64_debian4.0_4.1/static_pic
-  ${ILOG_CPLEX_ROOT_DIR}/lib/x86_linux/static_pic
-  ${ILOG_CPLEX_ROOT_DIR}/lib/x86-64_linux/static_pic
   ${ILOG_CPLEX_ROOT_DIR}/lib/${ILOG_WIN_COMPILER}/stat_mda
   NO_DEFAULT_PATH
@@ -75,6 +73,4 @@
   ${ILOG_CONCERT_ROOT_DIR}/lib/x86_debian4.0_4.1/static_pic
   ${ILOG_CONCERT_ROOT_DIR}/lib/x86-64_debian4.0_4.1/static_pic
-  ${ILOG_CONCERT_ROOT_DIR}/lib/x86_linux/static_pic
-  ${ILOG_CONCERT_ROOT_DIR}/lib/x86-64_linux/static_pic
   ${ILOG_CONCERT_ROOT_DIR}/lib/${ILOG_WIN_COMPILER}/stat_mda
   NO_DEFAULT_PATH
Index: doc/Doxyfile.in
===================================================================
--- doc/Doxyfile.in	(revision 1354)
+++ doc/Doxyfile.in	(revision 1251)
@@ -20,5 +20,5 @@
 STRIP_FROM_PATH        = "@abs_top_srcdir@"
 STRIP_FROM_INC_PATH    = "@abs_top_srcdir@"
-SHORT_NAMES            = NO
+SHORT_NAMES            = YES
 JAVADOC_AUTOBRIEF      = NO
 QT_AUTOBRIEF           = NO
@@ -40,4 +40,5 @@
 SUBGROUPING            = YES
 TYPEDEF_HIDES_STRUCT   = NO
+SYMBOL_CACHE_SIZE      = 0
 #---------------------------------------------------------------------------
 # Build related configuration options
@@ -72,4 +73,5 @@
 MAX_INITIALIZER_LINES  = 5
 SHOW_USED_FILES        = NO
+SHOW_DIRECTORIES       = YES
 SHOW_FILES             = YES
 SHOW_NAMESPACES        = YES
@@ -149,4 +151,5 @@
 HTML_COLORSTYLE_GAMMA  = 80
 HTML_TIMESTAMP         = YES
+HTML_ALIGN_MEMBERS     = YES
 HTML_DYNAMIC_SECTIONS  = YES
 GENERATE_DOCSET        = NO
@@ -175,4 +178,5 @@
 ENUM_VALUES_PER_LINE   = 4
 GENERATE_TREEVIEW      = NO
+USE_INLINE_TREES       = NO
 TREEVIEW_WIDTH         = 250
 EXT_LINKS_IN_WINDOW    = NO
@@ -221,4 +225,6 @@
 GENERATE_XML           = NO
 XML_OUTPUT             = xml
+XML_SCHEMA             = 
+XML_DTD                = 
 XML_PROGRAMLISTING     = YES
 #---------------------------------------------------------------------------
@@ -261,5 +267,5 @@
 HAVE_DOT               = YES
 DOT_NUM_THREADS        = 0
-DOT_FONTNAME           = 
+DOT_FONTNAME           = FreeSans
 DOT_FONTSIZE           = 10
 DOT_FONTPATH           = 
Index: doc/groups.dox
===================================================================
--- doc/groups.dox	(revision 1366)
+++ doc/groups.dox	(revision 1270)
@@ -423,6 +423,5 @@
 However, other algorithms could be faster in special cases.
 For example, if the total supply and/or capacities are rather small,
-\ref CapacityScaling is usually the fastest algorithm
-(without effective scaling).
+\ref CapacityScaling is usually the fastest algorithm (without effective scaling).
 
 These classes are intended to be used with integer-valued input data
@@ -562,33 +561,4 @@
 
 /**
-@defgroup graph_isomorphism Graph Isomorphism
-@ingroup algs
-\brief Algorithms for testing (sub)graph isomorphism
-
-This group contains algorithms for finding isomorph copies of a
-given graph in another one, or simply check whether two graphs are isomorphic.
-
-The formal definition of subgraph isomorphism is as follows.
-
-We are given two graphs, \f$G_1=(V_1,E_1)\f$ and \f$G_2=(V_2,E_2)\f$. A
-function \f$f:V_1\longrightarrow V_2\f$ is called \e mapping or \e
-embedding if \f$f(u)\neq f(v)\f$ whenever \f$u\neq v\f$.
-
-The standard <em>Subgraph Isomorphism Problem (SIP)</em> looks for a
-mapping with the property that whenever \f$(u,v)\in E_1\f$, then
-\f$(f(u),f(v))\in E_2\f$.
-
-In case of <em>Induced Subgraph Isomorphism Problem (ISIP)</em> one
-also requires that if \f$(u,v)\not\in E_1\f$, then \f$(f(u),f(v))\not\in
-E_2\f$
-
-In addition, the graph nodes may be \e labeled, i.e. we are given two
-node labelings \f$l_1:V_1\longrightarrow L\f$ and \f$l_2:V_2\longrightarrow
-L\f$ and we require that \f$l_1(u)=l_2(f(u))\f$ holds for all nodes \f$u \in
-G_1\f$.
-
-*/
-
-/**
 @defgroup planar Planar Embedding and Drawing
 @ingroup algs
Index: doc/named-param.dox
===================================================================
--- doc/named-param.dox	(revision 1351)
+++ doc/named-param.dox	(revision 463)
@@ -26,5 +26,5 @@
 function parameters by name also when you call the function. It is
 especially comfortable in case of a function having tons of parameters
-with natural default values. Sadly, C++ lacks this amenity.
+with natural default values. Sadly, C++ lack this amenity.
 
 However, with a crafty trick and with some little
Index: doc/references.bib
===================================================================
--- doc/references.bib	(revision 1367)
+++ doc/references.bib	(revision 1219)
@@ -355,15 +355,2 @@
   pages =        {587--612}
 }
-
-@article{cordella2004sub,
-  author =       {Cordella, Luigi P. and Foggia, Pasquale and Sansone,
-                  Carlo and Vento, Mario},
-  title =        {A (sub)graph isomorphism algorithm for matching
-                  large graphs},
-  journal =      {IEEE Transactions on Pattern Analysis and Machine
-                  Intelligence},
-  volume =       26,
-  number =       10,
-  pages =        {1367--1372},
-  year =         2004
-}
Index: lemon/CMakeLists.txt
===================================================================
--- lemon/CMakeLists.txt	(revision 1315)
+++ lemon/CMakeLists.txt	(revision 1264)
@@ -56,11 +56,6 @@
 
 ADD_LIBRARY(lemon ${LEMON_SOURCES})
-
-TARGET_LINK_LIBRARIES(lemon
-  ${GLPK_LIBRARIES} ${COIN_LIBRARIES} ${ILOG_LIBRARIES} ${SOPLEX_LIBRARIES}
-  )
-
 IF(UNIX)
-  SET_TARGET_PROPERTIES(lemon PROPERTIES OUTPUT_NAME emon VERSION ${LEMON_VERSION} SOVERSION ${LEMON_VERSION})
+  SET_TARGET_PROPERTIES(lemon PROPERTIES OUTPUT_NAME emon)
 ENDIF()
 
Index: lemon/arg_parser.h
===================================================================
--- lemon/arg_parser.h	(revision 1327)
+++ lemon/arg_parser.h	(revision 959)
@@ -27,5 +27,4 @@
 #include <sstream>
 #include <algorithm>
-#include <lemon/core.h>
 #include <lemon/assert.h>
 
Index: lemon/bellman_ford.h
===================================================================
--- lemon/bellman_ford.h	(revision 1337)
+++ lemon/bellman_ford.h	(revision 1270)
@@ -30,5 +30,4 @@
 #include <lemon/maps.h>
 #include <lemon/path.h>
-#include <lemon/bits/stl_iterators.h>
 
 #include <limits>
@@ -691,19 +690,4 @@
       int _index;
     };
-
-    /// \brief Gets the collection of the active nodes.
-    ///
-    /// This function can be used for iterating on the active nodes of the
-    /// Bellman-Ford algorithm after the last phase.
-    /// These nodes should be checked in the next phase to
-    /// find augmenting arcs outgoing from them.
-    /// It returns a wrapped ActiveIt, which looks
-    /// like an STL container (by having begin() and end())
-    /// which you can use in range-based for loops, STL algorithms, etc.
-    LemonRangeWrapper1<ActiveIt, BellmanFord>
-    activeNodes() const {
-      return LemonRangeWrapper1<ActiveIt, BellmanFord>(*this);
-    }
-
 
     /// \name Query Functions
Index: lemon/bits/edge_set_extender.h
===================================================================
--- lemon/bits/edge_set_extender.h	(revision 1337)
+++ lemon/bits/edge_set_extender.h	(revision 1270)
@@ -114,7 +114,4 @@
     };
 
-    LemonRangeWrapper1<NodeIt, Digraph> nodes() const {
-      return LemonRangeWrapper1<NodeIt, Digraph>(*this);
-    }
 
     class ArcIt : public Arc {
@@ -140,7 +137,4 @@
     };
 
-    LemonRangeWrapper1<ArcIt, Digraph> arcs() const {
-      return LemonRangeWrapper1<ArcIt, Digraph>(*this);
-    }
 
     class OutArcIt : public Arc {
@@ -167,7 +161,4 @@
     };
 
-    LemonRangeWrapper2<OutArcIt, Digraph, Node> outArcs(const Node& u) const {
-      return LemonRangeWrapper2<OutArcIt, Digraph, Node>(*this, u);
-    }
 
     class InArcIt : public Arc {
@@ -193,8 +184,4 @@
 
     };
-
-    LemonRangeWrapper2<InArcIt, Digraph, Node> inArcs(const Node& u) const {
-      return LemonRangeWrapper2<InArcIt, Digraph, Node>(*this, u);
-    }
 
     // \brief Base node of the iterator
@@ -386,7 +373,4 @@
     };
 
-    LemonRangeWrapper1<NodeIt, Graph> nodes() const {
-      return LemonRangeWrapper1<NodeIt, Graph>(*this);
-    }
 
     class ArcIt : public Arc {
@@ -412,7 +396,4 @@
     };
 
-    LemonRangeWrapper1<ArcIt, Graph> arcs() const {
-      return LemonRangeWrapper1<ArcIt, Graph>(*this);
-    }
 
     class OutArcIt : public Arc {
@@ -439,7 +420,4 @@
     };
 
-    LemonRangeWrapper2<OutArcIt, Graph, Node> outArcs(const Node& u) const {
-      return LemonRangeWrapper2<OutArcIt, Graph, Node>(*this, u);
-    }
 
     class InArcIt : public Arc {
@@ -466,7 +444,4 @@
     };
 
-    LemonRangeWrapper2<InArcIt, Graph, Node> inArcs(const Node& u) const {
-      return LemonRangeWrapper2<InArcIt, Graph, Node>(*this, u);
-    }
 
     class EdgeIt : public Parent::Edge {
@@ -491,8 +466,4 @@
 
     };
-
-    LemonRangeWrapper1<EdgeIt, Graph> edges() const {
-      return LemonRangeWrapper1<EdgeIt, Graph>(*this);
-    }
 
     class IncEdgeIt : public Parent::Edge {
@@ -520,8 +491,4 @@
       }
     };
-
-    LemonRangeWrapper2<IncEdgeIt, Graph, Node> incEdges(const Node& u) const {
-      return LemonRangeWrapper2<IncEdgeIt, Graph, Node>(*this, u);
-    }
 
     // \brief Base node of the iterator
Index: lemon/bits/graph_adaptor_extender.h
===================================================================
--- lemon/bits/graph_adaptor_extender.h	(revision 1337)
+++ lemon/bits/graph_adaptor_extender.h	(revision 1270)
@@ -86,7 +86,4 @@
     };
 
-    LemonRangeWrapper1<NodeIt, Adaptor> nodes() const {
-      return LemonRangeWrapper1<NodeIt, Adaptor>(*this);
-    }
 
     class ArcIt : public Arc {
@@ -111,8 +108,4 @@
 
     };
-
-    LemonRangeWrapper1<ArcIt, Adaptor> arcs() const {
-      return LemonRangeWrapper1<ArcIt, Adaptor>(*this);
-    }
 
 
@@ -140,8 +133,4 @@
     };
 
-    LemonRangeWrapper2<OutArcIt, Adaptor, Node> outArcs(const Node& u) const {
-      return LemonRangeWrapper2<OutArcIt, Adaptor, Node>(*this, u);
-    }
-
 
     class InArcIt : public Arc {
@@ -167,8 +156,4 @@
 
     };
-
-    LemonRangeWrapper2<InArcIt, Adaptor, Node> inArcs(const Node& u) const {
-      return LemonRangeWrapper2<InArcIt, Adaptor, Node>(*this, u);
-    }
 
     Node baseNode(const OutArcIt &e) const {
@@ -270,8 +255,4 @@
     };
 
-    LemonRangeWrapper1<NodeIt, Adaptor> nodes() const {
-      return LemonRangeWrapper1<NodeIt, Adaptor>(*this);
-    }
-
 
     class ArcIt : public Arc {
@@ -296,8 +277,4 @@
 
     };
-
-    LemonRangeWrapper1<ArcIt, Adaptor> arcs() const {
-      return LemonRangeWrapper1<ArcIt, Adaptor>(*this);
-    }
 
 
@@ -325,8 +302,4 @@
     };
 
-    LemonRangeWrapper2<OutArcIt, Adaptor, Node> outArcs(const Node& u) const {
-      return LemonRangeWrapper2<OutArcIt, Adaptor, Node>(*this, u);
-    }
-
 
     class InArcIt : public Arc {
@@ -353,8 +326,4 @@
     };
 
-    LemonRangeWrapper2<InArcIt, Adaptor, Node> inArcs(const Node& u) const {
-      return LemonRangeWrapper2<InArcIt, Adaptor, Node>(*this, u);
-    }
-
     class EdgeIt : public Parent::Edge {
       const Adaptor* _adaptor;
@@ -378,9 +347,4 @@
 
     };
-
-    LemonRangeWrapper1<EdgeIt, Adaptor> edges() const {
-      return LemonRangeWrapper1<EdgeIt, Adaptor>(*this);
-    }
-
 
     class IncEdgeIt : public Edge {
@@ -409,9 +373,4 @@
     };
 
-    LemonRangeWrapper2<IncEdgeIt, Adaptor, Node> incEdges(const Node& u) const {
-      return LemonRangeWrapper2<IncEdgeIt, Adaptor, Node>(*this, u);
-    }
-
-
     Node baseNode(const OutArcIt &a) const {
       return Parent::source(a);
Index: lemon/bits/graph_extender.h
===================================================================
--- lemon/bits/graph_extender.h	(revision 1336)
+++ lemon/bits/graph_extender.h	(revision 1270)
@@ -28,6 +28,4 @@
 #include <lemon/concepts/maps.h>
 
-#include <lemon/bits/stl_iterators.h>
-
 //\ingroup graphbits
 //\file
@@ -119,8 +117,4 @@
     };
 
-    LemonRangeWrapper1<NodeIt, Digraph> nodes() const {
-      return LemonRangeWrapper1<NodeIt, Digraph>(*this);
-    }
-
 
     class ArcIt : public Arc {
@@ -145,8 +139,4 @@
 
     };
-
-    LemonRangeWrapper1<ArcIt, Digraph> arcs() const {
-      return LemonRangeWrapper1<ArcIt, Digraph>(*this);
-    }
 
 
@@ -174,8 +164,4 @@
     };
 
-    LemonRangeWrapper2<OutArcIt, Digraph, Node> outArcs(const Node& u) const {
-      return LemonRangeWrapper2<OutArcIt, Digraph, Node>(*this, u);
-    }
-
 
     class InArcIt : public Arc {
@@ -201,8 +187,4 @@
 
     };
-
-    LemonRangeWrapper2<InArcIt, Digraph, Node> inArcs(const Node& u) const {
-      return LemonRangeWrapper2<InArcIt, Digraph, Node>(*this, u);
-    }
 
     // \brief Base node of the iterator
@@ -455,8 +437,4 @@
     };
 
-    LemonRangeWrapper1<NodeIt, Graph> nodes() const {
-      return LemonRangeWrapper1<NodeIt, Graph>(*this);
-    }
-
 
     class ArcIt : public Arc {
@@ -481,8 +459,4 @@
 
     };
-
-    LemonRangeWrapper1<ArcIt, Graph> arcs() const {
-      return LemonRangeWrapper1<ArcIt, Graph>(*this);
-    }
 
 
@@ -510,8 +484,4 @@
     };
 
-    LemonRangeWrapper2<OutArcIt, Graph, Node> outArcs(const Node& u) const {
-      return LemonRangeWrapper2<OutArcIt, Graph, Node>(*this, u);
-    }
-
 
     class InArcIt : public Arc {
@@ -538,8 +508,4 @@
     };
 
-    LemonRangeWrapper2<InArcIt, Graph, Node> inArcs(const Node& u) const {
-      return LemonRangeWrapper2<InArcIt, Graph, Node>(*this, u);
-    }
-
 
     class EdgeIt : public Parent::Edge {
@@ -564,9 +530,4 @@
 
     };
-
-    LemonRangeWrapper1<EdgeIt, Graph> edges() const {
-      return LemonRangeWrapper1<EdgeIt, Graph>(*this);
-    }
-
 
     class IncEdgeIt : public Parent::Edge {
@@ -594,9 +555,4 @@
       }
     };
-
-    LemonRangeWrapper2<IncEdgeIt, Graph, Node> incEdges(const Node& u) const {
-      return LemonRangeWrapper2<IncEdgeIt, Graph, Node>(*this, u);
-    }
-
 
     // \brief Base node of the iterator
@@ -948,9 +904,4 @@
     };
 
-    LemonRangeWrapper1<NodeIt, BpGraph> nodes() const {
-      return LemonRangeWrapper1<NodeIt, BpGraph>(*this);
-    }
-
-
     class RedNodeIt : public RedNode {
       const BpGraph* _graph;
@@ -975,9 +926,4 @@
     };
 
-    LemonRangeWrapper1<RedNodeIt, BpGraph> redNodes() const {
-      return LemonRangeWrapper1<RedNodeIt, BpGraph>(*this);
-    }
-
-
     class BlueNodeIt : public BlueNode {
       const BpGraph* _graph;
@@ -1002,9 +948,4 @@
     };
 
-    LemonRangeWrapper1<BlueNodeIt, BpGraph> blueNodes() const {
-      return LemonRangeWrapper1<BlueNodeIt, BpGraph>(*this);
-    }
-
-
 
     class ArcIt : public Arc {
@@ -1029,8 +970,4 @@
 
     };
-
-    LemonRangeWrapper1<ArcIt, BpGraph> arcs() const {
-      return LemonRangeWrapper1<ArcIt, BpGraph>(*this);
-    }
 
 
@@ -1058,8 +995,4 @@
     };
 
-    LemonRangeWrapper2<OutArcIt, BpGraph, Node> outArcs(const Node& u) const {
-      return LemonRangeWrapper2<OutArcIt, BpGraph, Node>(*this, u);
-    }
-
 
     class InArcIt : public Arc {
@@ -1086,8 +1019,4 @@
     };
 
-    LemonRangeWrapper2<InArcIt, BpGraph, Node> inArcs(const Node& u) const {
-      return LemonRangeWrapper2<InArcIt, BpGraph, Node>(*this, u);
-    }
-
 
     class EdgeIt : public Parent::Edge {
@@ -1112,9 +1041,4 @@
 
     };
-
-    LemonRangeWrapper1<EdgeIt, BpGraph> edges() const {
-      return LemonRangeWrapper1<EdgeIt, BpGraph>(*this);
-    }
-
 
     class IncEdgeIt : public Parent::Edge {
@@ -1142,9 +1066,4 @@
       }
     };
-
-    LemonRangeWrapper2<IncEdgeIt, BpGraph, Node> incEdges(const Node& u) const {
-      return LemonRangeWrapper2<IncEdgeIt, BpGraph, Node>(*this, u);
-    }
-
 
     // \brief Base node of the iterator
Index: lemon/bits/path_dump.h
===================================================================
--- lemon/bits/path_dump.h	(revision 1338)
+++ lemon/bits/path_dump.h	(revision 1270)
@@ -62,5 +62,5 @@
       }
 
-      operator typename Digraph::Arc() const {
+      operator const typename Digraph::Arc() const {
         return path->predMap[current];
       }
Index: mon/bits/stl_iterators.h
===================================================================
--- lemon/bits/stl_iterators.h	(revision 1339)
+++ 	(revision )
@@ -1,99 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- */
-
-#ifndef STL_ITERATORS_H_
-#define STL_ITERATORS_H_
-
-#include <lemon/core.h>
-
-namespace lemon {
-
-  /// \brief Template to make STL iterators from Lemon iterators.
-  ///
-  /// This template makes an STL iterator from a Lemon iterator
-  /// by adding the missing features.
-  /// It inherits from \c std::iterator to make \c iterator_concept work
-  /// (so that STL algorithms work).
-  /// \c T should be the lemon iterator to be decorated.
-  template<class T>
-  struct LemonItWrapper
-      : public T, public std::iterator<std::input_iterator_tag, T> {
-
-    LemonItWrapper(const T &x) : T(x) {}
-
-    //Lemon iterators don't have operator*, (because they rather
-    //inherit from their "value_type"),
-    //so we add one that just returns the object.
-    const T& operator*() const {
-      return static_cast<const T&>(*this);
-    }
-
-    //I can't think of any use case for this with Lemon iterators,
-    //but maybe it should be included for completeness.
-    const T* operator->() {
-      return static_cast<const T*>(this);
-    }
-
-    //Lemon iterators don't have postincrement.
-    void operator++(int) {
-      T::operator++();
-    }
-
-    using T::operator++;
-
-  };
-
-
-  /// \brief A generic wrapper for Lemon iterators for range-based for loops.
-  ///
-  /// This template can be used to create a class
-  /// that has begin() and end() from a Lemon iterator
-  /// (with a 1-parameter constructor)
-  /// to make range-based for loops and STL algorithms work.
-  ///
-  /// \c LIT is the Lemon iterator that will be wrapped
-  /// \c P is the type of the parameter of the constructor of \c LIT.
-  template<class LIT, class P>
-  class LemonRangeWrapper1 {
-    typedef LemonItWrapper<LIT> It;
-    It _begin;
-    
-  public:
-    LemonRangeWrapper1(const P &p) : _begin(LIT(p)) {}
-    It begin() const {
-      return _begin;
-    }
-    It end() const {
-      return It(lemon::INVALID);
-    }
-  };
-
-
-  /// \brief A generic wrapper for Lemon iterators for range-based for loops.
-  ///
-  /// This template can be used to create a class
-  /// that has begin() and end() from a Lemon iterator
-  /// (with a 2-parameter constructor)
-  /// to make range-based for loops and STL algorithms work.
-  ///
-  /// \c LIT is the Lemon iterator that will be wrapped
-  /// \c P1 and \c P2 are the types of the parameters
-  /// of the constructor of \c LIT.
-  template<class LIT, class P1, class P2>
-  class LemonRangeWrapper2 {
-    typedef LemonItWrapper<LIT> It; 
-    It _begin;
- public:
-    LemonRangeWrapper2(const P1 &p1, const P2 &p2) : _begin(LIT(p1, p2)) {}
-    It begin() const {
-      return _begin;
-    }
-    It end() const {
-      return It(lemon::INVALID);
-    }
-  };
-
-
-}
-
-#endif /* STL_ITERATORS_H_ */
Index: lemon/bits/windows.cc
===================================================================
--- lemon/bits/windows.cc	(revision 1341)
+++ lemon/bits/windows.cc	(revision 1270)
@@ -22,9 +22,5 @@
 #include<lemon/bits/windows.h>
 
-#if defined(LEMON_WIN32) && defined(__GNUC__)
-#pragma GCC diagnostic ignored "-Wold-style-cast"
-#endif
-
-#ifdef LEMON_WIN32
+#ifdef WIN32
 #ifndef WIN32_LEAN_AND_MEAN
 #define WIN32_LEAN_AND_MEAN
@@ -45,5 +41,5 @@
 #include <unistd.h>
 #include <ctime>
-#ifndef LEMON_WIN32
+#ifndef WIN32
 #include <sys/times.h>
 #endif
@@ -60,5 +56,5 @@
                          double &cutime, double &cstime)
     {
-#ifdef LEMON_WIN32
+#ifdef WIN32
       static const double ch = 4294967296.0e-7;
       static const double cl = 1.0e-7;
@@ -99,9 +95,9 @@
     {
       std::ostringstream os;
-#ifdef LEMON_WIN32
+#ifdef WIN32
       SYSTEMTIME time;
       GetSystemTime(&time);
       char buf1[11], buf2[9], buf3[5];
-      if (GetDateFormat(MY_LOCALE, 0, &time,
+          if (GetDateFormat(MY_LOCALE, 0, &time,
                         ("ddd MMM dd"), buf1, 11) &&
           GetTimeFormat(MY_LOCALE, 0, &time,
@@ -125,5 +121,5 @@
     int getWinRndSeed()
     {
-#ifdef LEMON_WIN32
+#ifdef WIN32
       FILETIME time;
       GetSystemTimeAsFileTime(&time);
@@ -137,5 +133,5 @@
 
     WinLock::WinLock() {
-#ifdef LEMON_WIN32
+#ifdef WIN32
       CRITICAL_SECTION *lock = new CRITICAL_SECTION;
       InitializeCriticalSection(lock);
@@ -147,5 +143,5 @@
 
     WinLock::~WinLock() {
-#ifdef LEMON_WIN32
+#ifdef WIN32
       CRITICAL_SECTION *lock = static_cast<CRITICAL_SECTION*>(_repr);
       DeleteCriticalSection(lock);
@@ -155,5 +151,5 @@
 
     void WinLock::lock() {
-#ifdef LEMON_WIN32
+#ifdef WIN32
       CRITICAL_SECTION *lock = static_cast<CRITICAL_SECTION*>(_repr);
       EnterCriticalSection(lock);
@@ -162,5 +158,5 @@
 
     void WinLock::unlock() {
-#ifdef LEMON_WIN32
+#ifdef WIN32
       CRITICAL_SECTION *lock = static_cast<CRITICAL_SECTION*>(_repr);
       LeaveCriticalSection(lock);
Index: lemon/bits/windows.h
===================================================================
--- lemon/bits/windows.h	(revision 1340)
+++ lemon/bits/windows.h	(revision 1270)
@@ -20,5 +20,4 @@
 #define LEMON_BITS_WINDOWS_H
 
-#include <lemon/config.h>
 #include <string>
 
@@ -36,5 +35,5 @@
       ~WinLock();
       void lock();
-      void unlock();\
+      void unlock();
     private:
       void *_repr;
Index: lemon/capacity_scaling.h
===================================================================
--- lemon/capacity_scaling.h	(revision 1363)
+++ lemon/capacity_scaling.h	(revision 1270)
@@ -28,5 +28,4 @@
 #include <limits>
 #include <lemon/core.h>
-#include <lemon/maps.h>
 #include <lemon/bin_heap.h>
 
@@ -165,5 +164,5 @@
 
     // Parameters of the problem
-    bool _has_lower;
+    bool _have_lower;
     Value _sum_supply;
 
@@ -358,7 +357,8 @@
     template <typename LowerMap>
     CapacityScaling& lowerMap(const LowerMap& map) {
-      _has_lower = true;
+      _have_lower = true;
       for (ArcIt a(_graph); a != INVALID; ++a) {
         _lower[_arc_idf[a]] = map[a];
+        _lower[_arc_idb[a]] = map[a];
       }
       return *this;
@@ -544,5 +544,5 @@
         _cost[j] = _forward[j] ? 1 : -1;
       }
-      _has_lower = false;
+      _have_lower = false;
       return *this;
     }
@@ -755,5 +755,5 @@
       const Value MAX = std::numeric_limits<Value>::max();
       int last_out;
-      if (_has_lower) {
+      if (_have_lower) {
         for (int i = 0; i != _root; ++i) {
           last_out = _first_out[i+1];
@@ -840,9 +840,9 @@
     }
 
-    // Check if the upper bound is greater than or equal to the lower bound
-    // on each forward arc.
+    // Check if the upper bound is greater or equal to the lower bound
+    // on each arc.
     bool checkBoundMaps() {
       for (int j = 0; j != _res_arc_num; ++j) {
-        if (_forward[j] && _upper[j] < _lower[j]) return false;
+        if (_upper[j] < _lower[j]) return false;
       }
       return true;
@@ -858,8 +858,8 @@
 
       // Handle non-zero lower bounds
-      if (_has_lower) {
+      if (_have_lower) {
         int limit = _first_out[_root];
         for (int j = 0; j != limit; ++j) {
-          if (_forward[j]) _res_cap[_reverse[j]] += _lower[j];
+          if (!_forward[j]) _res_cap[j] += _lower[j];
         }
       }
Index: lemon/cbc.cc
===================================================================
--- lemon/cbc.cc	(revision 1336)
+++ lemon/cbc.cc	(revision 1270)
@@ -112,9 +112,9 @@
 
   void CbcMip::_eraseColId(int i) {
-    _cols.eraseIndex(i);
+    cols.eraseIndex(i);
   }
 
   void CbcMip::_eraseRowId(int i) {
-    _rows.eraseIndex(i);
+    rows.eraseIndex(i);
   }
 
Index: lemon/clp.cc
===================================================================
--- lemon/clp.cc	(revision 1336)
+++ lemon/clp.cc	(revision 1270)
@@ -30,6 +30,6 @@
   ClpLp::ClpLp(const ClpLp& other) {
     _prob = new ClpSimplex(*other._prob);
-    _rows = other._rows;
-    _cols = other._cols;
+    rows = other.rows;
+    cols = other.cols;
     _init_temporals();
     messageLevel(MESSAGE_NOTHING);
@@ -104,11 +104,11 @@
 
   void ClpLp::_eraseColId(int i) {
-    _cols.eraseIndex(i);
-    _cols.shiftIndices(i);
+    cols.eraseIndex(i);
+    cols.shiftIndices(i);
   }
 
   void ClpLp::_eraseRowId(int i) {
-    _rows.eraseIndex(i);
-    _rows.shiftIndices(i);
+    rows.eraseIndex(i);
+    rows.shiftIndices(i);
   }
 
Index: lemon/clp.h
===================================================================
--- lemon/clp.h	(revision 1336)
+++ lemon/clp.h	(revision 1270)
@@ -152,8 +152,8 @@
 
     ///Returns the constraint identifier understood by CLP.
-    int clpRow(Row r) const { return _rows(id(r)); }
+    int clpRow(Row r) const { return rows(id(r)); }
 
     ///Returns the variable identifier understood by CLP.
-    int clpCol(Col c) const { return _cols(id(c)); }
+    int clpCol(Col c) const { return cols(id(c)); }
 
   };
Index: lemon/concepts/bpgraph.h
===================================================================
--- lemon/concepts/bpgraph.h	(revision 1336)
+++ lemon/concepts/bpgraph.h	(revision 1270)
@@ -28,5 +28,4 @@
 #include <lemon/concept_check.h>
 #include <lemon/core.h>
-#include <lemon/bits/stl_iterators.h>
 
 namespace lemon {
@@ -223,20 +222,4 @@
       };
 
-      /// \brief Gets the collection of the red nodes of the graph.
-      ///
-      /// This function can be used for iterating on
-      /// the red nodes of the graph. It returns a wrapped RedNodeIt,
-      /// which looks like an STL container (by having begin() and end())
-      /// which you can use in range-based for loops, stl algorithms, etc.
-      /// For example if g is a BpGraph, you can write:
-      ///\code
-      /// for(auto v: g.redNodes())
-      ///   doSomething(v);
-      ///\endcode
-      LemonRangeWrapper1<RedNodeIt, BpGraph> redNodes() const {
-        return LemonRangeWrapper1<RedNodeIt, BpGraph>(*this);
-      }
-
-
       /// Iterator class for the blue nodes.
 
@@ -282,20 +265,4 @@
       };
 
-      /// \brief Gets the collection of the blue nodes of the graph.
-      ///
-      /// This function can be used for iterating on
-      /// the blue nodes of the graph. It returns a wrapped BlueNodeIt,
-      /// which looks like an STL container (by having begin() and end())
-      /// which you can use in range-based for loops, stl algorithms, etc.
-      /// For example if g is a BpGraph, you can write:
-      ///\code
-      /// for(auto v: g.blueNodes())
-      ///   doSomething(v);
-      ///\endcode
-      LemonRangeWrapper1<BlueNodeIt, BpGraph> blueNodes() const {
-        return LemonRangeWrapper1<BlueNodeIt, BpGraph>(*this);
-      }
-
-
       /// Iterator class for the nodes.
 
@@ -341,20 +308,4 @@
       };
 
-      /// \brief Gets the collection of the nodes of the graph.
-      ///
-      /// This function can be used for iterating on
-      /// the nodes of the graph. It returns a wrapped NodeIt,
-      /// which looks like an STL container (by having begin() and end())
-      /// which you can use in range-based for loops, stl algorithms, etc.
-      /// For example if g is a BpGraph, you can write:
-      ///\code
-      /// for(auto v: g.nodes())
-      ///   doSomething(v);
-      ///\endcode
-      LemonRangeWrapper1<NodeIt, BpGraph> nodes() const {
-        return LemonRangeWrapper1<NodeIt, BpGraph>(*this);
-      }
-
-
 
       /// The edge type of the graph
@@ -445,21 +396,4 @@
       };
 
-      /// \brief Gets the collection of the edges of the graph.
-      ///
-      /// This function can be used for iterating on the
-      /// edges of the graph. It returns a wrapped
-      /// EdgeIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, stl algorithms, etc.
-      /// For example if g is a BpGraph, you can write:
-      ///\code
-      /// for(auto e: g.edges())
-      ///   doSomething(e);
-      ///\endcode
-      LemonRangeWrapper1<EdgeIt, BpGraph> edges() const {
-        return LemonRangeWrapper1<EdgeIt, BpGraph>(*this);
-      }
-
-
       /// Iterator class for the incident edges of a node.
 
@@ -509,23 +443,4 @@
         IncEdgeIt& operator++() { return *this; }
       };
-
-      /// \brief Gets the collection of the incident edges
-      ///  of a certain node of the graph.
-      ///
-      /// This function can be used for iterating on the
-      /// incident undirected edges of a certain node of the graph.
-      /// It returns a wrapped
-      /// IncEdgeIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, stl algorithms, etc.
-      /// For example if g is a BpGraph and u is a Node, you can write:
-      ///\code
-      /// for(auto e: g.incEdges(u))
-      ///   doSomething(e);
-      ///\endcode
-      LemonRangeWrapper2<IncEdgeIt, BpGraph, Node> incEdges(const Node& u) const {
-        return LemonRangeWrapper2<IncEdgeIt, BpGraph, Node>(*this, u);
-      }
-
 
       /// The arc type of the graph
@@ -624,21 +539,4 @@
         ArcIt& operator++() { return *this; }
       };
-
-      /// \brief Gets the collection of the directed arcs of the graph.
-      ///
-      /// This function can be used for iterating on the
-      /// arcs of the graph. It returns a wrapped
-      /// ArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, stl algorithms, etc.
-      /// For example if g is a BpGraph you can write:
-      ///\code
-      /// for(auto a: g.arcs())
-      ///   doSomething(a);
-      ///\endcode
-      LemonRangeWrapper1<ArcIt, BpGraph> arcs() const {
-        return LemonRangeWrapper1<ArcIt, BpGraph>(*this);
-      }
-
 
       /// Iterator class for the outgoing arcs of a node.
@@ -690,22 +588,4 @@
       };
 
-      /// \brief Gets the collection of the outgoing directed arcs of a
-      /// certain node of the graph.
-      ///
-      /// This function can be used for iterating on the
-      /// outgoing arcs of a certain node of the graph. It returns a wrapped
-      /// OutArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, stl algorithms, etc.
-      /// For example if g is a BpGraph and u is a Node, you can write:
-      ///\code
-      /// for(auto a: g.outArcs(u))
-      ///   doSomething(a);
-      ///\endcode
-      LemonRangeWrapper2<OutArcIt, BpGraph, Node> outArcs(const Node& u) const {
-        return LemonRangeWrapper2<OutArcIt, BpGraph, Node>(*this, u);
-      }
-
-
       /// Iterator class for the incoming arcs of a node.
 
@@ -756,22 +636,4 @@
       };
 
-      /// \brief Gets the collection of the incoming directed arcs of a
-      /// certain node of the graph.
-      ///
-      /// This function can be used for iterating on the
-      /// incoming arcs of a certain node of the graph. It returns a wrapped
-      /// InArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, stl algorithms, etc.
-      /// For example if g is a BpGraph and u is a Node, you can write:
-      ///\code
-      /// for(auto a: g.inArcs(u))
-      ///   doSomething(a);
-      ///\endcode
-      LemonRangeWrapper2<InArcIt, BpGraph, Node> inArcs(const Node& u) const {
-        return LemonRangeWrapper2<InArcIt, BpGraph, Node>(*this, u);
-      }
-
-
       /// \brief Standard graph map type for the nodes.
       ///
Index: lemon/concepts/digraph.h
===================================================================
--- lemon/concepts/digraph.h	(revision 1336)
+++ lemon/concepts/digraph.h	(revision 1270)
@@ -28,5 +28,4 @@
 #include <lemon/concept_check.h>
 #include <lemon/concepts/graph_components.h>
-#include <lemon/bits/stl_iterators.h>
 
 namespace lemon {
@@ -149,23 +148,4 @@
       };
 
-      /// \brief Gets the collection of the nodes of the digraph.
-      ///
-      /// This function can be used for iterating on
-      /// the nodes of the digraph. It returns a wrapped NodeIt, which looks
-      /// like an STL container (by having begin() and end())
-      /// which you can use in range-based for loops, STL algorithms, etc.
-      /// For example you can write:
-      ///\code
-      /// ListDigraph g;
-      /// for(auto v: g.nodes())
-      ///   doSomething(v);
-      ///
-      /// //Using an STL algorithm:
-      /// copy(g.nodes().begin(), g.nodes().end(), vect.begin());
-      ///\endcode
-      LemonRangeWrapper1<NodeIt, Digraph> nodes() const {
-        return LemonRangeWrapper1<NodeIt, Digraph>(*this);
-      }
-
 
       /// The arc type of the digraph
@@ -258,25 +238,4 @@
       };
 
-      /// \brief Gets the collection of the outgoing arcs of a certain node
-      /// of the digraph.
-      ///
-      /// This function can be used for iterating on the
-      /// outgoing arcs of a certain node of the digraph. It returns a wrapped
-      /// OutArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, STL algorithms, etc.
-      /// For example if g is a Digraph and u is a node, you can write:
-      ///\code
-      /// for(auto a: g.outArcs(u))
-      ///   doSomething(a);
-      ///
-      /// //Using an STL algorithm:
-      /// copy(g.outArcs(u).begin(), g.outArcs(u).end(), vect.begin());
-      ///\endcode
-      LemonRangeWrapper2<OutArcIt, Digraph, Node> outArcs(const Node& u) const {
-        return LemonRangeWrapper2<OutArcIt, Digraph, Node>(*this, u);
-      }
-
-
       /// Iterator class for the incoming arcs of a node.
 
@@ -324,25 +283,4 @@
       };
 
-      /// \brief Gets the collection of the incoming arcs of a certain node
-      /// of the digraph.
-      ///
-      /// This function can be used for iterating on the
-      /// incoming arcs of a certain node of the digraph. It returns a wrapped
-      /// InArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, STL algorithms, etc.
-      /// For example if g is a Digraph and u is a node, you can write:
-      ///\code
-      /// for(auto a: g.inArcs(u))
-      ///   doSomething(a);
-      ///
-      /// //Using an STL algorithm:
-      /// copy(g.inArcs(u).begin(), g.inArcs(u).end(), vect.begin());
-      ///\endcode
-      LemonRangeWrapper2<InArcIt, Digraph, Node> inArcs(const Node& u) const {
-        return LemonRangeWrapper2<InArcIt, Digraph, Node>(*this, u);
-      }
-
-
       /// Iterator class for the arcs.
 
@@ -375,7 +313,5 @@
         /// Sets the iterator to the first arc of the given digraph.
         ///
-        explicit ArcIt(const Digraph& g) {
-          ::lemon::ignore_unused_variable_warning(g);
-        }
+        explicit ArcIt(const Digraph& g) { ::lemon::ignore_unused_variable_warning(g); }
         /// Sets the iterator to the given arc.
 
@@ -389,25 +325,4 @@
         ArcIt& operator++() { return *this; }
       };
-
-      /// \brief Gets the collection of the arcs of the digraph.
-      ///
-      /// This function can be used for iterating on the
-      /// arcs of the digraph. It returns a wrapped
-      /// ArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, STL algorithms, etc.
-      /// For example you can write:
-      ///\code
-      /// ListDigraph g;
-      /// for(auto a: g.arcs())
-      ///   doSomething(a);
-      ///
-      /// //Using an STL algorithm:
-      /// copy(g.arcs().begin(), g.arcs().end(), vect.begin());
-      ///\endcode
-      LemonRangeWrapper1<ArcIt, Digraph> arcs() const {
-        return LemonRangeWrapper1<ArcIt, Digraph>(*this);
-      }
-
 
       /// \brief The source node of the arc.
Index: lemon/concepts/graph.h
===================================================================
--- lemon/concepts/graph.h	(revision 1336)
+++ lemon/concepts/graph.h	(revision 1270)
@@ -28,5 +28,4 @@
 #include <lemon/concept_check.h>
 #include <lemon/core.h>
-#include <lemon/bits/stl_iterators.h>
 
 namespace lemon {
@@ -182,23 +181,4 @@
       };
 
-      /// \brief Gets the collection of the nodes of the graph.
-      ///
-      /// This function can be used for iterating on
-      /// the nodes of the graph. It returns a wrapped NodeIt, which looks
-      /// like an STL container (by having begin() and end())
-      /// which you can use in range-based for loops, STL algorithms, etc.
-      /// For example you can write:
-      ///\code
-      /// ListGraph g;
-      /// for(auto v: g.nodes())
-      ///   doSomething(v);
-      ///
-      /// //Using an STL algorithm:
-      /// copy(g.nodes().begin(), g.nodes().end(), vect.begin());
-      ///\endcode
-      LemonRangeWrapper1<NodeIt, Graph> nodes() const {
-        return LemonRangeWrapper1<NodeIt, Graph>(*this);
-      }
-
 
       /// The edge type of the graph
@@ -289,25 +269,4 @@
       };
 
-      /// \brief Gets the collection of the edges of the graph.
-      ///
-      /// This function can be used for iterating on the
-      /// edges of the graph. It returns a wrapped
-      /// EdgeIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, STL algorithms, etc.
-      /// For example you can write:
-      ///\code
-      /// ListGraph g;
-      /// for(auto e: g.edges())
-      ///   doSomething(e);
-      ///
-      /// //Using an STL algorithm:
-      /// copy(g.edges().begin(), g.edges().end(), vect.begin());
-      ///\endcode
-      LemonRangeWrapper1<EdgeIt, Graph> edges() const {
-        return LemonRangeWrapper1<EdgeIt, Graph>(*this);
-      }
-
-
       /// Iterator class for the incident edges of a node.
 
@@ -357,26 +316,4 @@
         IncEdgeIt& operator++() { return *this; }
       };
-
-      /// \brief Gets the collection of the incident undirected edges
-      ///  of a certain node of the graph.
-      ///
-      /// This function can be used for iterating on the
-      /// incident undirected edges of a certain node of the graph.
-      /// It returns a wrapped
-      /// IncEdgeIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, STL algorithms, etc.
-      /// For example if g is a Graph and u is a Node, you can write:
-      ///\code
-      /// for(auto e: g.incEdges(u))
-      ///   doSomething(e);
-      ///
-      /// //Using an STL algorithm:
-      /// copy(g.incEdges(u).begin(), g.incEdges(u).end(), vect.begin());
-      ///\endcode
-      LemonRangeWrapper2<IncEdgeIt, Graph, Node> incEdges(const Node& u) const {
-        return LemonRangeWrapper2<IncEdgeIt, Graph, Node>(*this, u);
-      }
-
 
       /// The arc type of the graph
@@ -460,7 +397,5 @@
         /// Sets the iterator to the first arc of the given graph.
         ///
-        explicit ArcIt(const Graph &g) {
-          ::lemon::ignore_unused_variable_warning(g);
-        }
+        explicit ArcIt(const Graph &g) { ::lemon::ignore_unused_variable_warning(g); }
         /// Sets the iterator to the given arc.
 
@@ -474,25 +409,4 @@
         ArcIt& operator++() { return *this; }
       };
-
-      /// \brief Gets the collection of the directed arcs of the graph.
-      ///
-      /// This function can be used for iterating on the
-      /// arcs of the graph. It returns a wrapped
-      /// ArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, STL algorithms, etc.
-      /// For example you can write:
-      ///\code
-      /// ListGraph g;
-      /// for(auto a: g.arcs())
-      ///   doSomething(a);
-      ///
-      /// //Using an STL algorithm:
-      /// copy(g.arcs().begin(), g.arcs().end(), vect.begin());
-      ///\endcode
-      LemonRangeWrapper1<ArcIt, Graph> arcs() const {
-        return LemonRangeWrapper1<ArcIt, Graph>(*this);
-      }
-
 
       /// Iterator class for the outgoing arcs of a node.
@@ -544,25 +458,4 @@
       };
 
-      /// \brief Gets the collection of the outgoing directed arcs of a
-      /// certain node of the graph.
-      ///
-      /// This function can be used for iterating on the
-      /// outgoing arcs of a certain node of the graph. It returns a wrapped
-      /// OutArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, STL algorithms, etc.
-      /// For example if g is a Graph and u is a Node, you can write:
-      ///\code
-      /// for(auto a: g.outArcs(u))
-      ///   doSomething(a);
-      ///
-      /// //Using an STL algorithm:
-      /// copy(g.outArcs(u).begin(), g.outArcs(u).end(), vect.begin());
-      ///\endcode
-      LemonRangeWrapper2<OutArcIt, Graph, Node> outArcs(const Node& u) const {
-        return LemonRangeWrapper2<OutArcIt, Graph, Node>(*this, u);
-      }
-
-
       /// Iterator class for the incoming arcs of a node.
 
@@ -613,24 +506,4 @@
       };
 
-      /// \brief Gets the collection of the incoming directed arcs of
-      /// a certain node of the graph.
-      ///
-      /// This function can be used for iterating on the
-      /// incoming directed arcs of a certain node of the graph. It returns
-      /// a wrapped InArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, STL algorithms, etc.
-      /// For example if g is a Graph and u is a Node, you can write:
-      ///\code
-      /// for(auto a: g.inArcs(u))
-      ///   doSomething(a);
-      ///
-      /// //Using an STL algorithm:
-      /// copy(g.inArcs(u).begin(), g.inArcs(u).end(), vect.begin());
-      ///\endcode
-      LemonRangeWrapper2<InArcIt, Graph, Node> inArcs(const Node& u) const {
-        return LemonRangeWrapper2<InArcIt, Graph, Node>(*this, u);
-      }
-
       /// \brief Standard graph map type for the nodes.
       ///
Index: lemon/concepts/path.h
===================================================================
--- lemon/concepts/path.h	(revision 1336)
+++ lemon/concepts/path.h	(revision 1270)
@@ -27,5 +27,4 @@
 #include <lemon/core.h>
 #include <lemon/concept_check.h>
-#include <lemon/bits/stl_iterators.h>
 
 namespace lemon {
@@ -117,21 +116,4 @@
       };
 
-      /// \brief Gets the collection of the arcs of the path.
-      ///
-      /// This function can be used for iterating on the
-      /// arcs of the path. It returns a wrapped
-      /// ArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, STL algorithms, etc.
-      /// For example you can write:
-      ///\code
-      /// for(auto a: p.arcs())
-      ///   doSomething(a);
-      ///\endcode
-      LemonRangeWrapper1<ArcIt, Path> arcs() const {
-        return LemonRangeWrapper1<ArcIt, Path>(*this);
-      }
-
-
       template <typename _Path>
       struct Constraints {
@@ -282,21 +264,4 @@
 
       };
-
-      /// \brief Gets the collection of the arcs of the path.
-      ///
-      /// This function can be used for iterating on the
-      /// arcs of the path. It returns a wrapped
-      /// ArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, STL algorithms, etc.
-      /// For example you can write:
-      ///\code
-      /// for(auto a: p.arcs())
-      ///   doSomething(a);
-      ///\endcode
-      LemonRangeWrapper1<ArcIt, PathDumper> arcs() const {
-        return LemonRangeWrapper1<ArcIt, PathDumper>(*this);
-      }
-
 
       /// \brief LEMON style iterator for enumerating the arcs of a path
@@ -329,22 +294,4 @@
       };
 
-      /// \brief Gets the collection of the arcs of the path
-      /// in reverse direction.
-      ///
-      /// This function can be used for iterating on the
-      /// arcs of the path in reverse direction. It returns a wrapped
-      /// RevArcIt, which looks like an STL container
-      /// (by having begin() and end()) which you can use in range-based
-      /// for loops, STL algorithms, etc.
-      /// For example you can write:
-      ///\code
-      /// for(auto a: p.revArcs())
-      ///   doSomething(a);
-      ///\endcode
-      LemonRangeWrapper1<RevArcIt, PathDumper> revArcs() const {
-        return LemonRangeWrapper1<RevArcIt, PathDumper>(*this);
-      }
-
-
       template <typename _Path>
       struct Constraints {
Index: lemon/config.h.in
===================================================================
--- lemon/config.h.in	(revision 1343)
+++ lemon/config.h.in	(revision 1264)
@@ -1,12 +1,4 @@
-#ifndef LEMON_CONFIG_H
-#define LEMON_CONFIG_H
-
 #define LEMON_VERSION "@PROJECT_VERSION@"
 #cmakedefine LEMON_HAVE_LONG_LONG 1
-
-#cmakedefine LEMON_CXX11 1
-
-#cmakedefine LEMON_WIN32 1
-
 #cmakedefine LEMON_HAVE_LP 1
 #cmakedefine LEMON_HAVE_MIP 1
@@ -16,16 +8,6 @@
 #cmakedefine LEMON_HAVE_CLP 1
 #cmakedefine LEMON_HAVE_CBC 1
-
-#define LEMON_CPLEX_ 1
-#define LEMON_CLP_ 2
-#define LEMON_GLPK_ 3
-#define LEMON_SOPLEX_ 4
-#define LEMON_CBC_ 5
-
-#cmakedefine LEMON_DEFAULT_LP LEMON_@LEMON_DEFAULT_LP@_
-#cmakedefine LEMON_DEFAULT_MIP LEMON_@LEMON_DEFAULT_MIP@_
-
+#cmakedefine LEMON_DEFAULT_LP @LEMON_DEFAULT_LP@
+#cmakedefine LEMON_DEFAULT_MIP @LEMON_DEFAULT_MIP@
 #cmakedefine LEMON_USE_PTHREAD 1
 #cmakedefine LEMON_USE_WIN32_THREADS 1
-
-#endif
Index: lemon/core.h
===================================================================
--- lemon/core.h	(revision 1341)
+++ lemon/core.h	(revision 1270)
@@ -20,4 +20,33 @@
 #define LEMON_CORE_H
 
+#include <vector>
+#include <algorithm>
+
+#include <lemon/config.h>
+#include <lemon/bits/enable_if.h>
+#include <lemon/bits/traits.h>
+#include <lemon/assert.h>
+
+// Disable the following warnings when compiling with MSVC:
+// C4250: 'class1' : inherits 'class2::member' via dominance
+// C4355: 'this' : used in base member initializer list
+// C4503: 'function' : decorated name length exceeded, name was truncated
+// C4800: 'type' : forcing value to bool 'true' or 'false' (performance warning)
+// C4996: 'function': was declared deprecated
+#ifdef _MSC_VER
+#pragma warning( disable : 4250 4355 4503 4800 4996 )
+#endif
+
+#ifdef __GNUC__
+#define GCC_VERSION (__GNUC__ * 10000                   \
+                     + __GNUC_MINOR__ * 100             \
+                     + __GNUC_PATCHLEVEL__)
+#endif
+
+#if GCC_VERSION >= 40800
+// Needed by the [DI]GRAPH_TYPEDEFS marcos for gcc 4.8
+#pragma GCC diagnostic ignored "-Wunused-local-typedefs"
+#endif
+
 ///\file
 ///\brief LEMON core utilities.
@@ -26,30 +55,4 @@
 ///It is automatically included by all graph types, therefore it usually
 ///do not have to be included directly.
-
-// Disable the following warnings when compiling with MSVC:
-// C4250: 'class1' : inherits 'class2::member' via dominance
-// C4267: conversion from 'size_t' to 'type', possible loss of data
-// C4355: 'this' : used in base member initializer list
-// C4503: 'function' : decorated name length exceeded, name was truncated
-// C4800: 'type' : forcing value to bool 'true' or 'false' (performance warning)
-// C4996: 'function': was declared deprecated
-#ifdef _MSC_VER
-#pragma warning( disable : 4250 4267 4355 4503 4800 4996 )
-#endif
-
-#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8)
-// Needed by the [DI]GRAPH_TYPEDEFS marcos for gcc 4.8
-#pragma GCC diagnostic ignored "-Wunused-local-typedefs"
-#endif
-
-#include <vector>
-#include <algorithm>
-
-#include <lemon/config.h>
-#include <lemon/bits/enable_if.h>
-#include <lemon/bits/traits.h>
-#include <lemon/assert.h>
-
-
 
 namespace lemon {
Index: lemon/cost_scaling.h
===================================================================
--- lemon/cost_scaling.h	(revision 1298)
+++ lemon/cost_scaling.h	(revision 1270)
@@ -92,6 +92,5 @@
   /// \ref CostScaling implements a cost scaling algorithm that performs
   /// push/augment and relabel operations for finding a \ref min_cost_flow
-  /// "minimum cost flow" \cite amo93networkflows,
-  /// \cite goldberg90approximation,
+  /// "minimum cost flow" \cite amo93networkflows, \cite goldberg90approximation,
   /// \cite goldberg97efficient, \cite bunnagel98efficient.
   /// It is a highly efficient primal-dual solution method, which
@@ -215,6 +214,5 @@
     typedef std::vector<LargeCost> LargeCostVector;
     typedef std::vector<char> BoolVector;
-    // Note: vector<char> is used instead of vector<bool>
-    // for efficiency reasons
+    // Note: vector<char> is used instead of vector<bool> for efficiency reasons
 
   private:
@@ -257,5 +255,5 @@
 
     // Parameters of the problem
-    bool _has_lower;
+    bool _have_lower;
     Value _sum_supply;
     int _sup_node_num;
@@ -373,7 +371,8 @@
     template <typename LowerMap>
     CostScaling& lowerMap(const LowerMap& map) {
-      _has_lower = true;
+      _have_lower = true;
       for (ArcIt a(_graph); a != INVALID; ++a) {
         _lower[_arc_idf[a]] = map[a];
+        _lower[_arc_idb[a]] = map[a];
       }
       return *this;
@@ -568,5 +567,5 @@
         _scost[_reverse[j]] = 0;
       }
-      _has_lower = false;
+      _have_lower = false;
       return *this;
     }
@@ -780,5 +779,5 @@
       const Value MAX = std::numeric_limits<Value>::max();
       int last_out;
-      if (_has_lower) {
+      if (_have_lower) {
         for (int i = 0; i != _root; ++i) {
           last_out = _first_out[i+1];
@@ -837,5 +836,5 @@
         sup[n] = _supply[_node_id[n]];
       }
-      if (_has_lower) {
+      if (_have_lower) {
         for (ArcIt a(_graph); a != INVALID; ++a) {
           int j = _arc_idf[a];
@@ -907,9 +906,9 @@
     }
 
-    // Check if the upper bound is greater than or equal to the lower bound
-    // on each forward arc.
+    // Check if the upper bound is greater or equal to the lower bound
+    // on each arc.
     bool checkBoundMaps() {
       for (int j = 0; j != _res_arc_num; ++j) {
-        if (_forward[j] && _upper[j] < _lower[j]) return false;
+        if (_upper[j] < _lower[j]) return false;
       }
       return true;
@@ -991,8 +990,8 @@
 
       // Handle non-zero lower bounds
-      if (_has_lower) {
+      if (_have_lower) {
         int limit = _first_out[_root];
         for (int j = 0; j != limit; ++j) {
-          if (_forward[j]) _res_cap[_reverse[j]] += _lower[j];
+          if (!_forward[j]) _res_cap[j] += _lower[j];
         }
       }
Index: lemon/counter.h
===================================================================
--- lemon/counter.h	(revision 1327)
+++ lemon/counter.h	(revision 833)
@@ -22,6 +22,4 @@
 #include <string>
 #include <iostream>
-
-#include <lemon/core.h>
 
 ///\ingroup timecount
Index: lemon/cplex.cc
===================================================================
--- lemon/cplex.cc	(revision 1349)
+++ lemon/cplex.cc	(revision 1270)
@@ -38,52 +38,35 @@
   }
 
-  void CplexEnv::incCnt()
-  {
-    _cnt_lock->lock();
+  CplexEnv::CplexEnv() {
+    int status;
+    _cnt = new int;
+    (*_cnt) = 1;
+    _env = CPXopenCPLEX(&status);
+    if (_env == 0) {
+      delete _cnt;
+      _cnt = 0;
+      throw LicenseError(status);
+    }
+  }
+
+  CplexEnv::CplexEnv(const CplexEnv& other) {
+    _env = other._env;
+    _cnt = other._cnt;
     ++(*_cnt);
-    _cnt_lock->unlock();
-  }
-
-  void CplexEnv::decCnt()
-  {
-    _cnt_lock->lock();
+  }
+
+  CplexEnv& CplexEnv::operator=(const CplexEnv& other) {
+    _env = other._env;
+    _cnt = other._cnt;
+    ++(*_cnt);
+    return *this;
+  }
+
+  CplexEnv::~CplexEnv() {
     --(*_cnt);
     if (*_cnt == 0) {
       delete _cnt;
-      _cnt_lock->unlock();
-      delete _cnt_lock;
       CPXcloseCPLEX(&_env);
     }
-    else _cnt_lock->unlock();
-  }
-  
-  CplexEnv::CplexEnv() {
-    int status;
-    _env = CPXopenCPLEX(&status);
-    if (_env == 0)
-      throw LicenseError(status);
-    _cnt = new int;
-    (*_cnt) = 1;
-    _cnt_lock = new bits::Lock;
-  }
-
-  CplexEnv::CplexEnv(const CplexEnv& other) {
-    _env = other._env;
-    _cnt = other._cnt;
-    _cnt_lock = other._cnt_lock;
-    incCnt();
-  }
-
-  CplexEnv& CplexEnv::operator=(const CplexEnv& other) {
-    decCnt();
-    _env = other._env;
-    _cnt = other._cnt;
-    _cnt_lock = other._cnt_lock;
-    incCnt();
-    return *this;
-  }
-
-  CplexEnv::~CplexEnv() {
-    decCnt();
   }
 
@@ -105,6 +88,6 @@
     int status;
     _prob = CPXcloneprob(cplexEnv(), cplex._prob, &status);
-    _rows = cplex._rows;
-    _cols = cplex._cols;
+    rows = cplex.rows;
+    cols = cplex.cols;
     messageLevel(MESSAGE_NOTHING);
   }
@@ -133,8 +116,21 @@
                          ExprIterator e, Value ub) {
     int i = CPXgetnumrows(cplexEnv(), _prob);
-
-    int rmatbeg = 0;
-    
+    if (lb == -INF) {
+      const char s = 'L';
+      CPXnewrows(cplexEnv(), _prob, 1, &ub, &s, 0, 0);
+    } else if (ub == INF) {
+      const char s = 'G';
+      CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, 0, 0);
+    } else if (lb == ub){
+      const char s = 'E';
+      CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, 0, 0);
+    } else {
+      const char s = 'R';
+      double len = ub - lb;
+      CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, &len, 0);
+    }
+
     std::vector<int> indices;
+    std::vector<int> rowlist;
     std::vector<Value> values;
 
@@ -142,26 +138,10 @@
       indices.push_back(it->first);
       values.push_back(it->second);
-    }
-
-    if (lb == -INF) {
-      const char s = 'L';
-      CPXaddrows(cplexEnv(), _prob, 0, 1, values.size(), &ub, &s,
-                 &rmatbeg, &indices.front(), &values.front(), 0, 0);
-    } else if (ub == INF) {
-      const char s = 'G';
-      CPXaddrows(cplexEnv(), _prob, 0, 1, values.size(), &lb, &s,
-                 &rmatbeg, &indices.front(), &values.front(), 0, 0);
-    } else if (lb == ub){
-      const char s = 'E';
-      CPXaddrows(cplexEnv(), _prob, 0, 1, values.size(), &lb, &s,
-                 &rmatbeg, &indices.front(), &values.front(), 0, 0);
-    } else {
-      const char s = 'R';
-      double len = ub - lb;
-      CPXaddrows(cplexEnv(), _prob, 0, 1, values.size(), &ub, &s,
-                 &rmatbeg, &indices.front(), &values.front(), 0, 0);
-      CPXchgrngval(cplexEnv(), _prob, 1, &i, &len);
-    }
-    
+      rowlist.push_back(i);
+    }
+
+    CPXchgcoeflist(cplexEnv(), _prob, values.size(),
+                   &rowlist.front(), &indices.front(), &values.front());
+
     return i;
   }
@@ -176,10 +156,10 @@
 
   void CplexBase::_eraseColId(int i) {
-    _cols.eraseIndex(i);
-    _cols.shiftIndices(i);
+    cols.eraseIndex(i);
+    cols.shiftIndices(i);
   }
   void CplexBase::_eraseRowId(int i) {
-    _rows.eraseIndex(i);
-    _rows.shiftIndices(i);
+    rows.eraseIndex(i);
+    rows.shiftIndices(i);
   }
 
Index: lemon/cplex.h
===================================================================
--- lemon/cplex.h	(revision 1347)
+++ lemon/cplex.h	(revision 1270)
@@ -24,5 +24,4 @@
 
 #include <lemon/lp_base.h>
-#include <lemon/bits/lock.h>
 
 struct cpxenv;
@@ -42,9 +41,5 @@
     cpxenv* _env;
     mutable int* _cnt;
-    mutable bits::Lock* _cnt_lock;
-
-    void incCnt();
-    void decCnt();
-    
+
   public:
 
Index: lemon/cycle_canceling.h
===================================================================
--- lemon/cycle_canceling.h	(revision 1298)
+++ lemon/cycle_canceling.h	(revision 1270)
@@ -196,5 +196,5 @@
 
     // Parameters of the problem
-    bool _has_lower;
+    bool _have_lower;
     Value _sum_supply;
 
@@ -279,7 +279,8 @@
     template <typename LowerMap>
     CycleCanceling& lowerMap(const LowerMap& map) {
-      _has_lower = true;
+      _have_lower = true;
       for (ArcIt a(_graph); a != INVALID; ++a) {
         _lower[_arc_idf[a]] = map[a];
+        _lower[_arc_idb[a]] = map[a];
       }
       return *this;
@@ -471,5 +472,5 @@
         _cost[_reverse[j]] = 0;
       }
-      _has_lower = false;
+      _have_lower = false;
       return *this;
     }
@@ -684,5 +685,5 @@
       const Value MAX = std::numeric_limits<Value>::max();
       int last_out;
-      if (_has_lower) {
+      if (_have_lower) {
         for (int i = 0; i != _root; ++i) {
           last_out = _first_out[i+1];
@@ -727,5 +728,5 @@
         sup[n] = _supply[_node_id[n]];
       }
-      if (_has_lower) {
+      if (_have_lower) {
         for (ArcIt a(_graph); a != INVALID; ++a) {
           int j = _arc_idf[a];
@@ -784,9 +785,9 @@
     }
 
-    // Check if the upper bound is greater than or equal to the lower bound
-    // on each forward arc.
+    // Check if the upper bound is greater or equal to the lower bound
+    // on each arc.
     bool checkBoundMaps() {
       for (int j = 0; j != _res_arc_num; ++j) {
-        if (_forward[j] && _upper[j] < _lower[j]) return false;
+        if (_upper[j] < _lower[j]) return false;
       }
       return true;
@@ -835,8 +836,8 @@
 
       // Handle non-zero lower bounds
-      if (_has_lower) {
+      if (_have_lower) {
         int limit = _first_out[_root];
         for (int j = 0; j != limit; ++j) {
-          if (_forward[j]) _res_cap[_reverse[j]] += _lower[j];
+          if (!_forward[j]) _res_cap[j] += _lower[j];
         }
       }
Index: lemon/dim2.h
===================================================================
--- lemon/dim2.h	(revision 1311)
+++ lemon/dim2.h	(revision 761)
@@ -21,5 +21,4 @@
 
 #include <iostream>
-#include <algorithm>
 
 ///\ingroup geomdat
Index: lemon/elevator.h
===================================================================
--- lemon/elevator.h	(revision 1328)
+++ lemon/elevator.h	(revision 628)
@@ -168,5 +168,5 @@
     int onLevel(int l) const
     {
-      return static_cast<int>(_first[l+1]-_first[l]);
+      return _first[l+1]-_first[l];
     }
     ///Return true if level \c l is empty.
@@ -178,10 +178,10 @@
     int aboveLevel(int l) const
     {
-      return static_cast<int>(_first[_max_level+1]-_first[l+1]);
+      return _first[_max_level+1]-_first[l+1];
     }
     ///Return the number of active items on level \c l.
     int activesOnLevel(int l) const
     {
-      return static_cast<int>(_last_active[l]-_first[l]+1);
+      return _last_active[l]-_first[l]+1;
     }
     ///Return true if there is no active item on level \c l.
Index: lemon/glpk.cc
===================================================================
--- lemon/glpk.cc	(revision 1336)
+++ lemon/glpk.cc	(revision 1270)
@@ -39,6 +39,6 @@
     glp_copy_prob(lp, other.lp, GLP_ON);
     glp_create_index(lp);
-    _rows = other._rows;
-    _cols = other._cols;
+    rows = other.rows;
+    cols = other.cols;
     messageLevel(MESSAGE_NOTHING);
   }
@@ -109,11 +109,11 @@
 
   void GlpkBase::_eraseColId(int i) {
-    _cols.eraseIndex(i);
-    _cols.shiftIndices(i);
+    cols.eraseIndex(i);
+    cols.shiftIndices(i);
   }
 
   void GlpkBase::_eraseRowId(int i) {
-    _rows.eraseIndex(i);
-    _rows.shiftIndices(i);
+    rows.eraseIndex(i);
+    rows.shiftIndices(i);
   }
 
Index: lemon/glpk.h
===================================================================
--- lemon/glpk.h	(revision 1336)
+++ lemon/glpk.h	(revision 1270)
@@ -142,8 +142,8 @@
 
     ///Returns the constraint identifier understood by GLPK.
-    int lpxRow(Row r) const { return _rows(id(r)); }
+    int lpxRow(Row r) const { return rows(id(r)); }
 
     ///Returns the variable identifier understood by GLPK.
-    int lpxCol(Col c) const { return _cols(id(c)); }
+    int lpxCol(Col c) const { return cols(id(c)); }
 
 #ifdef DOXYGEN
Index: lemon/graph_to_eps.h
===================================================================
--- lemon/graph_to_eps.h	(revision 1340)
+++ lemon/graph_to_eps.h	(revision 1270)
@@ -26,5 +26,5 @@
 #include<vector>
 
-#ifndef LEMON_WIN32
+#ifndef WIN32
 #include<sys/time.h>
 #include<ctime>
@@ -223,4 +223,5 @@
   using T::_copyright;
 
+  using T::NodeTextColorType;
   using T::CUST_COL;
   using T::DIST_COL;
@@ -675,5 +676,5 @@
     {
       os << "%%CreationDate: ";
-#ifndef LEMON_WIN32
+#ifndef WIN32
       timeval tv;
       gettimeofday(&tv, 0);
Index: lemon/howard_mmc.h
===================================================================
--- lemon/howard_mmc.h	(revision 1271)
+++ lemon/howard_mmc.h	(revision 1270)
@@ -362,6 +362,5 @@
     /// \return The termination cause of the search process.
     /// For more information, see \ref TerminationCause.
-    TerminationCause findCycleMean(int limit =
-                                   std::numeric_limits<int>::max()) {
+    TerminationCause findCycleMean(int limit = std::numeric_limits<int>::max()) {
       // Initialize and find strongly connected components
       init();
Index: lemon/lgf_reader.h
===================================================================
--- lemon/lgf_reader.h	(revision 1361)
+++ lemon/lgf_reader.h	(revision 1270)
@@ -1245,5 +1245,5 @@
   ///\code
   ///ListDigraph digraph;
-  ///ListDigraph::ArcMap<int> cap(digraph);
+  ///ListDigraph::ArcMap<int> cm(digraph);
   ///ListDigraph::Node src, trg;
   ///digraphReader(digraph, std::cin).
Index: lemon/list_graph.h
===================================================================
--- lemon/list_graph.h	(revision 1359)
+++ lemon/list_graph.h	(revision 1270)
@@ -49,5 +49,5 @@
     };
 
-    std::vector<NodeT> _nodes;
+    std::vector<NodeT> nodes;
 
     int first_node;
@@ -55,5 +55,5 @@
     int first_free_node;
 
-    std::vector<ArcT> _arcs;
+    std::vector<ArcT> arcs;
 
     int first_free_arc;
@@ -98,13 +98,13 @@
 
     ListDigraphBase()
-      : _nodes(), first_node(-1),
-        first_free_node(-1), _arcs(), first_free_arc(-1) {}
-
-
-    int maxNodeId() const { return _nodes.size()-1; }
-    int maxArcId() const { return _arcs.size()-1; }
-
-    Node source(Arc e) const { return Node(_arcs[e.id].source); }
-    Node target(Arc e) const { return Node(_arcs[e.id].target); }
+      : nodes(), first_node(-1),
+        first_free_node(-1), arcs(), first_free_arc(-1) {}
+
+
+    int maxNodeId() const { return nodes.size()-1; }
+    int maxArcId() const { return arcs.size()-1; }
+
+    Node source(Arc e) const { return Node(arcs[e.id].source); }
+    Node target(Arc e) const { return Node(arcs[e.id].target); }
 
 
@@ -114,5 +114,5 @@
 
     void next(Node& node) const {
-      node.id = _nodes[node.id].next;
+      node.id = nodes[node.id].next;
     }
 
@@ -121,33 +121,33 @@
       int n;
       for(n = first_node;
-          n != -1 && _nodes[n].first_out == -1;
-          n = _nodes[n].next) {}
-      arc.id = (n == -1) ? -1 : _nodes[n].first_out;
+          n != -1 && nodes[n].first_out == -1;
+          n = nodes[n].next) {}
+      arc.id = (n == -1) ? -1 : nodes[n].first_out;
     }
 
     void next(Arc& arc) const {
-      if (_arcs[arc.id].next_out != -1) {
-        arc.id = _arcs[arc.id].next_out;
+      if (arcs[arc.id].next_out != -1) {
+        arc.id = arcs[arc.id].next_out;
       } else {
         int n;
-        for(n = _nodes[_arcs[arc.id].source].next;
-            n != -1 && _nodes[n].first_out == -1;
-            n = _nodes[n].next) {}
-        arc.id = (n == -1) ? -1 : _nodes[n].first_out;
+        for(n = nodes[arcs[arc.id].source].next;
+            n != -1 && nodes[n].first_out == -1;
+            n = nodes[n].next) {}
+        arc.id = (n == -1) ? -1 : nodes[n].first_out;
       }
     }
 
     void firstOut(Arc &e, const Node& v) const {
-      e.id = _nodes[v.id].first_out;
+      e.id = nodes[v.id].first_out;
     }
     void nextOut(Arc &e) const {
-      e.id=_arcs[e.id].next_out;
+      e.id=arcs[e.id].next_out;
     }
 
     void firstIn(Arc &e, const Node& v) const {
-      e.id = _nodes[v.id].first_in;
+      e.id = nodes[v.id].first_in;
     }
     void nextIn(Arc &e) const {
-      e.id=_arcs[e.id].next_in;
+      e.id=arcs[e.id].next_in;
     }
 
@@ -160,11 +160,11 @@
 
     bool valid(Node n) const {
-      return n.id >= 0 && n.id < static_cast<int>(_nodes.size()) &&
-        _nodes[n.id].prev != -2;
+      return n.id >= 0 && n.id < static_cast<int>(nodes.size()) &&
+        nodes[n.id].prev != -2;
     }
 
     bool valid(Arc a) const {
-      return a.id >= 0 && a.id < static_cast<int>(_arcs.size()) &&
-        _arcs[a.id].prev_in != -2;
+      return a.id >= 0 && a.id < static_cast<int>(arcs.size()) &&
+        arcs[a.id].prev_in != -2;
     }
 
@@ -173,17 +173,17 @@
 
       if(first_free_node==-1) {
-        n = _nodes.size();
-        _nodes.push_back(NodeT());
+        n = nodes.size();
+        nodes.push_back(NodeT());
       } else {
         n = first_free_node;
-        first_free_node = _nodes[n].next;
-      }
-
-      _nodes[n].next = first_node;
-      if(first_node != -1) _nodes[first_node].prev = n;
+        first_free_node = nodes[n].next;
+      }
+
+      nodes[n].next = first_node;
+      if(first_node != -1) nodes[first_node].prev = n;
       first_node = n;
-      _nodes[n].prev = -1;
-
-      _nodes[n].first_in = _nodes[n].first_out = -1;
+      nodes[n].prev = -1;
+
+      nodes[n].first_in = nodes[n].first_out = -1;
 
       return Node(n);
@@ -194,27 +194,27 @@
 
       if (first_free_arc == -1) {
-        n = _arcs.size();
-        _arcs.push_back(ArcT());
+        n = arcs.size();
+        arcs.push_back(ArcT());
       } else {
         n = first_free_arc;
-        first_free_arc = _arcs[n].next_in;
-      }
-
-      _arcs[n].source = u.id;
-      _arcs[n].target = v.id;
-
-      _arcs[n].next_out = _nodes[u.id].first_out;
-      if(_nodes[u.id].first_out != -1) {
-        _arcs[_nodes[u.id].first_out].prev_out = n;
-      }
-
-      _arcs[n].next_in = _nodes[v.id].first_in;
-      if(_nodes[v.id].first_in != -1) {
-        _arcs[_nodes[v.id].first_in].prev_in = n;
-      }
-
-      _arcs[n].prev_in = _arcs[n].prev_out = -1;
-
-      _nodes[u.id].first_out = _nodes[v.id].first_in = n;
+        first_free_arc = arcs[n].next_in;
+      }
+
+      arcs[n].source = u.id;
+      arcs[n].target = v.id;
+
+      arcs[n].next_out = nodes[u.id].first_out;
+      if(nodes[u.id].first_out != -1) {
+        arcs[nodes[u.id].first_out].prev_out = n;
+      }
+
+      arcs[n].next_in = nodes[v.id].first_in;
+      if(nodes[v.id].first_in != -1) {
+        arcs[nodes[v.id].first_in].prev_in = n;
+      }
+
+      arcs[n].prev_in = arcs[n].prev_out = -1;
+
+      nodes[u.id].first_out = nodes[v.id].first_in = n;
 
       return Arc(n);
@@ -224,17 +224,17 @@
       int n = node.id;
 
-      if(_nodes[n].next != -1) {
-        _nodes[_nodes[n].next].prev = _nodes[n].prev;
-      }
-
-      if(_nodes[n].prev != -1) {
-        _nodes[_nodes[n].prev].next = _nodes[n].next;
-      } else {
-        first_node = _nodes[n].next;
-      }
-
-      _nodes[n].next = first_free_node;
+      if(nodes[n].next != -1) {
+        nodes[nodes[n].next].prev = nodes[n].prev;
+      }
+
+      if(nodes[n].prev != -1) {
+        nodes[nodes[n].prev].next = nodes[n].next;
+      } else {
+        first_node = nodes[n].next;
+      }
+
+      nodes[n].next = first_free_node;
       first_free_node = n;
-      _nodes[n].prev = -2;
+      nodes[n].prev = -2;
 
     }
@@ -243,33 +243,33 @@
       int n = arc.id;
 
-      if(_arcs[n].next_in!=-1) {
-        _arcs[_arcs[n].next_in].prev_in = _arcs[n].prev_in;
-      }
-
-      if(_arcs[n].prev_in!=-1) {
-        _arcs[_arcs[n].prev_in].next_in = _arcs[n].next_in;
-      } else {
-        _nodes[_arcs[n].target].first_in = _arcs[n].next_in;
-      }
-
-
-      if(_arcs[n].next_out!=-1) {
-        _arcs[_arcs[n].next_out].prev_out = _arcs[n].prev_out;
-      }
-
-      if(_arcs[n].prev_out!=-1) {
-        _arcs[_arcs[n].prev_out].next_out = _arcs[n].next_out;
-      } else {
-        _nodes[_arcs[n].source].first_out = _arcs[n].next_out;
-      }
-
-      _arcs[n].next_in = first_free_arc;
+      if(arcs[n].next_in!=-1) {
+        arcs[arcs[n].next_in].prev_in = arcs[n].prev_in;
+      }
+
+      if(arcs[n].prev_in!=-1) {
+        arcs[arcs[n].prev_in].next_in = arcs[n].next_in;
+      } else {
+        nodes[arcs[n].target].first_in = arcs[n].next_in;
+      }
+
+
+      if(arcs[n].next_out!=-1) {
+        arcs[arcs[n].next_out].prev_out = arcs[n].prev_out;
+      }
+
+      if(arcs[n].prev_out!=-1) {
+        arcs[arcs[n].prev_out].next_out = arcs[n].next_out;
+      } else {
+        nodes[arcs[n].source].first_out = arcs[n].next_out;
+      }
+
+      arcs[n].next_in = first_free_arc;
       first_free_arc = n;
-      _arcs[n].prev_in = -2;
+      arcs[n].prev_in = -2;
     }
 
     void clear() {
-      _arcs.clear();
-      _nodes.clear();
+      arcs.clear();
+      nodes.clear();
       first_node = first_free_node = first_free_arc = -1;
     }
@@ -278,31 +278,31 @@
     void changeTarget(Arc e, Node n)
     {
-      if(_arcs[e.id].next_in != -1)
-        _arcs[_arcs[e.id].next_in].prev_in = _arcs[e.id].prev_in;
-      if(_arcs[e.id].prev_in != -1)
-        _arcs[_arcs[e.id].prev_in].next_in = _arcs[e.id].next_in;
-      else _nodes[_arcs[e.id].target].first_in = _arcs[e.id].next_in;
-      if (_nodes[n.id].first_in != -1) {
-        _arcs[_nodes[n.id].first_in].prev_in = e.id;
-      }
-      _arcs[e.id].target = n.id;
-      _arcs[e.id].prev_in = -1;
-      _arcs[e.id].next_in = _nodes[n.id].first_in;
-      _nodes[n.id].first_in = e.id;
+      if(arcs[e.id].next_in != -1)
+        arcs[arcs[e.id].next_in].prev_in = arcs[e.id].prev_in;
+      if(arcs[e.id].prev_in != -1)
+        arcs[arcs[e.id].prev_in].next_in = arcs[e.id].next_in;
+      else nodes[arcs[e.id].target].first_in = arcs[e.id].next_in;
+      if (nodes[n.id].first_in != -1) {
+        arcs[nodes[n.id].first_in].prev_in = e.id;
+      }
+      arcs[e.id].target = n.id;
+      arcs[e.id].prev_in = -1;
+      arcs[e.id].next_in = nodes[n.id].first_in;
+      nodes[n.id].first_in = e.id;
     }
     void changeSource(Arc e, Node n)
     {
-      if(_arcs[e.id].next_out != -1)
-        _arcs[_arcs[e.id].next_out].prev_out = _arcs[e.id].prev_out;
-      if(_arcs[e.id].prev_out != -1)
-        _arcs[_arcs[e.id].prev_out].next_out = _arcs[e.id].next_out;
-      else _nodes[_arcs[e.id].source].first_out = _arcs[e.id].next_out;
-      if (_nodes[n.id].first_out != -1) {
-        _arcs[_nodes[n.id].first_out].prev_out = e.id;
-      }
-      _arcs[e.id].source = n.id;
-      _arcs[e.id].prev_out = -1;
-      _arcs[e.id].next_out = _nodes[n.id].first_out;
-      _nodes[n.id].first_out = e.id;
+      if(arcs[e.id].next_out != -1)
+        arcs[arcs[e.id].next_out].prev_out = arcs[e.id].prev_out;
+      if(arcs[e.id].prev_out != -1)
+        arcs[arcs[e.id].prev_out].next_out = arcs[e.id].next_out;
+      else nodes[arcs[e.id].source].first_out = arcs[e.id].next_out;
+      if (nodes[n.id].first_out != -1) {
+        arcs[nodes[n.id].first_out].prev_out = e.id;
+      }
+      arcs[e.id].source = n.id;
+      arcs[e.id].prev_out = -1;
+      arcs[e.id].next_out = nodes[n.id].first_out;
+      nodes[n.id].first_out = e.id;
     }
 
@@ -487,8 +487,8 @@
     Node split(Node n, bool connect = true) {
       Node b = addNode();
-      _nodes[b.id].first_out=_nodes[n.id].first_out;
-      _nodes[n.id].first_out=-1;
-      for(int i=_nodes[b.id].first_out; i!=-1; i=_arcs[i].next_out) {
-        _arcs[i].source=b.id;
+      nodes[b.id].first_out=nodes[n.id].first_out;
+      nodes[n.id].first_out=-1;
+      for(int i=nodes[b.id].first_out; i!=-1; i=arcs[i].next_out) {
+        arcs[i].source=b.id;
       }
       if (connect) addArc(n,b);
@@ -533,5 +533,5 @@
     /// to build the digraph.
     /// \sa reserveArc()
-    void reserveNode(int n) { _nodes.reserve(n); };
+    void reserveNode(int n) { nodes.reserve(n); };
 
     /// Reserve memory for arcs.
@@ -543,5 +543,5 @@
     /// to build the digraph.
     /// \sa reserveNode()
-    void reserveArc(int m) { _arcs.reserve(m); };
+    void reserveArc(int m) { arcs.reserve(m); };
 
     /// \brief Class to make a snapshot of the digraph and restore
@@ -583,5 +583,5 @@
         }
         virtual void add(const std::vector<Node>& nodes) {
-          for (int i = nodes.size() - 1; i >= 0; --i) {
+          for (int i = nodes.size() - 1; i >= 0; ++i) {
             snapshot.addNode(nodes[i]);
           }
@@ -633,5 +633,5 @@
         }
         virtual void add(const std::vector<Arc>& arcs) {
-          for (int i = arcs.size() - 1; i >= 0; --i) {
+          for (int i = arcs.size() - 1; i >= 0; ++i) {
             snapshot.addArc(arcs[i]);
           }
@@ -804,5 +804,5 @@
     };
 
-    std::vector<NodeT> _nodes;
+    std::vector<NodeT> nodes;
 
     int first_node;
@@ -810,5 +810,5 @@
     int first_free_node;
 
-    std::vector<ArcT> _arcs;
+    std::vector<ArcT> arcs;
 
     int first_free_arc;
@@ -868,17 +868,17 @@
 
     ListGraphBase()
-      : _nodes(), first_node(-1),
-        first_free_node(-1), _arcs(), first_free_arc(-1) {}
-
-
-    int maxNodeId() const { return _nodes.size()-1; }
-    int maxEdgeId() const { return _arcs.size() / 2 - 1; }
-    int maxArcId() const { return _arcs.size()-1; }
-
-    Node source(Arc e) const { return Node(_arcs[e.id ^ 1].target); }
-    Node target(Arc e) const { return Node(_arcs[e.id].target); }
-
-    Node u(Edge e) const { return Node(_arcs[2 * e.id].target); }
-    Node v(Edge e) const { return Node(_arcs[2 * e.id + 1].target); }
+      : nodes(), first_node(-1),
+        first_free_node(-1), arcs(), first_free_arc(-1) {}
+
+
+    int maxNodeId() const { return nodes.size()-1; }
+    int maxEdgeId() const { return arcs.size() / 2 - 1; }
+    int maxArcId() const { return arcs.size()-1; }
+
+    Node source(Arc e) const { return Node(arcs[e.id ^ 1].target); }
+    Node target(Arc e) const { return Node(arcs[e.id].target); }
+
+    Node u(Edge e) const { return Node(arcs[2 * e.id].target); }
+    Node v(Edge e) const { return Node(arcs[2 * e.id + 1].target); }
 
     static bool direction(Arc e) {
@@ -895,24 +895,24 @@
 
     void next(Node& node) const {
-      node.id = _nodes[node.id].next;
+      node.id = nodes[node.id].next;
     }
 
     void first(Arc& e) const {
       int n = first_node;
-      while (n != -1 && _nodes[n].first_out == -1) {
-        n = _nodes[n].next;
-      }
-      e.id = (n == -1) ? -1 : _nodes[n].first_out;
+      while (n != -1 && nodes[n].first_out == -1) {
+        n = nodes[n].next;
+      }
+      e.id = (n == -1) ? -1 : nodes[n].first_out;
     }
 
     void next(Arc& e) const {
-      if (_arcs[e.id].next_out != -1) {
-        e.id = _arcs[e.id].next_out;
-      } else {
-        int n = _nodes[_arcs[e.id ^ 1].target].next;
-        while(n != -1 && _nodes[n].first_out == -1) {
-          n = _nodes[n].next;
-        }
-        e.id = (n == -1) ? -1 : _nodes[n].first_out;
+      if (arcs[e.id].next_out != -1) {
+        e.id = arcs[e.id].next_out;
+      } else {
+        int n = nodes[arcs[e.id ^ 1].target].next;
+        while(n != -1 && nodes[n].first_out == -1) {
+          n = nodes[n].next;
+        }
+        e.id = (n == -1) ? -1 : nodes[n].first_out;
       }
     }
@@ -921,7 +921,7 @@
       int n = first_node;
       while (n != -1) {
-        e.id = _nodes[n].first_out;
+        e.id = nodes[n].first_out;
         while ((e.id & 1) != 1) {
-          e.id = _arcs[e.id].next_out;
+          e.id = arcs[e.id].next_out;
         }
         if (e.id != -1) {
@@ -929,5 +929,5 @@
           return;
         }
-        n = _nodes[n].next;
+        n = nodes[n].next;
       }
       e.id = -1;
@@ -935,8 +935,8 @@
 
     void next(Edge& e) const {
-      int n = _arcs[e.id * 2].target;
-      e.id = _arcs[(e.id * 2) | 1].next_out;
+      int n = arcs[e.id * 2].target;
+      e.id = arcs[(e.id * 2) | 1].next_out;
       while ((e.id & 1) != 1) {
-        e.id = _arcs[e.id].next_out;
+        e.id = arcs[e.id].next_out;
       }
       if (e.id != -1) {
@@ -944,9 +944,9 @@
         return;
       }
-      n = _nodes[n].next;
+      n = nodes[n].next;
       while (n != -1) {
-        e.id = _nodes[n].first_out;
+        e.id = nodes[n].first_out;
         while ((e.id & 1) != 1) {
-          e.id = _arcs[e.id].next_out;
+          e.id = arcs[e.id].next_out;
         }
         if (e.id != -1) {
@@ -954,5 +954,5 @@
           return;
         }
-        n = _nodes[n].next;
+        n = nodes[n].next;
       }
       e.id = -1;
@@ -960,21 +960,21 @@
 
     void firstOut(Arc &e, const Node& v) const {
-      e.id = _nodes[v.id].first_out;
+      e.id = nodes[v.id].first_out;
     }
     void nextOut(Arc &e) const {
-      e.id = _arcs[e.id].next_out;
+      e.id = arcs[e.id].next_out;
     }
 
     void firstIn(Arc &e, const Node& v) const {
-      e.id = ((_nodes[v.id].first_out) ^ 1);
+      e.id = ((nodes[v.id].first_out) ^ 1);
       if (e.id == -2) e.id = -1;
     }
     void nextIn(Arc &e) const {
-      e.id = ((_arcs[e.id ^ 1].next_out) ^ 1);
+      e.id = ((arcs[e.id ^ 1].next_out) ^ 1);
       if (e.id == -2) e.id = -1;
     }
 
     void firstInc(Edge &e, bool& d, const Node& v) const {
-      int a = _nodes[v.id].first_out;
+      int a = nodes[v.id].first_out;
       if (a != -1 ) {
         e.id = a / 2;
@@ -986,5 +986,5 @@
     }
     void nextInc(Edge &e, bool& d) const {
-      int a = (_arcs[(e.id * 2) | (d ? 1 : 0)].next_out);
+      int a = (arcs[(e.id * 2) | (d ? 1 : 0)].next_out);
       if (a != -1 ) {
         e.id = a / 2;
@@ -1005,16 +1005,16 @@
 
     bool valid(Node n) const {
-      return n.id >= 0 && n.id < static_cast<int>(_nodes.size()) &&
-        _nodes[n.id].prev != -2;
+      return n.id >= 0 && n.id < static_cast<int>(nodes.size()) &&
+        nodes[n.id].prev != -2;
     }
 
     bool valid(Arc a) const {
-      return a.id >= 0 && a.id < static_cast<int>(_arcs.size()) &&
-        _arcs[a.id].prev_out != -2;
+      return a.id >= 0 && a.id < static_cast<int>(arcs.size()) &&
+        arcs[a.id].prev_out != -2;
     }
 
     bool valid(Edge e) const {
-      return e.id >= 0 && 2 * e.id < static_cast<int>(_arcs.size()) &&
-        _arcs[2 * e.id].prev_out != -2;
+      return e.id >= 0 && 2 * e.id < static_cast<int>(arcs.size()) &&
+        arcs[2 * e.id].prev_out != -2;
     }
 
@@ -1023,17 +1023,17 @@
 
       if(first_free_node==-1) {
-        n = _nodes.size();
-        _nodes.push_back(NodeT());
+        n = nodes.size();
+        nodes.push_back(NodeT());
       } else {
         n = first_free_node;
-        first_free_node = _nodes[n].next;
-      }
-
-      _nodes[n].next = first_node;
-      if (first_node != -1) _nodes[first_node].prev = n;
+        first_free_node = nodes[n].next;
+      }
+
+      nodes[n].next = first_node;
+      if (first_node != -1) nodes[first_node].prev = n;
       first_node = n;
-      _nodes[n].prev = -1;
-
-      _nodes[n].first_out = -1;
+      nodes[n].prev = -1;
+
+      nodes[n].first_out = -1;
 
       return Node(n);
@@ -1044,28 +1044,28 @@
 
       if (first_free_arc == -1) {
-        n = _arcs.size();
-        _arcs.push_back(ArcT());
-        _arcs.push_back(ArcT());
+        n = arcs.size();
+        arcs.push_back(ArcT());
+        arcs.push_back(ArcT());
       } else {
         n = first_free_arc;
-        first_free_arc = _arcs[n].next_out;
-      }
-
-      _arcs[n].target = u.id;
-      _arcs[n | 1].target = v.id;
-
-      _arcs[n].next_out = _nodes[v.id].first_out;
-      if (_nodes[v.id].first_out != -1) {
-        _arcs[_nodes[v.id].first_out].prev_out = n;
-      }
-      _arcs[n].prev_out = -1;
-      _nodes[v.id].first_out = n;
-
-      _arcs[n | 1].next_out = _nodes[u.id].first_out;
-      if (_nodes[u.id].first_out != -1) {
-        _arcs[_nodes[u.id].first_out].prev_out = (n | 1);
-      }
-      _arcs[n | 1].prev_out = -1;
-      _nodes[u.id].first_out = (n | 1);
+        first_free_arc = arcs[n].next_out;
+      }
+
+      arcs[n].target = u.id;
+      arcs[n | 1].target = v.id;
+
+      arcs[n].next_out = nodes[v.id].first_out;
+      if (nodes[v.id].first_out != -1) {
+        arcs[nodes[v.id].first_out].prev_out = n;
+      }
+      arcs[n].prev_out = -1;
+      nodes[v.id].first_out = n;
+
+      arcs[n | 1].next_out = nodes[u.id].first_out;
+      if (nodes[u.id].first_out != -1) {
+        arcs[nodes[u.id].first_out].prev_out = (n | 1);
+      }
+      arcs[n | 1].prev_out = -1;
+      nodes[u.id].first_out = (n | 1);
 
       return Edge(n / 2);
@@ -1075,17 +1075,17 @@
       int n = node.id;
 
-      if(_nodes[n].next != -1) {
-        _nodes[_nodes[n].next].prev = _nodes[n].prev;
-      }
-
-      if(_nodes[n].prev != -1) {
-        _nodes[_nodes[n].prev].next = _nodes[n].next;
-      } else {
-        first_node = _nodes[n].next;
-      }
-
-      _nodes[n].next = first_free_node;
+      if(nodes[n].next != -1) {
+        nodes[nodes[n].next].prev = nodes[n].prev;
+      }
+
+      if(nodes[n].prev != -1) {
+        nodes[nodes[n].prev].next = nodes[n].next;
+      } else {
+        first_node = nodes[n].next;
+      }
+
+      nodes[n].next = first_free_node;
       first_free_node = n;
-      _nodes[n].prev = -2;
+      nodes[n].prev = -2;
     }
 
@@ -1093,34 +1093,34 @@
       int n = edge.id * 2;
 
-      if (_arcs[n].next_out != -1) {
-        _arcs[_arcs[n].next_out].prev_out = _arcs[n].prev_out;
-      }
-
-      if (_arcs[n].prev_out != -1) {
-        _arcs[_arcs[n].prev_out].next_out = _arcs[n].next_out;
-      } else {
-        _nodes[_arcs[n | 1].target].first_out = _arcs[n].next_out;
-      }
-
-      if (_arcs[n | 1].next_out != -1) {
-        _arcs[_arcs[n | 1].next_out].prev_out = _arcs[n | 1].prev_out;
-      }
-
-      if (_arcs[n | 1].prev_out != -1) {
-        _arcs[_arcs[n | 1].prev_out].next_out = _arcs[n | 1].next_out;
-      } else {
-        _nodes[_arcs[n].target].first_out = _arcs[n | 1].next_out;
-      }
-
-      _arcs[n].next_out = first_free_arc;
+      if (arcs[n].next_out != -1) {
+        arcs[arcs[n].next_out].prev_out = arcs[n].prev_out;
+      }
+
+      if (arcs[n].prev_out != -1) {
+        arcs[arcs[n].prev_out].next_out = arcs[n].next_out;
+      } else {
+        nodes[arcs[n | 1].target].first_out = arcs[n].next_out;
+      }
+
+      if (arcs[n | 1].next_out != -1) {
+        arcs[arcs[n | 1].next_out].prev_out = arcs[n | 1].prev_out;
+      }
+
+      if (arcs[n | 1].prev_out != -1) {
+        arcs[arcs[n | 1].prev_out].next_out = arcs[n | 1].next_out;
+      } else {
+        nodes[arcs[n].target].first_out = arcs[n | 1].next_out;
+      }
+
+      arcs[n].next_out = first_free_arc;
       first_free_arc = n;
-      _arcs[n].prev_out = -2;
-      _arcs[n | 1].prev_out = -2;
+      arcs[n].prev_out = -2;
+      arcs[n | 1].prev_out = -2;
 
     }
 
     void clear() {
-      _arcs.clear();
-      _nodes.clear();
+      arcs.clear();
+      nodes.clear();
       first_node = first_free_node = first_free_arc = -1;
     }
@@ -1129,44 +1129,44 @@
 
     void changeV(Edge e, Node n) {
-      if(_arcs[2 * e.id].next_out != -1) {
-        _arcs[_arcs[2 * e.id].next_out].prev_out = _arcs[2 * e.id].prev_out;
-      }
-      if(_arcs[2 * e.id].prev_out != -1) {
-        _arcs[_arcs[2 * e.id].prev_out].next_out =
-          _arcs[2 * e.id].next_out;
-      } else {
-        _nodes[_arcs[(2 * e.id) | 1].target].first_out =
-          _arcs[2 * e.id].next_out;
-      }
-
-      if (_nodes[n.id].first_out != -1) {
-        _arcs[_nodes[n.id].first_out].prev_out = 2 * e.id;
-      }
-      _arcs[(2 * e.id) | 1].target = n.id;
-      _arcs[2 * e.id].prev_out = -1;
-      _arcs[2 * e.id].next_out = _nodes[n.id].first_out;
-      _nodes[n.id].first_out = 2 * e.id;
+      if(arcs[2 * e.id].next_out != -1) {
+        arcs[arcs[2 * e.id].next_out].prev_out = arcs[2 * e.id].prev_out;
+      }
+      if(arcs[2 * e.id].prev_out != -1) {
+        arcs[arcs[2 * e.id].prev_out].next_out =
+          arcs[2 * e.id].next_out;
+      } else {
+        nodes[arcs[(2 * e.id) | 1].target].first_out =
+          arcs[2 * e.id].next_out;
+      }
+
+      if (nodes[n.id].first_out != -1) {
+        arcs[nodes[n.id].first_out].prev_out = 2 * e.id;
+      }
+      arcs[(2 * e.id) | 1].target = n.id;
+      arcs[2 * e.id].prev_out = -1;
+      arcs[2 * e.id].next_out = nodes[n.id].first_out;
+      nodes[n.id].first_out = 2 * e.id;
     }
 
     void changeU(Edge e, Node n) {
-      if(_arcs[(2 * e.id) | 1].next_out != -1) {
-        _arcs[_arcs[(2 * e.id) | 1].next_out].prev_out =
-          _arcs[(2 * e.id) | 1].prev_out;
-      }
-      if(_arcs[(2 * e.id) | 1].prev_out != -1) {
-        _arcs[_arcs[(2 * e.id) | 1].prev_out].next_out =
-          _arcs[(2 * e.id) | 1].next_out;
-      } else {
-        _nodes[_arcs[2 * e.id].target].first_out =
-          _arcs[(2 * e.id) | 1].next_out;
-      }
-
-      if (_nodes[n.id].first_out != -1) {
-        _arcs[_nodes[n.id].first_out].prev_out = ((2 * e.id) | 1);
-      }
-      _arcs[2 * e.id].target = n.id;
-      _arcs[(2 * e.id) | 1].prev_out = -1;
-      _arcs[(2 * e.id) | 1].next_out = _nodes[n.id].first_out;
-      _nodes[n.id].first_out = ((2 * e.id) | 1);
+      if(arcs[(2 * e.id) | 1].next_out != -1) {
+        arcs[arcs[(2 * e.id) | 1].next_out].prev_out =
+          arcs[(2 * e.id) | 1].prev_out;
+      }
+      if(arcs[(2 * e.id) | 1].prev_out != -1) {
+        arcs[arcs[(2 * e.id) | 1].prev_out].next_out =
+          arcs[(2 * e.id) | 1].next_out;
+      } else {
+        nodes[arcs[2 * e.id].target].first_out =
+          arcs[(2 * e.id) | 1].next_out;
+      }
+
+      if (nodes[n.id].first_out != -1) {
+        arcs[nodes[n.id].first_out].prev_out = ((2 * e.id) | 1);
+      }
+      arcs[2 * e.id].target = n.id;
+      arcs[(2 * e.id) | 1].prev_out = -1;
+      arcs[(2 * e.id) | 1].next_out = nodes[n.id].first_out;
+      nodes[n.id].first_out = ((2 * e.id) | 1);
     }
 
@@ -1210,5 +1210,5 @@
     ListGraph() {}
 
-    typedef Parent::IncEdgeIt IncEdgeIt;
+    typedef Parent::OutArcIt IncEdgeIt;
 
     /// \brief Add a new node to the graph.
@@ -1345,5 +1345,5 @@
     /// to build the graph.
     /// \sa reserveEdge()
-    void reserveNode(int n) { _nodes.reserve(n); };
+    void reserveNode(int n) { nodes.reserve(n); };
 
     /// Reserve memory for edges.
@@ -1355,5 +1355,5 @@
     /// to build the graph.
     /// \sa reserveNode()
-    void reserveEdge(int m) { _arcs.reserve(2 * m); };
+    void reserveEdge(int m) { arcs.reserve(2 * m); };
 
     /// \brief Class to make a snapshot of the graph and restore
@@ -1395,5 +1395,5 @@
         }
         virtual void add(const std::vector<Node>& nodes) {
-          for (int i = nodes.size() - 1; i >= 0; --i) {
+          for (int i = nodes.size() - 1; i >= 0; ++i) {
             snapshot.addNode(nodes[i]);
           }
@@ -1445,5 +1445,5 @@
         }
         virtual void add(const std::vector<Edge>& edges) {
-          for (int i = edges.size() - 1; i >= 0; --i) {
+          for (int i = edges.size() - 1; i >= 0; ++i) {
             snapshot.addEdge(edges[i]);
           }
@@ -1618,5 +1618,5 @@
     };
 
-    std::vector<NodeT> _nodes;
+    std::vector<NodeT> nodes;
 
     int first_node, first_red, first_blue;
@@ -1625,5 +1625,5 @@
     int first_free_red, first_free_blue;
 
-    std::vector<ArcT> _arcs;
+    std::vector<ArcT> arcs;
 
     int first_free_arc;
@@ -1707,31 +1707,31 @@
 
     ListBpGraphBase()
-      : _nodes(), first_node(-1),
+      : nodes(), first_node(-1),
         first_red(-1), first_blue(-1),
         max_red(-1), max_blue(-1),
         first_free_red(-1), first_free_blue(-1),
-        _arcs(), first_free_arc(-1) {}
-
-
-    bool red(Node n) const { return _nodes[n.id].red; }
-    bool blue(Node n) const { return !_nodes[n.id].red; }
+        arcs(), first_free_arc(-1) {}
+
+
+    bool red(Node n) const { return nodes[n.id].red; }
+    bool blue(Node n) const { return !nodes[n.id].red; }
 
     static RedNode asRedNodeUnsafe(Node n) { return RedNode(n.id); }
     static BlueNode asBlueNodeUnsafe(Node n) { return BlueNode(n.id); }
 
-    int maxNodeId() const { return _nodes.size()-1; }
+    int maxNodeId() const { return nodes.size()-1; }
     int maxRedId() const { return max_red; }
     int maxBlueId() const { return max_blue; }
-    int maxEdgeId() const { return _arcs.size() / 2 - 1; }
-    int maxArcId() const { return _arcs.size()-1; }
-
-    Node source(Arc e) const { return Node(_arcs[e.id ^ 1].target); }
-    Node target(Arc e) const { return Node(_arcs[e.id].target); }
+    int maxEdgeId() const { return arcs.size() / 2 - 1; }
+    int maxArcId() const { return arcs.size()-1; }
+
+    Node source(Arc e) const { return Node(arcs[e.id ^ 1].target); }
+    Node target(Arc e) const { return Node(arcs[e.id].target); }
 
     RedNode redNode(Edge e) const {
-      return RedNode(_arcs[2 * e.id].target);
+      return RedNode(arcs[2 * e.id].target);
     }
     BlueNode blueNode(Edge e) const {
-      return BlueNode(_arcs[2 * e.id + 1].target);
+      return BlueNode(arcs[2 * e.id + 1].target);
     }
 
@@ -1749,5 +1749,5 @@
 
     void next(Node& node) const {
-      node.id = _nodes[node.id].next;
+      node.id = nodes[node.id].next;
     }
 
@@ -1757,5 +1757,5 @@
 
     void next(RedNode& node) const {
-      node.id = _nodes[node.id].partition_next;
+      node.id = nodes[node.id].partition_next;
     }
 
@@ -1765,24 +1765,24 @@
 
     void next(BlueNode& node) const {
-      node.id = _nodes[node.id].partition_next;
+      node.id = nodes[node.id].partition_next;
     }
 
     void first(Arc& e) const {
       int n = first_node;
-      while (n != -1 && _nodes[n].first_out == -1) {
-        n = _nodes[n].next;
-      }
-      e.id = (n == -1) ? -1 : _nodes[n].first_out;
+      while (n != -1 && nodes[n].first_out == -1) {
+        n = nodes[n].next;
+      }
+      e.id = (n == -1) ? -1 : nodes[n].first_out;
     }
 
     void next(Arc& e) const {
-      if (_arcs[e.id].next_out != -1) {
-        e.id = _arcs[e.id].next_out;
-      } else {
-        int n = _nodes[_arcs[e.id ^ 1].target].next;
-        while(n != -1 && _nodes[n].first_out == -1) {
-          n = _nodes[n].next;
-        }
-        e.id = (n == -1) ? -1 : _nodes[n].first_out;
+      if (arcs[e.id].next_out != -1) {
+        e.id = arcs[e.id].next_out;
+      } else {
+        int n = nodes[arcs[e.id ^ 1].target].next;
+        while(n != -1 && nodes[n].first_out == -1) {
+          n = nodes[n].next;
+        }
+        e.id = (n == -1) ? -1 : nodes[n].first_out;
       }
     }
@@ -1791,7 +1791,7 @@
       int n = first_node;
       while (n != -1) {
-        e.id = _nodes[n].first_out;
+        e.id = nodes[n].first_out;
         while ((e.id & 1) != 1) {
-          e.id = _arcs[e.id].next_out;
+          e.id = arcs[e.id].next_out;
         }
         if (e.id != -1) {
@@ -1799,5 +1799,5 @@
           return;
         }
-        n = _nodes[n].next;
+        n = nodes[n].next;
       }
       e.id = -1;
@@ -1805,8 +1805,8 @@
 
     void next(Edge& e) const {
-      int n = _arcs[e.id * 2].target;
-      e.id = _arcs[(e.id * 2) | 1].next_out;
+      int n = arcs[e.id * 2].target;
+      e.id = arcs[(e.id * 2) | 1].next_out;
       while ((e.id & 1) != 1) {
-        e.id = _arcs[e.id].next_out;
+        e.id = arcs[e.id].next_out;
       }
       if (e.id != -1) {
@@ -1814,9 +1814,9 @@
         return;
       }
-      n = _nodes[n].next;
+      n = nodes[n].next;
       while (n != -1) {
-        e.id = _nodes[n].first_out;
+        e.id = nodes[n].first_out;
         while ((e.id & 1) != 1) {
-          e.id = _arcs[e.id].next_out;
+          e.id = arcs[e.id].next_out;
         }
         if (e.id != -1) {
@@ -1824,5 +1824,5 @@
           return;
         }
-        n = _nodes[n].next;
+        n = nodes[n].next;
       }
       e.id = -1;
@@ -1830,21 +1830,21 @@
 
     void firstOut(Arc &e, const Node& v) const {
-      e.id = _nodes[v.id].first_out;
+      e.id = nodes[v.id].first_out;
     }
     void nextOut(Arc &e) const {
-      e.id = _arcs[e.id].next_out;
+      e.id = arcs[e.id].next_out;
     }
 
     void firstIn(Arc &e, const Node& v) const {
-      e.id = ((_nodes[v.id].first_out) ^ 1);
+      e.id = ((nodes[v.id].first_out) ^ 1);
       if (e.id == -2) e.id = -1;
     }
     void nextIn(Arc &e) const {
-      e.id = ((_arcs[e.id ^ 1].next_out) ^ 1);
+      e.id = ((arcs[e.id ^ 1].next_out) ^ 1);
       if (e.id == -2) e.id = -1;
     }
 
     void firstInc(Edge &e, bool& d, const Node& v) const {
-      int a = _nodes[v.id].first_out;
+      int a = nodes[v.id].first_out;
       if (a != -1 ) {
         e.id = a / 2;
@@ -1856,5 +1856,5 @@
     }
     void nextInc(Edge &e, bool& d) const {
-      int a = (_arcs[(e.id * 2) | (d ? 1 : 0)].next_out);
+      int a = (arcs[(e.id * 2) | (d ? 1 : 0)].next_out);
       if (a != -1 ) {
         e.id = a / 2;
@@ -1867,6 +1867,6 @@
 
     static int id(Node v) { return v.id; }
-    int id(RedNode v) const { return _nodes[v.id].partition_index; }
-    int id(BlueNode v) const { return _nodes[v.id].partition_index; }
+    int id(RedNode v) const { return nodes[v.id].partition_index; }
+    int id(BlueNode v) const { return nodes[v.id].partition_index; }
     static int id(Arc e) { return e.id; }
     static int id(Edge e) { return e.id; }
@@ -1877,16 +1877,16 @@
 
     bool valid(Node n) const {
-      return n.id >= 0 && n.id < static_cast<int>(_nodes.size()) &&
-        _nodes[n.id].prev != -2;
+      return n.id >= 0 && n.id < static_cast<int>(nodes.size()) &&
+        nodes[n.id].prev != -2;
     }
 
     bool valid(Arc a) const {
-      return a.id >= 0 && a.id < static_cast<int>(_arcs.size()) &&
-        _arcs[a.id].prev_out != -2;
+      return a.id >= 0 && a.id < static_cast<int>(arcs.size()) &&
+        arcs[a.id].prev_out != -2;
     }
 
     bool valid(Edge e) const {
-      return e.id >= 0 && 2 * e.id < static_cast<int>(_arcs.size()) &&
-        _arcs[2 * e.id].prev_out != -2;
+      return e.id >= 0 && 2 * e.id < static_cast<int>(arcs.size()) &&
+        arcs[2 * e.id].prev_out != -2;
     }
 
@@ -1895,24 +1895,24 @@
 
       if(first_free_red==-1) {
-        n = _nodes.size();
-        _nodes.push_back(NodeT());
-        _nodes[n].partition_index = ++max_red;
-        _nodes[n].red = true;
+        n = nodes.size();
+        nodes.push_back(NodeT());
+        nodes[n].partition_index = ++max_red;
+        nodes[n].red = true;
       } else {
         n = first_free_red;
-        first_free_red = _nodes[n].next;
-      }
-
-      _nodes[n].next = first_node;
-      if (first_node != -1) _nodes[first_node].prev = n;
+        first_free_red = nodes[n].next;
+      }
+
+      nodes[n].next = first_node;
+      if (first_node != -1) nodes[first_node].prev = n;
       first_node = n;
-      _nodes[n].prev = -1;
-
-      _nodes[n].partition_next = first_red;
-      if (first_red != -1) _nodes[first_red].partition_prev = n;
+      nodes[n].prev = -1;
+
+      nodes[n].partition_next = first_red;
+      if (first_red != -1) nodes[first_red].partition_prev = n;
       first_red = n;
-      _nodes[n].partition_prev = -1;
-
-      _nodes[n].first_out = -1;
+      nodes[n].partition_prev = -1;
+
+      nodes[n].first_out = -1;
 
       return RedNode(n);
@@ -1923,24 +1923,24 @@
 
       if(first_free_blue==-1) {
-        n = _nodes.size();
-        _nodes.push_back(NodeT());
-        _nodes[n].partition_index = ++max_blue;
-        _nodes[n].red = false;
+        n = nodes.size();
+        nodes.push_back(NodeT());
+        nodes[n].partition_index = ++max_blue;
+        nodes[n].red = false;
       } else {
         n = first_free_blue;
-        first_free_blue = _nodes[n].next;
-      }
-
-      _nodes[n].next = first_node;
-      if (first_node != -1) _nodes[first_node].prev = n;
+        first_free_blue = nodes[n].next;
+      }
+
+      nodes[n].next = first_node;
+      if (first_node != -1) nodes[first_node].prev = n;
       first_node = n;
-      _nodes[n].prev = -1;
-
-      _nodes[n].partition_next = first_blue;
-      if (first_blue != -1) _nodes[first_blue].partition_prev = n;
+      nodes[n].prev = -1;
+
+      nodes[n].partition_next = first_blue;
+      if (first_blue != -1) nodes[first_blue].partition_prev = n;
       first_blue = n;
-      _nodes[n].partition_prev = -1;
-
-      _nodes[n].first_out = -1;
+      nodes[n].partition_prev = -1;
+
+      nodes[n].first_out = -1;
 
       return BlueNode(n);
@@ -1951,28 +1951,28 @@
 
       if (first_free_arc == -1) {
-        n = _arcs.size();
-        _arcs.push_back(ArcT());
-        _arcs.push_back(ArcT());
+        n = arcs.size();
+        arcs.push_back(ArcT());
+        arcs.push_back(ArcT());
       } else {
         n = first_free_arc;
-        first_free_arc = _arcs[n].next_out;
-      }
-
-      _arcs[n].target = u.id;
-      _arcs[n | 1].target = v.id;
-
-      _arcs[n].next_out = _nodes[v.id].first_out;
-      if (_nodes[v.id].first_out != -1) {
-        _arcs[_nodes[v.id].first_out].prev_out = n;
-      }
-      _arcs[n].prev_out = -1;
-      _nodes[v.id].first_out = n;
-
-      _arcs[n | 1].next_out = _nodes[u.id].first_out;
-      if (_nodes[u.id].first_out != -1) {
-        _arcs[_nodes[u.id].first_out].prev_out = (n | 1);
-      }
-      _arcs[n | 1].prev_out = -1;
-      _nodes[u.id].first_out = (n | 1);
+        first_free_arc = arcs[n].next_out;
+      }
+
+      arcs[n].target = u.id;
+      arcs[n | 1].target = v.id;
+
+      arcs[n].next_out = nodes[v.id].first_out;
+      if (nodes[v.id].first_out != -1) {
+        arcs[nodes[v.id].first_out].prev_out = n;
+      }
+      arcs[n].prev_out = -1;
+      nodes[v.id].first_out = n;
+
+      arcs[n | 1].next_out = nodes[u.id].first_out;
+      if (nodes[u.id].first_out != -1) {
+        arcs[nodes[u.id].first_out].prev_out = (n | 1);
+      }
+      arcs[n | 1].prev_out = -1;
+      nodes[u.id].first_out = (n | 1);
 
       return Edge(n / 2);
@@ -1982,36 +1982,36 @@
       int n = node.id;
 
-      if(_nodes[n].next != -1) {
-        _nodes[_nodes[n].next].prev = _nodes[n].prev;
-      }
-
-      if(_nodes[n].prev != -1) {
-        _nodes[_nodes[n].prev].next = _nodes[n].next;
-      } else {
-        first_node = _nodes[n].next;
-      }
-
-      if (_nodes[n].partition_next != -1) {
-        _nodes[_nodes[n].partition_next].partition_prev = _nodes[n].partition_prev;
-      }
-
-      if (_nodes[n].partition_prev != -1) {
-        _nodes[_nodes[n].partition_prev].partition_next = _nodes[n].partition_next;
-      } else {
-        if (_nodes[n].red) {
-          first_red = _nodes[n].partition_next;
+      if(nodes[n].next != -1) {
+        nodes[nodes[n].next].prev = nodes[n].prev;
+      }
+
+      if(nodes[n].prev != -1) {
+        nodes[nodes[n].prev].next = nodes[n].next;
+      } else {
+        first_node = nodes[n].next;
+      }
+
+      if (nodes[n].partition_next != -1) {
+        nodes[nodes[n].partition_next].partition_prev = nodes[n].partition_prev;
+      }
+
+      if (nodes[n].partition_prev != -1) {
+        nodes[nodes[n].partition_prev].partition_next = nodes[n].partition_next;
+      } else {
+        if (nodes[n].red) {
+          first_red = nodes[n].partition_next;
         } else {
-          first_blue = _nodes[n].partition_next;
-        }
-      }
-
-      if (_nodes[n].red) {
-        _nodes[n].next = first_free_red;
+          first_blue = nodes[n].partition_next;
+        }
+      }
+
+      if (nodes[n].red) {
+        nodes[n].next = first_free_red;
         first_free_red = n;
       } else {
-        _nodes[n].next = first_free_blue;
+        nodes[n].next = first_free_blue;
         first_free_blue = n;
       }
-      _nodes[n].prev = -2;
+      nodes[n].prev = -2;
     }
 
@@ -2019,34 +2019,34 @@
       int n = edge.id * 2;
 
-      if (_arcs[n].next_out != -1) {
-        _arcs[_arcs[n].next_out].prev_out = _arcs[n].prev_out;
-      }
-
-      if (_arcs[n].prev_out != -1) {
-        _arcs[_arcs[n].prev_out].next_out = _arcs[n].next_out;
-      } else {
-        _nodes[_arcs[n | 1].target].first_out = _arcs[n].next_out;
-      }
-
-      if (_arcs[n | 1].next_out != -1) {
-        _arcs[_arcs[n | 1].next_out].prev_out = _arcs[n | 1].prev_out;
-      }
-
-      if (_arcs[n | 1].prev_out != -1) {
-        _arcs[_arcs[n | 1].prev_out].next_out = _arcs[n | 1].next_out;
-      } else {
-        _nodes[_arcs[n].target].first_out = _arcs[n | 1].next_out;
-      }
-
-      _arcs[n].next_out = first_free_arc;
+      if (arcs[n].next_out != -1) {
+        arcs[arcs[n].next_out].prev_out = arcs[n].prev_out;
+      }
+
+      if (arcs[n].prev_out != -1) {
+        arcs[arcs[n].prev_out].next_out = arcs[n].next_out;
+      } else {
+        nodes[arcs[n | 1].target].first_out = arcs[n].next_out;
+      }
+
+      if (arcs[n | 1].next_out != -1) {
+        arcs[arcs[n | 1].next_out].prev_out = arcs[n | 1].prev_out;
+      }
+
+      if (arcs[n | 1].prev_out != -1) {
+        arcs[arcs[n | 1].prev_out].next_out = arcs[n | 1].next_out;
+      } else {
+        nodes[arcs[n].target].first_out = arcs[n | 1].next_out;
+      }
+
+      arcs[n].next_out = first_free_arc;
       first_free_arc = n;
-      _arcs[n].prev_out = -2;
-      _arcs[n | 1].prev_out = -2;
+      arcs[n].prev_out = -2;
+      arcs[n | 1].prev_out = -2;
 
     }
 
     void clear() {
-      _arcs.clear();
-      _nodes.clear();
+      arcs.clear();
+      nodes.clear();
       first_node = first_free_arc = first_red = first_blue =
         max_red = max_blue = first_free_red = first_free_blue = -1;
@@ -2056,44 +2056,44 @@
 
     void changeRed(Edge e, RedNode n) {
-      if(_arcs[(2 * e.id) | 1].next_out != -1) {
-        _arcs[_arcs[(2 * e.id) | 1].next_out].prev_out =
-          _arcs[(2 * e.id) | 1].prev_out;
-      }
-      if(_arcs[(2 * e.id) | 1].prev_out != -1) {
-        _arcs[_arcs[(2 * e.id) | 1].prev_out].next_out =
-          _arcs[(2 * e.id) | 1].next_out;
-      } else {
-        _nodes[_arcs[2 * e.id].target].first_out =
-          _arcs[(2 * e.id) | 1].next_out;
-      }
-
-      if (_nodes[n.id].first_out != -1) {
-        _arcs[_nodes[n.id].first_out].prev_out = ((2 * e.id) | 1);
-      }
-      _arcs[2 * e.id].target = n.id;
-      _arcs[(2 * e.id) | 1].prev_out = -1;
-      _arcs[(2 * e.id) | 1].next_out = _nodes[n.id].first_out;
-      _nodes[n.id].first_out = ((2 * e.id) | 1);
+      if(arcs[(2 * e.id) | 1].next_out != -1) {
+        arcs[arcs[(2 * e.id) | 1].next_out].prev_out =
+          arcs[(2 * e.id) | 1].prev_out;
+      }
+      if(arcs[(2 * e.id) | 1].prev_out != -1) {
+        arcs[arcs[(2 * e.id) | 1].prev_out].next_out =
+          arcs[(2 * e.id) | 1].next_out;
+      } else {
+        nodes[arcs[2 * e.id].target].first_out =
+          arcs[(2 * e.id) | 1].next_out;
+      }
+
+      if (nodes[n.id].first_out != -1) {
+        arcs[nodes[n.id].first_out].prev_out = ((2 * e.id) | 1);
+      }
+      arcs[2 * e.id].target = n.id;
+      arcs[(2 * e.id) | 1].prev_out = -1;
+      arcs[(2 * e.id) | 1].next_out = nodes[n.id].first_out;
+      nodes[n.id].first_out = ((2 * e.id) | 1);
     }
 
     void changeBlue(Edge e, BlueNode n) {
-       if(_arcs[2 * e.id].next_out != -1) {
-        _arcs[_arcs[2 * e.id].next_out].prev_out = _arcs[2 * e.id].prev_out;
-      }
-      if(_arcs[2 * e.id].prev_out != -1) {
-        _arcs[_arcs[2 * e.id].prev_out].next_out =
-          _arcs[2 * e.id].next_out;
-      } else {
-        _nodes[_arcs[(2 * e.id) | 1].target].first_out =
-          _arcs[2 * e.id].next_out;
-      }
-
-      if (_nodes[n.id].first_out != -1) {
-        _arcs[_nodes[n.id].first_out].prev_out = 2 * e.id;
-      }
-      _arcs[(2 * e.id) | 1].target = n.id;
-      _arcs[2 * e.id].prev_out = -1;
-      _arcs[2 * e.id].next_out = _nodes[n.id].first_out;
-      _nodes[n.id].first_out = 2 * e.id;
+       if(arcs[2 * e.id].next_out != -1) {
+        arcs[arcs[2 * e.id].next_out].prev_out = arcs[2 * e.id].prev_out;
+      }
+      if(arcs[2 * e.id].prev_out != -1) {
+        arcs[arcs[2 * e.id].prev_out].next_out =
+          arcs[2 * e.id].next_out;
+      } else {
+        nodes[arcs[(2 * e.id) | 1].target].first_out =
+          arcs[2 * e.id].next_out;
+      }
+
+      if (nodes[n.id].first_out != -1) {
+        arcs[nodes[n.id].first_out].prev_out = 2 * e.id;
+      }
+      arcs[(2 * e.id) | 1].target = n.id;
+      arcs[2 * e.id].prev_out = -1;
+      arcs[2 * e.id].next_out = nodes[n.id].first_out;
+      nodes[n.id].first_out = 2 * e.id;
     }
 
@@ -2137,5 +2137,5 @@
     ListBpGraph() {}
 
-    typedef Parent::IncEdgeIt IncEdgeIt;
+    typedef Parent::OutArcIt IncEdgeIt;
 
     /// \brief Add a new red node to the graph.
@@ -2250,5 +2250,5 @@
     /// to build the graph.
     /// \sa reserveEdge()
-    void reserveNode(int n) { _nodes.reserve(n); };
+    void reserveNode(int n) { nodes.reserve(n); };
 
     /// Reserve memory for edges.
@@ -2260,5 +2260,5 @@
     /// to build the graph.
     /// \sa reserveNode()
-    void reserveEdge(int m) { _arcs.reserve(2 * m); };
+    void reserveEdge(int m) { arcs.reserve(2 * m); };
 
     /// \brief Class to make a snapshot of the graph and restore
@@ -2300,5 +2300,5 @@
         }
         virtual void add(const std::vector<Node>& nodes) {
-          for (int i = nodes.size() - 1; i >= 0; --i) {
+          for (int i = nodes.size() - 1; i >= 0; ++i) {
             snapshot.addNode(nodes[i]);
           }
@@ -2350,5 +2350,5 @@
         }
         virtual void add(const std::vector<Edge>& edges) {
-          for (int i = edges.size() - 1; i >= 0; --i) {
+          for (int i = edges.size() - 1; i >= 0; ++i) {
             snapshot.addEdge(edges[i]);
           }
Index: lemon/lp.h
===================================================================
--- lemon/lp.h	(revision 1340)
+++ lemon/lp.h	(revision 1270)
@@ -23,18 +23,12 @@
 
 
-#if LEMON_DEFAULT_LP == LEMON_GLPK_ || LEMON_DEFAULT_MIP == LEMON_GLPK_
+#ifdef LEMON_HAVE_GLPK
 #include <lemon/glpk.h>
-#endif
-#if LEMON_DEFAULT_LP == LEMON_CPLEX_ || LEMON_DEFAULT_MIP == LEMON_CPLEX_
+#elif LEMON_HAVE_CPLEX
 #include <lemon/cplex.h>
-#endif
-#if LEMON_DEFAULT_LP == LEMON_SOPLEX_
+#elif LEMON_HAVE_SOPLEX
 #include <lemon/soplex.h>
-#endif
-#if LEMON_DEFAULT_LP == LEMON_CLP_
+#elif LEMON_HAVE_CLP
 #include <lemon/clp.h>
-#endif
-#if LEMON_DEFAULT_MIP == LEMON_CBC_
-#include <lemon/cbc.h>
 #endif
 
@@ -50,6 +44,6 @@
   ///\ingroup lp_group
   ///
-  ///Currently, the possible values are \c LEMON_GLPK_, \c LEMON_CPLEX_,
-  ///\c LEMON_SOPLEX_ or \c LEMON_CLP_
+  ///Currently, the possible values are \c GLPK, \c CPLEX,
+  ///\c SOPLEX or \c CLP
 #define LEMON_DEFAULT_LP SOLVER
   ///The default LP solver
@@ -66,6 +60,5 @@
   ///\ingroup lp_group
   ///
-  ///Currently, the possible values are \c LEMON_GLPK_, \c LEMON_CPLEX_
-  ///or \c LEMON_CBC_
+  ///Currently, the possible values are \c GLPK, \c CPLEX or \c CBC
 #define LEMON_DEFAULT_MIP SOLVER
   ///The default MIP solver.
@@ -77,18 +70,18 @@
   typedef GlpkMip Mip;
 #else
-#if LEMON_DEFAULT_LP == LEMON_GLPK_
+#if LEMON_DEFAULT_LP == GLPK
   typedef GlpkLp Lp;
-#elif LEMON_DEFAULT_LP == LEMON_CPLEX_
+#elif LEMON_DEFAULT_LP == CPLEX
   typedef CplexLp Lp;
-#elif LEMON_DEFAULT_LP == LEMON_SOPLEX_
+#elif LEMON_DEFAULT_LP == SOPLEX
   typedef SoplexLp Lp;
-#elif LEMON_DEFAULT_LP == LEMON_CLP_
+#elif LEMON_DEFAULT_LP == CLP
   typedef ClpLp Lp;
 #endif
-#if LEMON_DEFAULT_MIP == LEMON_GLPK_
-  typedef GlpkMip Mip;
-#elif LEMON_DEFAULT_MIP == LEMON_CPLEX_
+#if LEMON_DEFAULT_MIP == GLPK
+  typedef GlpkLp Mip;
+#elif LEMON_DEFAULT_MIP == CPLEX
   typedef CplexMip Mip;
-#elif LEMON_DEFAULT_MIP == LEMON_CBC_
+#elif LEMON_DEFAULT_MIP == CBC
   typedef CbcMip Mip;
 #endif
Index: lemon/lp_base.h
===================================================================
--- lemon/lp_base.h	(revision 1353)
+++ lemon/lp_base.h	(revision 1270)
@@ -32,6 +32,4 @@
 #include<lemon/bits/solver_bits.h>
 
-#include<lemon/bits/stl_iterators.h>
-
 ///\file
 ///\brief The interface of the LP solver interface.
@@ -48,6 +46,6 @@
   protected:
 
-    _solver_bits::VarIndex _rows;
-    _solver_bits::VarIndex _cols;
+    _solver_bits::VarIndex rows;
+    _solver_bits::VarIndex cols;
 
   public:
@@ -169,5 +167,5 @@
       ColIt(const LpBase &solver) : _solver(&solver)
       {
-        _solver->_cols.firstItem(_id);
+        _solver->cols.firstItem(_id);
       }
       /// Invalid constructor \& conversion
@@ -182,24 +180,8 @@
       ColIt &operator++()
       {
-        _solver->_cols.nextItem(_id);
+        _solver->cols.nextItem(_id);
         return *this;
       }
     };
-
-    /// \brief Gets the collection of the columns of the LP problem.
-    ///
-    /// This function can be used for iterating on
-    /// the columns of the LP problem. It returns a wrapped ColIt, which looks
-    /// like an STL container (by having begin() and end())
-    /// which you can use in range-based for loops, STL algorithms, etc.
-    /// For example you can write:
-    ///\code
-    /// for(auto c: lp.cols())
-    ///   doSomething(c);
-    ///\endcode
-    LemonRangeWrapper1<ColIt, LpBase> cols() {
-      return LemonRangeWrapper1<ColIt, LpBase>(*this);
-    }
-
 
     /// \brief Returns the ID of the column.
@@ -280,5 +262,5 @@
       RowIt(const LpBase &solver) : _solver(&solver)
       {
-        _solver->_rows.firstItem(_id);
+        _solver->rows.firstItem(_id);
       }
       /// Invalid constructor \& conversion
@@ -293,24 +275,8 @@
       RowIt &operator++()
       {
-        _solver->_rows.nextItem(_id);
+        _solver->rows.nextItem(_id);
         return *this;
       }
     };
-    
-    /// \brief Gets the collection of the rows of the LP problem.
-    ///
-    /// This function can be used for iterating on
-    /// the rows of the LP problem. It returns a wrapped RowIt, which looks
-    /// like an STL container (by having begin() and end())
-    /// which you can use in range-based for loops, STL algorithms, etc.
-    /// For example you can write:
-    ///\code
-    /// for(auto c: lp.rows())
-    ///   doSomething(c);
-    ///\endcode
-    LemonRangeWrapper1<RowIt, LpBase> rows() {
-      return LemonRangeWrapper1<RowIt, LpBase>(*this);
-    }
-    
 
     /// \brief Returns the ID of the row.
@@ -660,5 +626,5 @@
     ///This data structure represents a column of the matrix,
     ///thas is it strores a linear expression of the dual variables
-    ///(\ref LpBase::Row "Row"s).
+    ///(\ref Row "Row"s).
     ///
     ///There are several ways to access and modify the contents of this
@@ -677,5 +643,5 @@
     ///(This code computes the sum of all coefficients).
     ///- Numbers (<tt>double</tt>'s)
-    ///and variables (\ref LpBase::Row "Row"s) directly convert to an
+    ///and variables (\ref Row "Row"s) directly convert to an
     ///\ref DualExpr and the usual linear operations are defined, so
     ///\code
@@ -969,9 +935,9 @@
     //Abstract virtual functions
 
-    virtual int _addColId(int col) { return _cols.addIndex(col); }
-    virtual int _addRowId(int row) { return _rows.addIndex(row); }
-
-    virtual void _eraseColId(int col) { _cols.eraseIndex(col); }
-    virtual void _eraseRowId(int row) { _rows.eraseIndex(row); }
+    virtual int _addColId(int col) { return cols.addIndex(col); }
+    virtual int _addRowId(int row) { return rows.addIndex(row); }
+
+    virtual void _eraseColId(int col) { cols.eraseIndex(col); }
+    virtual void _eraseRowId(int row) { rows.eraseIndex(row); }
 
     virtual int _addCol() = 0;
@@ -1038,5 +1004,5 @@
     Value obj_const_comp;
 
-    LpBase() : _rows(), _cols(), obj_const_comp(0) {}
+    LpBase() : rows(), cols(), obj_const_comp(0) {}
 
   public:
@@ -1150,6 +1116,6 @@
     void col(Col c, const DualExpr &e) {
       e.simplify();
-      _setColCoeffs(_cols(id(c)), ExprIterator(e.comps.begin(), _rows),
-                    ExprIterator(e.comps.end(), _rows));
+      _setColCoeffs(cols(id(c)), ExprIterator(e.comps.begin(), rows),
+                    ExprIterator(e.comps.end(), rows));
     }
 
@@ -1160,5 +1126,5 @@
     DualExpr col(Col c) const {
       DualExpr e;
-      _getColCoeffs(_cols(id(c)), InsertIterator(e.comps, _rows));
+      _getColCoeffs(cols(id(c)), InsertIterator(e.comps, rows));
       return e;
     }
@@ -1189,5 +1155,5 @@
     ///\param t can be
     ///- a standard STL compatible iterable container with
-    ///\ref LpBase::Row "Row" as its \c values_type like
+    ///\ref Row as its \c values_type like
     ///\code
     ///std::vector<LpBase::Row>
@@ -1195,5 +1161,5 @@
     ///\endcode
     ///- a standard STL compatible iterable container with
-    ///\ref LpBase::Row "Row" as its \c mapped_type like
+    ///\ref Row as its \c mapped_type like
     ///\code
     ///std::map<AnyType,LpBase::Row>
@@ -1247,8 +1213,8 @@
     void row(Row r, Value l, const Expr &e, Value u) {
       e.simplify();
-      _setRowCoeffs(_rows(id(r)), ExprIterator(e.comps.begin(), _cols),
-                    ExprIterator(e.comps.end(), _cols));
-      _setRowLowerBound(_rows(id(r)),l - *e);
-      _setRowUpperBound(_rows(id(r)),u - *e);
+      _setRowCoeffs(rows(id(r)), ExprIterator(e.comps.begin(), cols),
+                    ExprIterator(e.comps.end(), cols));
+      _setRowLowerBound(rows(id(r)),l - *e);
+      _setRowUpperBound(rows(id(r)),u - *e);
     }
 
@@ -1269,5 +1235,5 @@
     Expr row(Row r) const {
       Expr e;
-      _getRowCoeffs(_rows(id(r)), InsertIterator(e.comps, _cols));
+      _getRowCoeffs(rows(id(r)), InsertIterator(e.comps, cols));
       return e;
     }
@@ -1282,6 +1248,6 @@
       Row r;
       e.simplify();
-      r._id = _addRowId(_addRow(l - *e, ExprIterator(e.comps.begin(), _cols),
-                                ExprIterator(e.comps.end(), _cols), u - *e));
+      r._id = _addRowId(_addRow(l - *e, ExprIterator(e.comps.begin(), cols),
+                                ExprIterator(e.comps.end(), cols), u - *e));
       return r;
     }
@@ -1295,6 +1261,6 @@
       c.expr().simplify();
       r._id = _addRowId(_addRow(c.lowerBounded()?c.lowerBound()-*c.expr():-INF,
-                                ExprIterator(c.expr().comps.begin(), _cols),
-                                ExprIterator(c.expr().comps.end(), _cols),
+                                ExprIterator(c.expr().comps.begin(), cols),
+                                ExprIterator(c.expr().comps.end(), cols),
                                 c.upperBounded()?c.upperBound()-*c.expr():INF));
       return r;
@@ -1304,6 +1270,6 @@
     ///\param c is the column to be deleted
     void erase(Col c) {
-      _eraseCol(_cols(id(c)));
-      _eraseColId(_cols(id(c)));
+      _eraseCol(cols(id(c)));
+      _eraseColId(cols(id(c)));
     }
     ///Erase a row (i.e a constraint) from the LP
@@ -1311,6 +1277,6 @@
     ///\param r is the row to be deleted
     void erase(Row r) {
-      _eraseRow(_rows(id(r)));
-      _eraseRowId(_rows(id(r)));
+      _eraseRow(rows(id(r)));
+      _eraseRowId(rows(id(r)));
     }
 
@@ -1321,5 +1287,5 @@
     std::string colName(Col c) const {
       std::string name;
-      _getColName(_cols(id(c)), name);
+      _getColName(cols(id(c)), name);
       return name;
     }
@@ -1330,5 +1296,5 @@
     ///\param name The name to be given
     void colName(Col c, const std::string& name) {
-      _setColName(_cols(id(c)), name);
+      _setColName(cols(id(c)), name);
     }
 
@@ -1339,5 +1305,5 @@
     Col colByName(const std::string& name) const {
       int k = _colByName(name);
-      return k != -1 ? Col(_cols[k]) : Col(INVALID);
+      return k != -1 ? Col(cols[k]) : Col(INVALID);
     }
 
@@ -1348,5 +1314,5 @@
     std::string rowName(Row r) const {
       std::string name;
-      _getRowName(_rows(id(r)), name);
+      _getRowName(rows(id(r)), name);
       return name;
     }
@@ -1357,5 +1323,5 @@
     ///\param name The name to be given
     void rowName(Row r, const std::string& name) {
-      _setRowName(_rows(id(r)), name);
+      _setRowName(rows(id(r)), name);
     }
 
@@ -1366,5 +1332,5 @@
     Row rowByName(const std::string& name) const {
       int k = _rowByName(name);
-      return k != -1 ? Row(_rows[k]) : Row(INVALID);
+      return k != -1 ? Row(rows[k]) : Row(INVALID);
     }
 
@@ -1375,5 +1341,5 @@
     ///\param val is the new value of the coefficient
     void coeff(Row r, Col c, Value val) {
-      _setCoeff(_rows(id(r)),_cols(id(c)), val);
+      _setCoeff(rows(id(r)),cols(id(c)), val);
     }
 
@@ -1384,5 +1350,5 @@
     ///\return the corresponding coefficient
     Value coeff(Row r, Col c) const {
-      return _getCoeff(_rows(id(r)),_cols(id(c)));
+      return _getCoeff(rows(id(r)),cols(id(c)));
     }
 
@@ -1393,5 +1359,5 @@
     /// Value or -\ref INF.
     void colLowerBound(Col c, Value value) {
-      _setColLowerBound(_cols(id(c)),value);
+      _setColLowerBound(cols(id(c)),value);
     }
 
@@ -1402,5 +1368,5 @@
     ///\return The lower bound for column \c c
     Value colLowerBound(Col c) const {
-      return _getColLowerBound(_cols(id(c)));
+      return _getColLowerBound(cols(id(c)));
     }
 
@@ -1448,5 +1414,5 @@
     /// Value or \ref INF.
     void colUpperBound(Col c, Value value) {
-      _setColUpperBound(_cols(id(c)),value);
+      _setColUpperBound(cols(id(c)),value);
     };
 
@@ -1457,5 +1423,5 @@
     /// \return The upper bound for column \c c
     Value colUpperBound(Col c) const {
-      return _getColUpperBound(_cols(id(c)));
+      return _getColUpperBound(cols(id(c)));
     }
 
@@ -1504,6 +1470,6 @@
     /// Value, -\ref INF or \ref INF.
     void colBounds(Col c, Value lower, Value upper) {
-      _setColLowerBound(_cols(id(c)),lower);
-      _setColUpperBound(_cols(id(c)),upper);
+      _setColLowerBound(cols(id(c)),lower);
+      _setColUpperBound(cols(id(c)),upper);
     }
 
@@ -1550,5 +1516,5 @@
     /// Value or -\ref INF.
     void rowLowerBound(Row r, Value value) {
-      _setRowLowerBound(_rows(id(r)),value);
+      _setRowLowerBound(rows(id(r)),value);
     }
 
@@ -1559,5 +1525,5 @@
     ///\return The lower bound for row \c r
     Value rowLowerBound(Row r) const {
-      return _getRowLowerBound(_rows(id(r)));
+      return _getRowLowerBound(rows(id(r)));
     }
 
@@ -1568,5 +1534,5 @@
     /// Value or -\ref INF.
     void rowUpperBound(Row r, Value value) {
-      _setRowUpperBound(_rows(id(r)),value);
+      _setRowUpperBound(rows(id(r)),value);
     }
 
@@ -1577,12 +1543,12 @@
     ///\return The upper bound for row \c r
     Value rowUpperBound(Row r) const {
-      return _getRowUpperBound(_rows(id(r)));
+      return _getRowUpperBound(rows(id(r)));
     }
 
     ///Set an element of the objective function
-    void objCoeff(Col c, Value v) {_setObjCoeff(_cols(id(c)),v); };
+    void objCoeff(Col c, Value v) {_setObjCoeff(cols(id(c)),v); };
 
     ///Get an element of the objective function
-    Value objCoeff(Col c) const { return _getObjCoeff(_cols(id(c))); };
+    Value objCoeff(Col c) const { return _getObjCoeff(cols(id(c))); };
 
     ///Set the objective function
@@ -1591,6 +1557,6 @@
     ///
     void obj(const Expr& e) {
-      _setObjCoeffs(ExprIterator(e.comps.begin(), _cols),
-                    ExprIterator(e.comps.end(), _cols));
+      _setObjCoeffs(ExprIterator(e.comps.begin(), cols),
+                    ExprIterator(e.comps.end(), cols));
       obj_const_comp = *e;
     }
@@ -1602,5 +1568,5 @@
     Expr obj() const {
       Expr e;
-      _getObjCoeffs(InsertIterator(e.comps, _cols));
+      _getObjCoeffs(InsertIterator(e.comps, cols));
       *e = obj_const_comp;
       return e;
@@ -1621,5 +1587,5 @@
 
     ///Clear the problem
-    void clear() { _clear(); _rows.clear(); _cols.clear(); }
+    void clear() { _clear(); rows.clear(); cols.clear(); }
 
     /// Set the message level of the solver
@@ -1964,5 +1930,5 @@
     /// Return the primal value of the column.
     /// \pre The problem is solved.
-    Value primal(Col c) const { return _getPrimal(_cols(id(c))); }
+    Value primal(Col c) const { return _getPrimal(cols(id(c))); }
 
     /// Return the primal value of the expression
@@ -1991,5 +1957,5 @@
     /// \note Some solvers does not provide primal ray calculation
     /// functions.
-    Value primalRay(Col c) const { return _getPrimalRay(_cols(id(c))); }
+    Value primalRay(Col c) const { return _getPrimalRay(cols(id(c))); }
 
     /// Return the dual value of the row
@@ -1997,5 +1963,5 @@
     /// Return the dual value of the row.
     /// \pre The problem is solved.
-    Value dual(Row r) const { return _getDual(_rows(id(r))); }
+    Value dual(Row r) const { return _getDual(rows(id(r))); }
 
     /// Return the dual value of the dual expression
@@ -2025,15 +1991,15 @@
     /// \note Some solvers does not provide dual ray calculation
     /// functions.
-    Value dualRay(Row r) const { return _getDualRay(_rows(id(r))); }
+    Value dualRay(Row r) const { return _getDualRay(rows(id(r))); }
 
     /// Return the basis status of the column
 
     /// \see VarStatus
-    VarStatus colStatus(Col c) const { return _getColStatus(_cols(id(c))); }
+    VarStatus colStatus(Col c) const { return _getColStatus(cols(id(c))); }
 
     /// Return the basis status of the row
 
     /// \see VarStatus
-    VarStatus rowStatus(Row r) const { return _getRowStatus(_rows(id(r))); }
+    VarStatus rowStatus(Row r) const { return _getRowStatus(rows(id(r))); }
 
     ///The value of the objective function
@@ -2115,5 +2081,5 @@
     ///
     void colType(Col c, ColTypes col_type) {
-      _setColType(_cols(id(c)),col_type);
+      _setColType(cols(id(c)),col_type);
     }
 
@@ -2123,5 +2089,5 @@
     ///
     ColTypes colType(Col c) const {
-      return _getColType(_cols(id(c)));
+      return _getColType(cols(id(c)));
     }
     ///@}
@@ -2140,5 +2106,5 @@
     ///  Return the value of the row in the solution.
     /// \pre The problem is solved.
-    Value sol(Col c) const { return _getSol(_cols(id(c))); }
+    Value sol(Col c) const { return _getSol(cols(id(c))); }
 
     /// Return the value of the expression in the solution
Index: lemon/maps.h
===================================================================
--- lemon/maps.h	(revision 1336)
+++ lemon/maps.h	(revision 1270)
@@ -26,5 +26,4 @@
 
 #include <lemon/core.h>
-#include <lemon/bits/stl_iterators.h>
 
 ///\file
@@ -2583,14 +2582,4 @@
     };
 
-    /// \brief STL style iterator for the keys mapped to \c true.
-    ///
-    /// This is an STL style wrapper for \ref TrueIt.
-    /// It can be used in range-based for loops, STL algorithms, etc.
-    LemonRangeWrapper1<TrueIt, IterableBoolMap>
-    trueKeys() {
-      return LemonRangeWrapper1<TrueIt, IterableBoolMap>(*this);
-    }
-
-
     /// \brief Iterator for the keys mapped to \c false.
     ///
@@ -2631,14 +2620,4 @@
       const IterableBoolMap* _map;
     };
-
-    /// \brief STL style iterator for the keys mapped to \c false.
-    ///
-    /// This is an STL style wrapper for \ref FalseIt.
-    /// It can be used in range-based for loops, STL algorithms, etc.
-    LemonRangeWrapper1<FalseIt, IterableBoolMap>
-    falseKeys() {
-      return LemonRangeWrapper1<FalseIt, IterableBoolMap>(*this);
-    }
-
 
     /// \brief Iterator for the keys mapped to a given value.
@@ -2685,13 +2664,4 @@
       const IterableBoolMap* _map;
     };
-
-    /// \brief STL style iterator for the keys mapped to a given value.
-    ///
-    /// This is an STL style wrapper for \ref ItemIt.
-    /// It can be used in range-based for loops, STL algorithms, etc.
-    LemonRangeWrapper2<ItemIt, IterableBoolMap, bool>
-    items(bool value) {
-      return LemonRangeWrapper2<ItemIt, IterableBoolMap, bool>(*this, value);
-    }
 
   protected:
@@ -3036,14 +3006,4 @@
     };
 
-    /// \brief STL style iterator for the keys with the same value.
-    ///
-    /// This is an STL style wrapper for \ref ItemIt.
-    /// It can be used in range-based for loops, STL algorithms, etc.
-    LemonRangeWrapper2<ItemIt, IterableIntMap, int>
-    items(int value) {
-      return LemonRangeWrapper2<ItemIt, IterableIntMap, int>(*this, value);
-    }
-
-
   protected:
 
@@ -3289,14 +3249,4 @@
     };
 
-    /// \brief STL style iterator for the keys with the same value.
-    ///
-    /// This is an STL style wrapper for \ref ItemIt.
-    /// It can be used in range-based for loops, STL algorithms, etc.
-    LemonRangeWrapper2<ItemIt, IterableValueMap, V>
-    items(const V& value) {
-      return LemonRangeWrapper2<ItemIt, IterableValueMap, V>(*this, value);
-    }
-
-
   protected:
 
Index: lemon/math.h
===================================================================
--- lemon/math.h	(revision 1311)
+++ lemon/math.h	(revision 1270)
@@ -68,5 +68,5 @@
   ///Round a value to its closest integer
   inline double round(double r) {
-    return (r > 0.0) ? std::floor(r + 0.5) : std::ceil(r - 0.5);
+    return (r > 0.0) ? floor(r + 0.5) : ceil(r - 0.5);
   }
 
Index: lemon/max_cardinality_search.h
===================================================================
--- lemon/max_cardinality_search.h	(revision 1271)
+++ lemon/max_cardinality_search.h	(revision 1270)
@@ -165,6 +165,6 @@
     ///
     /// This function instantiates a \ref CardinalityMap.
-    /// \param digraph is the digraph, to which we would like to
-    /// define the \ref CardinalityMap
+    /// \param digraph is the digraph, to which we would like to define the \ref
+    /// CardinalityMap
     static CardinalityMap *createCardinalityMap(const Digraph &digraph) {
       return new CardinalityMap(digraph);
@@ -181,6 +181,5 @@
   /// Search algorithm. The maximum cardinality search first chooses any
   /// node of the digraph. Then every time it chooses one unprocessed node
-  /// with maximum cardinality, i.e the sum of capacities on out arcs
-  /// to the nodes
+  /// with maximum cardinality, i.e the sum of capacities on out arcs to the nodes
   /// which were previusly processed.
   /// If there is a cut in the digraph the algorithm should choose
Index: lemon/nearest_neighbor_tsp.h
===================================================================
--- lemon/nearest_neighbor_tsp.h	(revision 1294)
+++ lemon/nearest_neighbor_tsp.h	(revision 1270)
@@ -116,5 +116,5 @@
             for (IncEdgeIt e(_gr, n1); e != INVALID; ++e) {
               if (!used[_gr.runningNode(e)] &&
-                  (min_edge1 == INVALID || _cost[e] < _cost[min_edge1])) {
+                  (_cost[e] < _cost[min_edge1] || min_edge1 == INVALID)) {
                 min_edge1 = e;
               }
@@ -125,5 +125,5 @@
             for (IncEdgeIt e(_gr, n2); e != INVALID; ++e) {
               if (!used[_gr.runningNode(e)] &&
-                  (min_edge2 == INVALID||_cost[e] < _cost[min_edge2])) {
+                  (_cost[e] < _cost[min_edge2] || min_edge2 == INVALID)) {
                 min_edge2 = e;
               }
Index: lemon/network_simplex.h
===================================================================
--- lemon/network_simplex.h	(revision 1318)
+++ lemon/network_simplex.h	(revision 1270)
@@ -199,5 +199,5 @@
 
     // Parameters of the problem
-    bool _has_lower;
+    bool _have_lower;
     SupplyType _stype;
     Value _sum_supply;
@@ -683,5 +683,5 @@
     template <typename LowerMap>
     NetworkSimplex& lowerMap(const LowerMap& map) {
-      _has_lower = true;
+      _have_lower = true;
       for (ArcIt a(_graph); a != INVALID; ++a) {
         _lower[_arc_id[a]] = map[a];
@@ -880,5 +880,5 @@
         _cost[i] = 1;
       }
-      _has_lower = false;
+      _have_lower = false;
       _stype = GEQ;
       return *this;
@@ -937,5 +937,5 @@
         _node_id[n] = i;
       }
-      if (_arc_mixing && _node_num > 1) {
+      if (_arc_mixing) {
         // Store the arcs in a mixed order
         const int skip = std::max(_arc_num / _node_num, 3);
@@ -1073,5 +1073,5 @@
 
       // Remove non-zero lower bounds
-      if (_has_lower) {
+      if (_have_lower) {
         for (int i = 0; i != _arc_num; ++i) {
           Value c = _lower[i];
@@ -1236,5 +1236,5 @@
     }
 
-    // Check if the upper bound is greater than or equal to the lower bound
+    // Check if the upper bound is greater or equal to the lower bound
     // on each arc.
     bool checkBoundMaps() {
@@ -1613,5 +1613,5 @@
 
       // Transform the solution and the supply map to the original form
-      if (_has_lower) {
+      if (_have_lower) {
         for (int i = 0; i != _arc_num; ++i) {
           Value c = _lower[i];
Index: lemon/path.h
===================================================================
--- lemon/path.h	(revision 1336)
+++ lemon/path.h	(revision 1270)
@@ -31,5 +31,4 @@
 #include <lemon/core.h>
 #include <lemon/concepts/path.h>
-#include <lemon/bits/stl_iterators.h>
 
 namespace lemon {
@@ -141,21 +140,4 @@
       int idx;
     };
-
-    /// \brief Gets the collection of the arcs of the path.
-    ///
-    /// This function can be used for iterating on the
-    /// arcs of the path. It returns a wrapped
-    /// ArcIt, which looks like an STL container
-    /// (by having begin() and end()) which you can use in range-based
-    /// for loops, STL algorithms, etc.
-    /// For example you can write:
-    ///\code
-    /// for(auto a: p.arcs())
-    ///   doSomething(a);
-    ///\endcode
-    LemonRangeWrapper1<ArcIt, Path> arcs() const {
-      return LemonRangeWrapper1<ArcIt, Path>(*this);
-    }
-
 
     /// \brief Length of the path.
@@ -364,21 +346,4 @@
     };
 
-    /// \brief Gets the collection of the arcs of the path.
-    ///
-    /// This function can be used for iterating on the
-    /// arcs of the path. It returns a wrapped
-    /// ArcIt, which looks like an STL container
-    /// (by having begin() and end()) which you can use in range-based
-    /// for loops, STL algorithms, etc.
-    /// For example you can write:
-    ///\code
-    /// for(auto a: p.arcs())
-    ///   doSomething(a);
-    ///\endcode
-    LemonRangeWrapper1<ArcIt, SimplePath> arcs() const {
-      return LemonRangeWrapper1<ArcIt, SimplePath>(*this);
-    }
-
-
     /// \brief Length of the path.
     int length() const { return data.size(); }
@@ -578,21 +543,4 @@
       Node *node;
     };
-
-    /// \brief Gets the collection of the arcs of the path.
-    ///
-    /// This function can be used for iterating on the
-    /// arcs of the path. It returns a wrapped
-    /// ArcIt, which looks like an STL container
-    /// (by having begin() and end()) which you can use in range-based
-    /// for loops, STL algorithms, etc.
-    /// For example you can write:
-    ///\code
-    /// for(auto a: p.arcs())
-    ///   doSomething(a);
-    ///\endcode
-    LemonRangeWrapper1<ArcIt, ListPath> arcs() const {
-      return LemonRangeWrapper1<ArcIt, ListPath>(*this);
-    }
-
 
     /// \brief The n-th arc.
@@ -848,9 +796,9 @@
     ///
     /// Default constructor
-    StaticPath() : len(0), _arcs(0) {}
+    StaticPath() : len(0), arcs(0) {}
 
     /// \brief Copy constructor
     ///
-    StaticPath(const StaticPath& cpath) : _arcs(0) {
+    StaticPath(const StaticPath& cpath) : arcs(0) {
       pathCopy(cpath, *this);
     }
@@ -860,5 +808,5 @@
     /// This path can be initialized from any other path type.
     template <typename CPath>
-    StaticPath(const CPath& cpath) : _arcs(0) {
+    StaticPath(const CPath& cpath) : arcs(0) {
       pathCopy(cpath, *this);
     }
@@ -868,5 +816,5 @@
     /// Destructor of the path
     ~StaticPath() {
-      if (_arcs) delete[] _arcs;
+      if (arcs) delete[] arcs;
     }
 
@@ -935,21 +883,4 @@
       int idx;
     };
-    
-    /// \brief Gets the collection of the arcs of the path.
-    ///
-    /// This function can be used for iterating on the
-    /// arcs of the path. It returns a wrapped
-    /// ArcIt, which looks like an STL container
-    /// (by having begin() and end()) which you can use in range-based
-    /// for loops, STL algorithms, etc.
-    /// For example you can write:
-    ///\code
-    /// for(auto a: p.arcs())
-    ///   doSomething(a);
-    ///\endcode
-    LemonRangeWrapper1<ArcIt, StaticPath> arcs() const {
-      return LemonRangeWrapper1<ArcIt, StaticPath>(*this);
-    }
-    
 
     /// \brief The n-th arc.
@@ -957,5 +888,5 @@
     /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
     const Arc& nth(int n) const {
-      return _arcs[n];
+      return arcs[n];
     }
 
@@ -974,16 +905,16 @@
     void clear() {
       len = 0;
-      if (_arcs) delete[] _arcs;
-      _arcs = 0;
+      if (arcs) delete[] arcs;
+      arcs = 0;
     }
 
     /// \brief The first arc of the path.
     const Arc& front() const {
-      return _arcs[0];
+      return arcs[0];
     }
 
     /// \brief The last arc of the path.
     const Arc& back() const {
-      return _arcs[len - 1];
+      return arcs[len - 1];
     }
 
@@ -994,8 +925,8 @@
     void build(const CPath& path) {
       len = path.length();
-      _arcs = new Arc[len];
+      arcs = new Arc[len];
       int index = 0;
       for (typename CPath::ArcIt it(path); it != INVALID; ++it) {
-        _arcs[index] = it;
+        arcs[index] = it;
         ++index;
       }
@@ -1005,9 +936,9 @@
     void buildRev(const CPath& path) {
       len = path.length();
-      _arcs = new Arc[len];
+      arcs = new Arc[len];
       int index = len;
       for (typename CPath::RevArcIt it(path); it != INVALID; ++it) {
         --index;
-        _arcs[index] = it;
+        arcs[index] = it;
       }
     }
@@ -1015,5 +946,5 @@
   private:
     int len;
-    Arc* _arcs;
+    Arc* arcs;
   };
 
@@ -1227,23 +1158,4 @@
   };
 
-  /// \brief Gets the collection of the nodes of the path.
-  ///
-  /// This function can be used for iterating on the
-  /// nodes of the path. It returns a wrapped
-  /// PathNodeIt, which looks like an STL container
-  /// (by having begin() and end()) which you can use in range-based
-  /// for loops, STL algorithms, etc.
-  /// For example you can write:
-  ///\code
-  /// for(auto u: pathNodes(g,p))
-  ///   doSomething(u);
-  ///\endcode
-  template<typename Path>
-  LemonRangeWrapper2<PathNodeIt<Path>, typename Path::Digraph, Path>
-      pathNodes(const typename Path::Digraph &g, const Path &p) {
-    return
-        LemonRangeWrapper2<PathNodeIt<Path>, typename Path::Digraph, Path>(g,p);
-  }
-
   ///@}
 
Index: lemon/radix_sort.h
===================================================================
--- lemon/radix_sort.h	(revision 1328)
+++ lemon/radix_sort.h	(revision 1270)
@@ -329,5 +329,5 @@
       Allocator allocator;
 
-      int length = static_cast<int>(std::distance(first, last));
+      int length = std::distance(first, last);
       Key* buffer = allocator.allocate(2 * length);
       try {
Index: lemon/random.h
===================================================================
--- lemon/random.h	(revision 1380)
+++ lemon/random.h	(revision 631)
@@ -63,6 +63,4 @@
 #define LEMON_RANDOM_H
 
-#include <lemon/config.h>
-
 #include <algorithm>
 #include <iterator>
@@ -74,5 +72,5 @@
 #include <lemon/dim2.h>
 
-#ifndef LEMON_WIN32
+#ifndef WIN32
 #include <sys/time.h>
 #include <ctime>
@@ -112,4 +110,5 @@
       static const Word hiMask = ~loMask;
 
+
       static Word tempering(Word rnd) {
         rnd ^= (rnd >> 11);
@@ -201,5 +200,5 @@
         initState(init);
 
-        num = static_cast<int>(length > end - begin ? length : end - begin);
+        num = length > end - begin ? length : end - begin;
         while (num--) {
           curr[0] = (curr[0] ^ ((curr[1] ^ (curr[1] >> (bits - 2))) * mul1))
@@ -215,5 +214,5 @@
         }
 
-        num = length - 1; cnt = static_cast<int>(length - (curr - state) - 1);
+        num = length - 1; cnt = length - (curr - state) - 1;
         while (num--) {
           curr[0] = (curr[0] ^ ((curr[1] ^ (curr[1] >> (bits - 2))) * mul2))
@@ -243,4 +242,5 @@
     private:
 
+
       void fillState() {
         static const Word mask[2] = { 0x0ul, RandomTraits<Word>::mask };
@@ -250,6 +250,6 @@
         current = state + length;
 
-        Word *curr = state + length - 1;
-        long num;
+        register Word *curr = state + length - 1;
+        register long num;
 
         num = length - shift;
@@ -270,4 +270,5 @@
       }
 
+
       Word *current;
       Word state[length];
@@ -294,5 +295,5 @@
     template <typename Result, typename Word,
               int rest = std::numeric_limits<Result>::digits, int shift = 0,
-              bool last = (rest <= std::numeric_limits<Word>::digits)>
+              bool last = rest <= std::numeric_limits<Word>::digits>
     struct IntConversion {
       static const int bits = std::numeric_limits<Word>::digits;
@@ -463,544 +464,5 @@
     };
 
-    /// \ingroup misc
-    ///
-    /// \brief Mersenne Twister random number generator
-    ///
-    /// The Mersenne Twister is a twisted generalized feedback
-    /// shift-register generator of Matsumoto and Nishimura. The period
-    /// of this generator is \f$ 2^{19937} - 1\f$ and it is
-    /// equi-distributed in 623 dimensions for 32-bit numbers. The time
-    /// performance of this generator is comparable to the commonly used
-    /// generators.
-    ///
-    /// This is a template implementation of both 32-bit and
-    /// 64-bit architecture optimized versions. The generators differ
-    /// sligthly in the initialization and generation phase so they
-    /// produce two completly different sequences.
-    ///
-    /// \alert Do not use this class directly, but instead one of \ref
-    /// Random, \ref Random32 or \ref Random64.
-    ///
-    /// The generator gives back random numbers of serveral types. To
-    /// get a random number from a range of a floating point type, you
-    /// can use one form of the \c operator() or the \c real() member
-    /// function. If you want to get random number from the {0, 1, ...,
-    /// n-1} integer range, use the \c operator[] or the \c integer()
-    /// method. And to get random number from the whole range of an
-    /// integer type, you can use the argumentless \c integer() or
-    /// \c uinteger() functions. Finally, you can get random bool with
-    /// equal chance of true and false or with given probability of true
-    /// result using the \c boolean() member functions.
-    ///
-    /// Various non-uniform distributions are also supported: normal (Gauss),
-    /// exponential, gamma, Poisson, etc.; and a few two-dimensional
-    /// distributions, too.
-    ///
-    ///\code
-    /// // The commented code is identical to the other
-    /// double a = rnd();                     // [0.0, 1.0)
-    /// // double a = rnd.real();             // [0.0, 1.0)
-    /// double b = rnd(100.0);                // [0.0, 100.0)
-    /// // double b = rnd.real(100.0);        // [0.0, 100.0)
-    /// double c = rnd(1.0, 2.0);             // [1.0, 2.0)
-    /// // double c = rnd.real(1.0, 2.0);     // [1.0, 2.0)
-    /// int d = rnd[100000];                  // 0..99999
-    /// // int d = rnd.integer(100000);       // 0..99999
-    /// int e = rnd[6] + 1;                   // 1..6
-    /// // int e = rnd.integer(1, 1 + 6);     // 1..6
-    /// int b = rnd.uinteger<int>();          // 0 .. 2^31 - 1
-    /// int c = rnd.integer<int>();           // - 2^31 .. 2^31 - 1
-    /// bool g = rnd.boolean();               // P(g = true) = 0.5
-    /// bool h = rnd.boolean(0.8);            // P(h = true) = 0.8
-    ///\endcode
-    ///
-    /// LEMON provides a global instance of the random number generator:
-    /// \ref lemon::rnd "rnd". In most cases, it is a good practice
-    /// to use this global generator to get random numbers.
-    ///
-    /// \sa \ref Random, \ref Random32 or \ref Random64.
-    template<class Word>
-    class Random {
-    private:
-
-      _random_bits::RandomCore<Word> core;
-      _random_bits::BoolProducer<Word> bool_producer;
-
-
-    public:
-
-      ///\name Initialization
-      ///
-      /// @{
-
-      /// \brief Default constructor
-      ///
-      /// Constructor with constant seeding.
-      Random() { core.initState(); }
-
-      /// \brief Constructor with seed
-      ///
-      /// Constructor with seed. The current number type will be converted
-      /// to the architecture word type.
-      template <typename Number>
-      Random(Number seed) {
-        _random_bits::Initializer<Number, Word>::init(core, seed);
-      }
-
-      /// \brief Constructor with array seeding
-      ///
-      /// Constructor with array seeding. The given range should contain
-      /// any number type and the numbers will be converted to the
-      /// architecture word type.
-      template <typename Iterator>
-      Random(Iterator begin, Iterator end) {
-        typedef typename std::iterator_traits<Iterator>::value_type Number;
-        _random_bits::Initializer<Number, Word>::init(core, begin, end);
-      }
-
-      /// \brief Copy constructor
-      ///
-      /// Copy constructor. The generated sequence will be identical to
-      /// the other sequence. It can be used to save the current state
-      /// of the generator and later use it to generate the same
-      /// sequence.
-      Random(const Random& other) {
-        core.copyState(other.core);
-      }
-
-      /// \brief Assign operator
-      ///
-      /// Assign operator. The generated sequence will be identical to
-      /// the other sequence. It can be used to save the current state
-      /// of the generator and later use it to generate the same
-      /// sequence.
-      Random& operator=(const Random& other) {
-        if (&other != this) {
-          core.copyState(other.core);
-        }
-        return *this;
-      }
-
-      /// \brief Seeding random sequence
-      ///
-      /// Seeding the random sequence. The current number type will be
-      /// converted to the architecture word type.
-      template <typename Number>
-      void seed(Number seed) {
-        _random_bits::Initializer<Number, Word>::init(core, seed);
-      }
-
-      /// \brief Seeding random sequence
-      ///
-      /// Seeding the random sequence. The given range should contain
-      /// any number type and the numbers will be converted to the
-      /// architecture word type.
-      template <typename Iterator>
-      void seed(Iterator begin, Iterator end) {
-        typedef typename std::iterator_traits<Iterator>::value_type Number;
-        _random_bits::Initializer<Number, Word>::init(core, begin, end);
-      }
-
-      /// \brief Seeding from file or from process id and time
-      ///
-      /// By default, this function calls the \c seedFromFile() member
-      /// function with the <tt>/dev/urandom</tt> file. If it does not success,
-      /// it uses the \c seedFromTime().
-      /// \return Currently always \c true.
-      bool seed() {
-#ifndef LEMON_WIN32
-        if (seedFromFile("/dev/urandom", 0)) return true;
-#endif
-        if (seedFromTime()) return true;
-        return false;
-      }
-
-      /// \brief Seeding from file
-      ///
-      /// Seeding the random sequence from file. The linux kernel has two
-      /// devices, <tt>/dev/random</tt> and <tt>/dev/urandom</tt> which
-      /// could give good seed values for pseudo random generators (The
-      /// difference between two devices is that the <tt>random</tt> may
-      /// block the reading operation while the kernel can give good
-      /// source of randomness, while the <tt>urandom</tt> does not
-      /// block the input, but it could give back bytes with worse
-      /// entropy).
-      /// \param file The source file
-      /// \param offset The offset, from the file read.
-      /// \return \c true when the seeding successes.
-#ifndef LEMON_WIN32
-      bool seedFromFile(const std::string& file = "/dev/urandom", int offset = 0)
-#else
-        bool seedFromFile(const std::string& file = "", int offset = 0)
-#endif
-      {
-        std::ifstream rs(file.c_str());
-        const int size = 4;
-        Word buf[size];
-        if (offset != 0 && !rs.seekg(offset)) return false;
-        if (!rs.read(reinterpret_cast<char*>(buf), sizeof(buf))) return false;
-        seed(buf, buf + size);
-        return true;
-      }
-
-      /// \brief Seeding from process id and time
-      ///
-      /// Seeding from process id and time. This function uses the
-      /// current process id and the current time for initialize the
-      /// random sequence.
-      /// \return Currently always \c true.
-      bool seedFromTime() {
-#ifndef LEMON_WIN32
-        timeval tv;
-        gettimeofday(&tv, 0);
-        seed(getpid() + tv.tv_sec + tv.tv_usec);
-#else
-        seed(bits::getWinRndSeed());
-#endif
-        return true;
-      }
-
-      /// @}
-
-      ///\name Uniform Distributions
-      ///
-      /// @{
-
-      /// \brief Returns a random real number from the range [0, 1)
-      ///
-      /// It returns a random real number from the range [0, 1). The
-      /// default Number type is \c double.
-      template <typename Number>
-      Number real() {
-        return _random_bits::RealConversion<Number, Word>::convert(core);
-      }
-
-      double real() {
-        return real<double>();
-      }
-
-      /// \brief Returns a random real number from the range [0, 1)
-      ///
-      /// It returns a random double from the range [0, 1).
-      double operator()() {
-        return real<double>();
-      }
-
-      /// \brief Returns a random real number from the range [0, b)
-      ///
-      /// It returns a random real number from the range [0, b).
-      double operator()(double b) {
-        return real<double>() * b;
-      }
-
-      /// \brief Returns a random real number from the range [a, b)
-      ///
-      /// It returns a random real number from the range [a, b).
-      double operator()(double a, double b) {
-        return real<double>() * (b - a) + a;
-      }
-
-      /// \brief Returns a random integer from a range
-      ///
-      /// It returns a random integer from the range {0, 1, ..., b - 1}.
-      template <typename Number>
-      Number integer(Number b) {
-        return _random_bits::Mapping<Number, Word>::map(core, b);
-      }
-
-      /// \brief Returns a random integer from a range
-      ///
-      /// It returns a random integer from the range {a, a + 1, ..., b - 1}.
-      template <typename Number>
-      Number integer(Number a, Number b) {
-        return _random_bits::Mapping<Number, Word>::map(core, b - a) + a;
-      }
-
-      /// \brief Returns a random integer from a range
-      ///
-      /// It returns a random integer from the range {0, 1, ..., b - 1}.
-      template <typename Number>
-      Number operator[](Number b) {
-        return _random_bits::Mapping<Number, Word>::map(core, b);
-      }
-
-      /// \brief Returns a random non-negative integer
-      ///
-      /// It returns a random non-negative integer uniformly from the
-      /// whole range of the current \c Number type. The default result
-      /// type of this function is <tt>unsigned int</tt>.
-      template <typename Number>
-      Number uinteger() {
-        return _random_bits::IntConversion<Number, Word>::convert(core);
-      }
-
-      unsigned int uinteger() {
-        return uinteger<unsigned int>();
-      }
-
-      /// \brief Returns a random integer
-      ///
-      /// It returns a random integer uniformly from the whole range of
-      /// the current \c Number type. The default result type of this
-      /// function is \c int.
-      template <typename Number>
-      Number integer() {
-        static const int nb = std::numeric_limits<Number>::digits +
-          (std::numeric_limits<Number>::is_signed ? 1 : 0);
-        return _random_bits::IntConversion<Number, Word, nb>::convert(core);
-      }
-
-      int integer() {
-        return integer<int>();
-      }
-
-      /// \brief Returns a random bool
-      ///
-      /// It returns a random bool. The generator holds a buffer for
-      /// random bits. Every time when it become empty the generator makes
-      /// a new random word and fill the buffer up.
-      bool boolean() {
-        return bool_producer.convert(core);
-      }
-
-      /// @}
-
-      ///\name Non-uniform Distributions
-      ///
-      ///@{
-
-      /// \brief Returns a random bool with given probability of true result.
-      ///
-      /// It returns a random bool with given probability of true result.
-      bool boolean(double p) {
-        return operator()() < p;
-      }
-
-      /// Standard normal (Gauss) distribution
-
-      /// Standard normal (Gauss) distribution.
-      /// \note The Cartesian form of the Box-Muller
-      /// transformation is used to generate a random normal distribution.
-      double gauss()
-      {
-        double V1,V2,S;
-        do {
-          V1=2*real<double>()-1;
-          V2=2*real<double>()-1;
-          S=V1*V1+V2*V2;
-        } while(S>=1);
-        return std::sqrt(-2*std::log(S)/S)*V1;
-      }
-      /// Normal (Gauss) distribution with given mean and standard deviation
-
-      /// Normal (Gauss) distribution with given mean and standard deviation.
-      /// \sa gauss()
-      double gauss(double mean,double std_dev)
-      {
-        return gauss()*std_dev+mean;
-      }
-
-      /// Lognormal distribution
-
-      /// Lognormal distribution. The parameters are the mean and the standard
-      /// deviation of <tt>exp(X)</tt>.
-      ///
-      double lognormal(double n_mean,double n_std_dev)
-      {
-        return std::exp(gauss(n_mean,n_std_dev));
-      }
-      /// Lognormal distribution
-
-      /// Lognormal distribution. The parameter is an <tt>std::pair</tt> of
-      /// the mean and the standard deviation of <tt>exp(X)</tt>.
-      ///
-      double lognormal(const std::pair<double,double> &params)
-      {
-        return std::exp(gauss(params.first,params.second));
-      }
-      /// Compute the lognormal parameters from mean and standard deviation
-
-      /// This function computes the lognormal parameters from mean and
-      /// standard deviation. The return value can direcly be passed to
-      /// lognormal().
-      std::pair<double,double> lognormalParamsFromMD(double mean,
-                                                     double std_dev)
-      {
-        double fr=std_dev/mean;
-        fr*=fr;
-        double lg=std::log(1+fr);
-        return std::pair<double,double>(std::log(mean)-lg/2.0,std::sqrt(lg));
-      }
-      /// Lognormal distribution with given mean and standard deviation
-
-      /// Lognormal distribution with given mean and standard deviation.
-      ///
-      double lognormalMD(double mean,double std_dev)
-      {
-        return lognormal(lognormalParamsFromMD(mean,std_dev));
-      }
-
-      /// Exponential distribution with given mean
-
-      /// This function generates an exponential distribution random number
-      /// with mean <tt>1/lambda</tt>.
-      ///
-      double exponential(double lambda=1.0)
-      {
-        return -std::log(1.0-real<double>())/lambda;
-      }
-
-      /// Gamma distribution with given integer shape
-
-      /// This function generates a gamma distribution random number.
-      ///
-      ///\param k shape parameter (<tt>k>0</tt> integer)
-      double gamma(int k)
-      {
-        double s = 0;
-        for(int i=0;i<k;i++) s-=std::log(1.0-real<double>());
-        return s;
-      }
-
-      /// Gamma distribution with given shape and scale parameter
-
-      /// This function generates a gamma distribution random number.
-      ///
-      ///\param k shape parameter (<tt>k>0</tt>)
-      ///\param theta scale parameter
-      ///
-      double gamma(double k,double theta=1.0)
-      {
-        double xi,nu;
-        const double delta = k-std::floor(k);
-        const double v0=E/(E-delta);
-        do {
-          double V0=1.0-real<double>();
-          double V1=1.0-real<double>();
-          double V2=1.0-real<double>();
-          if(V2<=v0)
-            {
-              xi=std::pow(V1,1.0/delta);
-              nu=V0*std::pow(xi,delta-1.0);
-            }
-          else
-            {
-              xi=1.0-std::log(V1);
-              nu=V0*std::exp(-xi);
-            }
-        } while(nu>std::pow(xi,delta-1.0)*std::exp(-xi));
-        return theta*(xi+gamma(int(std::floor(k))));
-      }
-
-      /// Weibull distribution
-
-      /// This function generates a Weibull distribution random number.
-      ///
-      ///\param k shape parameter (<tt>k>0</tt>)
-      ///\param lambda scale parameter (<tt>lambda>0</tt>)
-      ///
-      double weibull(double k,double lambda)
-      {
-        return lambda*pow(-std::log(1.0-real<double>()),1.0/k);
-      }
-
-      /// Pareto distribution
-
-      /// This function generates a Pareto distribution random number.
-      ///
-      ///\param k shape parameter (<tt>k>0</tt>)
-      ///\param x_min location parameter (<tt>x_min>0</tt>)
-      ///
-      double pareto(double k,double x_min)
-      {
-        return exponential(gamma(k,1.0/x_min))+x_min;
-      }
-
-      /// Poisson distribution
-
-      /// This function generates a Poisson distribution random number with
-      /// parameter \c lambda.
-      ///
-      /// The probability mass function of this distribusion is
-      /// \f[ \frac{e^{-\lambda}\lambda^k}{k!} \f]
-      /// \note The algorithm is taken from the book of Donald E. Knuth titled
-      /// ''Seminumerical Algorithms'' (1969). Its running time is linear in the
-      /// return value.
-
-      int poisson(double lambda)
-      {
-        const double l = std::exp(-lambda);
-        int k=0;
-        double p = 1.0;
-        do {
-          k++;
-          p*=real<double>();
-        } while (p>=l);
-        return k-1;
-      }
-
-      ///@}
-
-      ///\name Two-Dimensional Distributions
-      ///
-      ///@{
-
-      /// Uniform distribution on the full unit circle
-
-      /// Uniform distribution on the full unit circle.
-      ///
-      dim2::Point<double> disc()
-      {
-        double V1,V2;
-        do {
-          V1=2*real<double>()-1;
-          V2=2*real<double>()-1;
-
-        } while(V1*V1+V2*V2>=1);
-        return dim2::Point<double>(V1,V2);
-      }
-      /// A kind of two-dimensional normal (Gauss) distribution
-
-      /// This function provides a turning symmetric two-dimensional distribution.
-      /// Both coordinates are of standard normal distribution, but they are not
-      /// independent.
-      ///
-      /// \note The coordinates are the two random variables provided by
-      /// the Box-Muller method.
-      dim2::Point<double> gauss2()
-      {
-        double V1,V2,S;
-        do {
-          V1=2*real<double>()-1;
-          V2=2*real<double>()-1;
-          S=V1*V1+V2*V2;
-        } while(S>=1);
-        double W=std::sqrt(-2*std::log(S)/S);
-        return dim2::Point<double>(W*V1,W*V2);
-      }
-      /// A kind of two-dimensional exponential distribution
-
-      /// This function provides a turning symmetric two-dimensional distribution.
-      /// The x-coordinate is of conditionally exponential distribution
-      /// with the condition that x is positive and y=0. If x is negative and
-      /// y=0 then, -x is of exponential distribution. The same is true for the
-      /// y-coordinate.
-      dim2::Point<double> exponential2()
-      {
-        double V1,V2,S;
-        do {
-          V1=2*real<double>()-1;
-          V2=2*real<double>()-1;
-          S=V1*V1+V2*V2;
-        } while(S>=1);
-        double W=-std::log(S)/S;
-        return dim2::Point<double>(W*V1,W*V2);
-      }
-
-      ///@}
-    };
-
-
-  };
+  }
 
   /// \ingroup misc
@@ -1008,47 +470,535 @@
   /// \brief Mersenne Twister random number generator
   ///
-  /// This class implements either the 32-bit or the 64-bit version of
-  /// the Mersenne Twister random number generator algorithm
-  /// depending on the system architecture.
-  /// 
-  /// For the API description, see its base class
-  /// \ref _random_bits::Random.
+  /// The Mersenne Twister is a twisted generalized feedback
+  /// shift-register generator of Matsumoto and Nishimura. The period
+  /// of this generator is \f$ 2^{19937} - 1 \f$ and it is
+  /// equi-distributed in 623 dimensions for 32-bit numbers. The time
+  /// performance of this generator is comparable to the commonly used
+  /// generators.
   ///
-  /// \sa \ref _random_bits::Random
-  typedef _random_bits::Random<unsigned long> Random;
-
-  /// \ingroup misc
+  /// This implementation is specialized for both 32-bit and 64-bit
+  /// architectures. The generators differ sligthly in the
+  /// initialization and generation phase so they produce two
+  /// completly different sequences.
   ///
-  /// \brief Mersenne Twister random number generator (32-bit version)
+  /// The generator gives back random numbers of serveral types. To
+  /// get a random number from a range of a floating point type you
+  /// can use one form of the \c operator() or the \c real() member
+  /// function. If you want to get random number from the {0, 1, ...,
+  /// n-1} integer range use the \c operator[] or the \c integer()
+  /// method. And to get random number from the whole range of an
+  /// integer type you can use the argumentless \c integer() or \c
+  /// uinteger() functions. After all you can get random bool with
+  /// equal chance of true and false or given probability of true
+  /// result with the \c boolean() member functions.
   ///
-  /// This class implements the 32-bit version of the Mersenne Twister
-  /// random number generator algorithm. It is recommended to be used
-  /// when someone wants to make sure that the \e same pseudo random
-  /// sequence will be generated on every platfrom.
+  ///\code
+  /// // The commented code is identical to the other
+  /// double a = rnd();                     // [0.0, 1.0)
+  /// // double a = rnd.real();             // [0.0, 1.0)
+  /// double b = rnd(100.0);                // [0.0, 100.0)
+  /// // double b = rnd.real(100.0);        // [0.0, 100.0)
+  /// double c = rnd(1.0, 2.0);             // [1.0, 2.0)
+  /// // double c = rnd.real(1.0, 2.0);     // [1.0, 2.0)
+  /// int d = rnd[100000];                  // 0..99999
+  /// // int d = rnd.integer(100000);       // 0..99999
+  /// int e = rnd[6] + 1;                   // 1..6
+  /// // int e = rnd.integer(1, 1 + 6);     // 1..6
+  /// int b = rnd.uinteger<int>();          // 0 .. 2^31 - 1
+  /// int c = rnd.integer<int>();           // - 2^31 .. 2^31 - 1
+  /// bool g = rnd.boolean();               // P(g = true) = 0.5
+  /// bool h = rnd.boolean(0.8);            // P(h = true) = 0.8
+  ///\endcode
   ///
-  /// For the API description, see its base class
-  /// \ref _random_bits::Random.
-  ///
-  /// \sa \ref _random_bits::Random
-  typedef _random_bits::Random<unsigned int> Random32;
-
-  /// \ingroup misc
-  ///
-  /// \brief Mersenne Twister random number generator (64-bit version)
-  ///
-  /// This class implements the 64-bit version of the Mersenne Twister
-  /// random number generator algorithm. (Even though it runs
-  /// on 32-bit architectures, too.) It is recommended to be used when
-  /// someone wants to make sure that the \e same pseudo random sequence
-  /// will be generated on every platfrom.
-  ///
-  /// For the API description, see its base class
-  /// \ref _random_bits::Random.
-  ///
-  /// \sa \ref _random_bits::Random
-  typedef _random_bits::Random<unsigned long long> Random64;
+  /// LEMON provides a global instance of the random number
+  /// generator which name is \ref lemon::rnd "rnd". Usually it is a
+  /// good programming convenience to use this global generator to get
+  /// random numbers.
+  class Random {
+  private:
+
+    // Architecture word
+    typedef unsigned long Word;
+
+    _random_bits::RandomCore<Word> core;
+    _random_bits::BoolProducer<Word> bool_producer;
+
+
+  public:
+
+    ///\name Initialization
+    ///
+    /// @{
+
+    /// \brief Default constructor
+    ///
+    /// Constructor with constant seeding.
+    Random() { core.initState(); }
+
+    /// \brief Constructor with seed
+    ///
+    /// Constructor with seed. The current number type will be converted
+    /// to the architecture word type.
+    template <typename Number>
+    Random(Number seed) {
+      _random_bits::Initializer<Number, Word>::init(core, seed);
+    }
+
+    /// \brief Constructor with array seeding
+    ///
+    /// Constructor with array seeding. The given range should contain
+    /// any number type and the numbers will be converted to the
+    /// architecture word type.
+    template <typename Iterator>
+    Random(Iterator begin, Iterator end) {
+      typedef typename std::iterator_traits<Iterator>::value_type Number;
+      _random_bits::Initializer<Number, Word>::init(core, begin, end);
+    }
+
+    /// \brief Copy constructor
+    ///
+    /// Copy constructor. The generated sequence will be identical to
+    /// the other sequence. It can be used to save the current state
+    /// of the generator and later use it to generate the same
+    /// sequence.
+    Random(const Random& other) {
+      core.copyState(other.core);
+    }
+
+    /// \brief Assign operator
+    ///
+    /// Assign operator. The generated sequence will be identical to
+    /// the other sequence. It can be used to save the current state
+    /// of the generator and later use it to generate the same
+    /// sequence.
+    Random& operator=(const Random& other) {
+      if (&other != this) {
+        core.copyState(other.core);
+      }
+      return *this;
+    }
+
+    /// \brief Seeding random sequence
+    ///
+    /// Seeding the random sequence. The current number type will be
+    /// converted to the architecture word type.
+    template <typename Number>
+    void seed(Number seed) {
+      _random_bits::Initializer<Number, Word>::init(core, seed);
+    }
+
+    /// \brief Seeding random sequence
+    ///
+    /// Seeding the random sequence. The given range should contain
+    /// any number type and the numbers will be converted to the
+    /// architecture word type.
+    template <typename Iterator>
+    void seed(Iterator begin, Iterator end) {
+      typedef typename std::iterator_traits<Iterator>::value_type Number;
+      _random_bits::Initializer<Number, Word>::init(core, begin, end);
+    }
+
+    /// \brief Seeding from file or from process id and time
+    ///
+    /// By default, this function calls the \c seedFromFile() member
+    /// function with the <tt>/dev/urandom</tt> file. If it does not success,
+    /// it uses the \c seedFromTime().
+    /// \return Currently always \c true.
+    bool seed() {
+#ifndef WIN32
+      if (seedFromFile("/dev/urandom", 0)) return true;
+#endif
+      if (seedFromTime()) return true;
+      return false;
+    }
+
+    /// \brief Seeding from file
+    ///
+    /// Seeding the random sequence from file. The linux kernel has two
+    /// devices, <tt>/dev/random</tt> and <tt>/dev/urandom</tt> which
+    /// could give good seed values for pseudo random generators (The
+    /// difference between two devices is that the <tt>random</tt> may
+    /// block the reading operation while the kernel can give good
+    /// source of randomness, while the <tt>urandom</tt> does not
+    /// block the input, but it could give back bytes with worse
+    /// entropy).
+    /// \param file The source file
+    /// \param offset The offset, from the file read.
+    /// \return \c true when the seeding successes.
+#ifndef WIN32
+    bool seedFromFile(const std::string& file = "/dev/urandom", int offset = 0)
+#else
+    bool seedFromFile(const std::string& file = "", int offset = 0)
+#endif
+    {
+      std::ifstream rs(file.c_str());
+      const int size = 4;
+      Word buf[size];
+      if (offset != 0 && !rs.seekg(offset)) return false;
+      if (!rs.read(reinterpret_cast<char*>(buf), sizeof(buf))) return false;
+      seed(buf, buf + size);
+      return true;
+    }
+
+    /// \brief Seding from process id and time
+    ///
+    /// Seding from process id and time. This function uses the
+    /// current process id and the current time for initialize the
+    /// random sequence.
+    /// \return Currently always \c true.
+    bool seedFromTime() {
+#ifndef WIN32
+      timeval tv;
+      gettimeofday(&tv, 0);
+      seed(getpid() + tv.tv_sec + tv.tv_usec);
+#else
+      seed(bits::getWinRndSeed());
+#endif
+      return true;
+    }
+
+    /// @}
+
+    ///\name Uniform Distributions
+    ///
+    /// @{
+
+    /// \brief Returns a random real number from the range [0, 1)
+    ///
+    /// It returns a random real number from the range [0, 1). The
+    /// default Number type is \c double.
+    template <typename Number>
+    Number real() {
+      return _random_bits::RealConversion<Number, Word>::convert(core);
+    }
+
+    double real() {
+      return real<double>();
+    }
+
+    /// \brief Returns a random real number from the range [0, 1)
+    ///
+    /// It returns a random double from the range [0, 1).
+    double operator()() {
+      return real<double>();
+    }
+
+    /// \brief Returns a random real number from the range [0, b)
+    ///
+    /// It returns a random real number from the range [0, b).
+    double operator()(double b) {
+      return real<double>() * b;
+    }
+
+    /// \brief Returns a random real number from the range [a, b)
+    ///
+    /// It returns a random real number from the range [a, b).
+    double operator()(double a, double b) {
+      return real<double>() * (b - a) + a;
+    }
+
+    /// \brief Returns a random integer from a range
+    ///
+    /// It returns a random integer from the range {0, 1, ..., b - 1}.
+    template <typename Number>
+    Number integer(Number b) {
+      return _random_bits::Mapping<Number, Word>::map(core, b);
+    }
+
+    /// \brief Returns a random integer from a range
+    ///
+    /// It returns a random integer from the range {a, a + 1, ..., b - 1}.
+    template <typename Number>
+    Number integer(Number a, Number b) {
+      return _random_bits::Mapping<Number, Word>::map(core, b - a) + a;
+    }
+
+    /// \brief Returns a random integer from a range
+    ///
+    /// It returns a random integer from the range {0, 1, ..., b - 1}.
+    template <typename Number>
+    Number operator[](Number b) {
+      return _random_bits::Mapping<Number, Word>::map(core, b);
+    }
+
+    /// \brief Returns a random non-negative integer
+    ///
+    /// It returns a random non-negative integer uniformly from the
+    /// whole range of the current \c Number type. The default result
+    /// type of this function is <tt>unsigned int</tt>.
+    template <typename Number>
+    Number uinteger() {
+      return _random_bits::IntConversion<Number, Word>::convert(core);
+    }
+
+    unsigned int uinteger() {
+      return uinteger<unsigned int>();
+    }
+
+    /// \brief Returns a random integer
+    ///
+    /// It returns a random integer uniformly from the whole range of
+    /// the current \c Number type. The default result type of this
+    /// function is \c int.
+    template <typename Number>
+    Number integer() {
+      static const int nb = std::numeric_limits<Number>::digits +
+        (std::numeric_limits<Number>::is_signed ? 1 : 0);
+      return _random_bits::IntConversion<Number, Word, nb>::convert(core);
+    }
+
+    int integer() {
+      return integer<int>();
+    }
+
+    /// \brief Returns a random bool
+    ///
+    /// It returns a random bool. The generator holds a buffer for
+    /// random bits. Every time when it become empty the generator makes
+    /// a new random word and fill the buffer up.
+    bool boolean() {
+      return bool_producer.convert(core);
+    }
+
+    /// @}
+
+    ///\name Non-uniform Distributions
+    ///
+    ///@{
+
+    /// \brief Returns a random bool with given probability of true result.
+    ///
+    /// It returns a random bool with given probability of true result.
+    bool boolean(double p) {
+      return operator()() < p;
+    }
+
+    /// Standard normal (Gauss) distribution
+
+    /// Standard normal (Gauss) distribution.
+    /// \note The Cartesian form of the Box-Muller
+    /// transformation is used to generate a random normal distribution.
+    double gauss()
+    {
+      double V1,V2,S;
+      do {
+        V1=2*real<double>()-1;
+        V2=2*real<double>()-1;
+        S=V1*V1+V2*V2;
+      } while(S>=1);
+      return std::sqrt(-2*std::log(S)/S)*V1;
+    }
+    /// Normal (Gauss) distribution with given mean and standard deviation
+
+    /// Normal (Gauss) distribution with given mean and standard deviation.
+    /// \sa gauss()
+    double gauss(double mean,double std_dev)
+    {
+      return gauss()*std_dev+mean;
+    }
+
+    /// Lognormal distribution
+
+    /// Lognormal distribution. The parameters are the mean and the standard
+    /// deviation of <tt>exp(X)</tt>.
+    ///
+    double lognormal(double n_mean,double n_std_dev)
+    {
+      return std::exp(gauss(n_mean,n_std_dev));
+    }
+    /// Lognormal distribution
+
+    /// Lognormal distribution. The parameter is an <tt>std::pair</tt> of
+    /// the mean and the standard deviation of <tt>exp(X)</tt>.
+    ///
+    double lognormal(const std::pair<double,double> &params)
+    {
+      return std::exp(gauss(params.first,params.second));
+    }
+    /// Compute the lognormal parameters from mean and standard deviation
+
+    /// This function computes the lognormal parameters from mean and
+    /// standard deviation. The return value can direcly be passed to
+    /// lognormal().
+    std::pair<double,double> lognormalParamsFromMD(double mean,
+                                                   double std_dev)
+    {
+      double fr=std_dev/mean;
+      fr*=fr;
+      double lg=std::log(1+fr);
+      return std::pair<double,double>(std::log(mean)-lg/2.0,std::sqrt(lg));
+    }
+    /// Lognormal distribution with given mean and standard deviation
+
+    /// Lognormal distribution with given mean and standard deviation.
+    ///
+    double lognormalMD(double mean,double std_dev)
+    {
+      return lognormal(lognormalParamsFromMD(mean,std_dev));
+    }
+
+    /// Exponential distribution with given mean
+
+    /// This function generates an exponential distribution random number
+    /// with mean <tt>1/lambda</tt>.
+    ///
+    double exponential(double lambda=1.0)
+    {
+      return -std::log(1.0-real<double>())/lambda;
+    }
+
+    /// Gamma distribution with given integer shape
+
+    /// This function generates a gamma distribution random number.
+    ///
+    ///\param k shape parameter (<tt>k>0</tt> integer)
+    double gamma(int k)
+    {
+      double s = 0;
+      for(int i=0;i<k;i++) s-=std::log(1.0-real<double>());
+      return s;
+    }
+
+    /// Gamma distribution with given shape and scale parameter
+
+    /// This function generates a gamma distribution random number.
+    ///
+    ///\param k shape parameter (<tt>k>0</tt>)
+    ///\param theta scale parameter
+    ///
+    double gamma(double k,double theta=1.0)
+    {
+      double xi,nu;
+      const double delta = k-std::floor(k);
+      const double v0=E/(E-delta);
+      do {
+        double V0=1.0-real<double>();
+        double V1=1.0-real<double>();
+        double V2=1.0-real<double>();
+        if(V2<=v0)
+          {
+            xi=std::pow(V1,1.0/delta);
+            nu=V0*std::pow(xi,delta-1.0);
+          }
+        else
+          {
+            xi=1.0-std::log(V1);
+            nu=V0*std::exp(-xi);
+          }
+      } while(nu>std::pow(xi,delta-1.0)*std::exp(-xi));
+      return theta*(xi+gamma(int(std::floor(k))));
+    }
+
+    /// Weibull distribution
+
+    /// This function generates a Weibull distribution random number.
+    ///
+    ///\param k shape parameter (<tt>k>0</tt>)
+    ///\param lambda scale parameter (<tt>lambda>0</tt>)
+    ///
+    double weibull(double k,double lambda)
+    {
+      return lambda*pow(-std::log(1.0-real<double>()),1.0/k);
+    }
+
+    /// Pareto distribution
+
+    /// This function generates a Pareto distribution random number.
+    ///
+    ///\param k shape parameter (<tt>k>0</tt>)
+    ///\param x_min location parameter (<tt>x_min>0</tt>)
+    ///
+    double pareto(double k,double x_min)
+    {
+      return exponential(gamma(k,1.0/x_min))+x_min;
+    }
+
+    /// Poisson distribution
+
+    /// This function generates a Poisson distribution random number with
+    /// parameter \c lambda.
+    ///
+    /// The probability mass function of this distribusion is
+    /// \f[ \frac{e^{-\lambda}\lambda^k}{k!} \f]
+    /// \note The algorithm is taken from the book of Donald E. Knuth titled
+    /// ''Seminumerical Algorithms'' (1969). Its running time is linear in the
+    /// return value.
+
+    int poisson(double lambda)
+    {
+      const double l = std::exp(-lambda);
+      int k=0;
+      double p = 1.0;
+      do {
+        k++;
+        p*=real<double>();
+      } while (p>=l);
+      return k-1;
+    }
+
+    ///@}
+
+    ///\name Two Dimensional Distributions
+    ///
+    ///@{
+
+    /// Uniform distribution on the full unit circle
+
+    /// Uniform distribution on the full unit circle.
+    ///
+    dim2::Point<double> disc()
+    {
+      double V1,V2;
+      do {
+        V1=2*real<double>()-1;
+        V2=2*real<double>()-1;
+
+      } while(V1*V1+V2*V2>=1);
+      return dim2::Point<double>(V1,V2);
+    }
+    /// A kind of two dimensional normal (Gauss) distribution
+
+    /// This function provides a turning symmetric two-dimensional distribution.
+    /// Both coordinates are of standard normal distribution, but they are not
+    /// independent.
+    ///
+    /// \note The coordinates are the two random variables provided by
+    /// the Box-Muller method.
+    dim2::Point<double> gauss2()
+    {
+      double V1,V2,S;
+      do {
+        V1=2*real<double>()-1;
+        V2=2*real<double>()-1;
+        S=V1*V1+V2*V2;
+      } while(S>=1);
+      double W=std::sqrt(-2*std::log(S)/S);
+      return dim2::Point<double>(W*V1,W*V2);
+    }
+    /// A kind of two dimensional exponential distribution
+
+    /// This function provides a turning symmetric two-dimensional distribution.
+    /// The x-coordinate is of conditionally exponential distribution
+    /// with the condition that x is positive and y=0. If x is negative and
+    /// y=0 then, -x is of exponential distribution. The same is true for the
+    /// y-coordinate.
+    dim2::Point<double> exponential2()
+    {
+      double V1,V2,S;
+      do {
+        V1=2*real<double>()-1;
+        V2=2*real<double>()-1;
+        S=V1*V1+V2*V2;
+      } while(S>=1);
+      double W=-std::log(S)/S;
+      return dim2::Point<double>(W*V1,W*V2);
+    }
+
+    ///@}
+  };
+
 
   extern Random rnd;
-  
+
 }
 
Index: lemon/smart_graph.h
===================================================================
--- lemon/smart_graph.h	(revision 1336)
+++ lemon/smart_graph.h	(revision 1270)
@@ -48,6 +48,6 @@
     };
 
-    std::vector<NodeT> _nodes;
-    std::vector<ArcT> _arcs;
+    std::vector<NodeT> nodes;
+    std::vector<ArcT> arcs;
 
   public:
@@ -60,33 +60,33 @@
   public:
 
-    SmartDigraphBase() : _nodes(), _arcs() { }
+    SmartDigraphBase() : nodes(), arcs() { }
     SmartDigraphBase(const SmartDigraphBase &_g)
-      : _nodes(_g._nodes), _arcs(_g._arcs) { }
+      : nodes(_g.nodes), arcs(_g.arcs) { }
 
     typedef True NodeNumTag;
     typedef True ArcNumTag;
 
-    int nodeNum() const { return _nodes.size(); }
-    int arcNum() const { return _arcs.size(); }
-
-    int maxNodeId() const { return _nodes.size()-1; }
-    int maxArcId() const { return _arcs.size()-1; }
+    int nodeNum() const { return nodes.size(); }
+    int arcNum() const { return arcs.size(); }
+
+    int maxNodeId() const { return nodes.size()-1; }
+    int maxArcId() const { return arcs.size()-1; }
 
     Node addNode() {
-      int n = _nodes.size();
-      _nodes.push_back(NodeT());
-      _nodes[n].first_in = -1;
-      _nodes[n].first_out = -1;
+      int n = nodes.size();
+      nodes.push_back(NodeT());
+      nodes[n].first_in = -1;
+      nodes[n].first_out = -1;
       return Node(n);
     }
 
     Arc addArc(Node u, Node v) {
-      int n = _arcs.size();
-      _arcs.push_back(ArcT());
-      _arcs[n].source = u._id;
-      _arcs[n].target = v._id;
-      _arcs[n].next_out = _nodes[u._id].first_out;
-      _arcs[n].next_in = _nodes[v._id].first_in;
-      _nodes[u._id].first_out = _nodes[v._id].first_in = n;
+      int n = arcs.size();
+      arcs.push_back(ArcT());
+      arcs[n].source = u._id;
+      arcs[n].target = v._id;
+      arcs[n].next_out = nodes[u._id].first_out;
+      arcs[n].next_in = nodes[v._id].first_in;
+      nodes[u._id].first_out = nodes[v._id].first_in = n;
 
       return Arc(n);
@@ -94,10 +94,10 @@
 
     void clear() {
-      _arcs.clear();
-      _nodes.clear();
-    }
-
-    Node source(Arc a) const { return Node(_arcs[a._id].source); }
-    Node target(Arc a) const { return Node(_arcs[a._id].target); }
+      arcs.clear();
+      nodes.clear();
+    }
+
+    Node source(Arc a) const { return Node(arcs[a._id].source); }
+    Node target(Arc a) const { return Node(arcs[a._id].target); }
 
     static int id(Node v) { return v._id; }
@@ -108,8 +108,8 @@
 
     bool valid(Node n) const {
-      return n._id >= 0 && n._id < static_cast<int>(_nodes.size());
+      return n._id >= 0 && n._id < static_cast<int>(nodes.size());
     }
     bool valid(Arc a) const {
-      return a._id >= 0 && a._id < static_cast<int>(_arcs.size());
+      return a._id >= 0 && a._id < static_cast<int>(arcs.size());
     }
 
@@ -146,5 +146,5 @@
 
     void first(Node& node) const {
-      node._id = _nodes.size() - 1;
+      node._id = nodes.size() - 1;
     }
 
@@ -154,5 +154,5 @@
 
     void first(Arc& arc) const {
-      arc._id = _arcs.size() - 1;
+      arc._id = arcs.size() - 1;
     }
 
@@ -162,17 +162,17 @@
 
     void firstOut(Arc& arc, const Node& node) const {
-      arc._id = _nodes[node._id].first_out;
+      arc._id = nodes[node._id].first_out;
     }
 
     void nextOut(Arc& arc) const {
-      arc._id = _arcs[arc._id].next_out;
+      arc._id = arcs[arc._id].next_out;
     }
 
     void firstIn(Arc& arc, const Node& node) const {
-      arc._id = _nodes[node._id].first_in;
+      arc._id = nodes[node._id].first_in;
     }
 
     void nextIn(Arc& arc) const {
-      arc._id = _arcs[arc._id].next_in;
+      arc._id = arcs[arc._id].next_in;
     }
 
@@ -267,8 +267,8 @@
     {
       Node b = addNode();
-      _nodes[b._id].first_out=_nodes[n._id].first_out;
-      _nodes[n._id].first_out=-1;
-      for(int i=_nodes[b._id].first_out; i!=-1; i=_arcs[i].next_out) {
-        _arcs[i].source=b._id;
+      nodes[b._id].first_out=nodes[n._id].first_out;
+      nodes[n._id].first_out=-1;
+      for(int i=nodes[b._id].first_out; i!=-1; i=arcs[i].next_out) {
+        arcs[i].source=b._id;
       }
       if(connect) addArc(n,b);
@@ -292,5 +292,5 @@
     /// to build the digraph.
     /// \sa reserveArc()
-    void reserveNode(int n) { _nodes.reserve(n); };
+    void reserveNode(int n) { nodes.reserve(n); };
 
     /// Reserve memory for arcs.
@@ -302,5 +302,5 @@
     /// to build the digraph.
     /// \sa reserveNode()
-    void reserveArc(int m) { _arcs.reserve(m); };
+    void reserveArc(int m) { arcs.reserve(m); };
 
   public:
@@ -312,15 +312,15 @@
     void restoreSnapshot(const Snapshot &s)
     {
-      while(s.arc_num<_arcs.size()) {
-        Arc arc = arcFromId(_arcs.size()-1);
+      while(s.arc_num<arcs.size()) {
+        Arc arc = arcFromId(arcs.size()-1);
         Parent::notifier(Arc()).erase(arc);
-        _nodes[_arcs.back().source].first_out=_arcs.back().next_out;
-        _nodes[_arcs.back().target].first_in=_arcs.back().next_in;
-        _arcs.pop_back();
-      }
-      while(s.node_num<_nodes.size()) {
-        Node node = nodeFromId(_nodes.size()-1);
+        nodes[arcs.back().source].first_out=arcs.back().next_out;
+        nodes[arcs.back().target].first_in=arcs.back().next_in;
+        arcs.pop_back();
+      }
+      while(s.node_num<nodes.size()) {
+        Node node = nodeFromId(nodes.size()-1);
         Parent::notifier(Node()).erase(node);
-        _nodes.pop_back();
+        nodes.pop_back();
       }
     }
@@ -363,6 +363,6 @@
       ///
       Snapshot(SmartDigraph &gr) : _graph(&gr) {
-        node_num=_graph->_nodes.size();
-        arc_num=_graph->_arcs.size();
+        node_num=_graph->nodes.size();
+        arc_num=_graph->arcs.size();
       }
 
@@ -374,6 +374,6 @@
       void save(SmartDigraph &gr) {
         _graph=&gr;
-        node_num=_graph->_nodes.size();
-        arc_num=_graph->_arcs.size();
+        node_num=_graph->nodes.size();
+        arc_num=_graph->arcs.size();
       }
 
@@ -403,6 +403,6 @@
     };
 
-    std::vector<NodeT> _nodes;
-    std::vector<ArcT> _arcs;
+    std::vector<NodeT> nodes;
+    std::vector<ArcT> arcs;
 
   public:
@@ -466,5 +466,5 @@
 
     SmartGraphBase()
-      : _nodes(), _arcs() {}
+      : nodes(), arcs() {}
 
     typedef True NodeNumTag;
@@ -472,17 +472,17 @@
     typedef True ArcNumTag;
 
-    int nodeNum() const { return _nodes.size(); }
-    int edgeNum() const { return _arcs.size() / 2; }
-    int arcNum() const { return _arcs.size(); }
-
-    int maxNodeId() const { return _nodes.size()-1; }
-    int maxEdgeId() const { return _arcs.size() / 2 - 1; }
-    int maxArcId() const { return _arcs.size()-1; }
-
-    Node source(Arc e) const { return Node(_arcs[e._id ^ 1].target); }
-    Node target(Arc e) const { return Node(_arcs[e._id].target); }
-
-    Node u(Edge e) const { return Node(_arcs[2 * e._id].target); }
-    Node v(Edge e) const { return Node(_arcs[2 * e._id + 1].target); }
+    int nodeNum() const { return nodes.size(); }
+    int edgeNum() const { return arcs.size() / 2; }
+    int arcNum() const { return arcs.size(); }
+
+    int maxNodeId() const { return nodes.size()-1; }
+    int maxEdgeId() const { return arcs.size() / 2 - 1; }
+    int maxArcId() const { return arcs.size()-1; }
+
+    Node source(Arc e) const { return Node(arcs[e._id ^ 1].target); }
+    Node target(Arc e) const { return Node(arcs[e._id].target); }
+
+    Node u(Edge e) const { return Node(arcs[2 * e._id].target); }
+    Node v(Edge e) const { return Node(arcs[2 * e._id + 1].target); }
 
     static bool direction(Arc e) {
@@ -495,5 +495,5 @@
 
     void first(Node& node) const {
-      node._id = _nodes.size() - 1;
+      node._id = nodes.size() - 1;
     }
 
@@ -503,5 +503,5 @@
 
     void first(Arc& arc) const {
-      arc._id = _arcs.size() - 1;
+      arc._id = arcs.size() - 1;
     }
 
@@ -511,5 +511,5 @@
 
     void first(Edge& arc) const {
-      arc._id = _arcs.size() / 2 - 1;
+      arc._id = arcs.size() / 2 - 1;
     }
 
@@ -519,21 +519,21 @@
 
     void firstOut(Arc &arc, const Node& v) const {
-      arc._id = _nodes[v._id].first_out;
+      arc._id = nodes[v._id].first_out;
     }
     void nextOut(Arc &arc) const {
-      arc._id = _arcs[arc._id].next_out;
+      arc._id = arcs[arc._id].next_out;
     }
 
     void firstIn(Arc &arc, const Node& v) const {
-      arc._id = ((_nodes[v._id].first_out) ^ 1);
+      arc._id = ((nodes[v._id].first_out) ^ 1);
       if (arc._id == -2) arc._id = -1;
     }
     void nextIn(Arc &arc) const {
-      arc._id = ((_arcs[arc._id ^ 1].next_out) ^ 1);
+      arc._id = ((arcs[arc._id ^ 1].next_out) ^ 1);
       if (arc._id == -2) arc._id = -1;
     }
 
     void firstInc(Edge &arc, bool& d, const Node& v) const {
-      int de = _nodes[v._id].first_out;
+      int de = nodes[v._id].first_out;
       if (de != -1) {
         arc._id = de / 2;
@@ -545,5 +545,5 @@
     }
     void nextInc(Edge &arc, bool& d) const {
-      int de = (_arcs[(arc._id * 2) | (d ? 1 : 0)].next_out);
+      int de = (arcs[(arc._id * 2) | (d ? 1 : 0)].next_out);
       if (de != -1) {
         arc._id = de / 2;
@@ -564,17 +564,17 @@
 
     bool valid(Node n) const {
-      return n._id >= 0 && n._id < static_cast<int>(_nodes.size());
+      return n._id >= 0 && n._id < static_cast<int>(nodes.size());
     }
     bool valid(Arc a) const {
-      return a._id >= 0 && a._id < static_cast<int>(_arcs.size());
+      return a._id >= 0 && a._id < static_cast<int>(arcs.size());
     }
     bool valid(Edge e) const {
-      return e._id >= 0 && 2 * e._id < static_cast<int>(_arcs.size());
+      return e._id >= 0 && 2 * e._id < static_cast<int>(arcs.size());
     }
 
     Node addNode() {
-      int n = _nodes.size();
-      _nodes.push_back(NodeT());
-      _nodes[n].first_out = -1;
+      int n = nodes.size();
+      nodes.push_back(NodeT());
+      nodes[n].first_out = -1;
 
       return Node(n);
@@ -582,16 +582,16 @@
 
     Edge addEdge(Node u, Node v) {
-      int n = _arcs.size();
-      _arcs.push_back(ArcT());
-      _arcs.push_back(ArcT());
-
-      _arcs[n].target = u._id;
-      _arcs[n | 1].target = v._id;
-
-      _arcs[n].next_out = _nodes[v._id].first_out;
-      _nodes[v._id].first_out = n;
-
-      _arcs[n | 1].next_out = _nodes[u._id].first_out;
-      _nodes[u._id].first_out = (n | 1);
+      int n = arcs.size();
+      arcs.push_back(ArcT());
+      arcs.push_back(ArcT());
+
+      arcs[n].target = u._id;
+      arcs[n | 1].target = v._id;
+
+      arcs[n].next_out = nodes[v._id].first_out;
+      nodes[v._id].first_out = n;
+
+      arcs[n | 1].next_out = nodes[u._id].first_out;
+      nodes[u._id].first_out = (n | 1);
 
       return Edge(n / 2);
@@ -599,6 +599,6 @@
 
     void clear() {
-      _arcs.clear();
-      _nodes.clear();
+      arcs.clear();
+      nodes.clear();
     }
 
@@ -702,5 +702,5 @@
     /// to build the graph.
     /// \sa reserveEdge()
-    void reserveNode(int n) { _nodes.reserve(n); };
+    void reserveNode(int n) { nodes.reserve(n); };
 
     /// Reserve memory for edges.
@@ -712,5 +712,5 @@
     /// to build the graph.
     /// \sa reserveNode()
-    void reserveEdge(int m) { _arcs.reserve(2 * m); };
+    void reserveEdge(int m) { arcs.reserve(2 * m); };
 
   public:
@@ -723,12 +723,12 @@
     {
       s._graph = this;
-      s.node_num = _nodes.size();
-      s.arc_num = _arcs.size();
+      s.node_num = nodes.size();
+      s.arc_num = arcs.size();
     }
 
     void restoreSnapshot(const Snapshot &s)
     {
-      while(s.arc_num<_arcs.size()) {
-        int n=_arcs.size()-1;
+      while(s.arc_num<arcs.size()) {
+        int n=arcs.size()-1;
         Edge arc=edgeFromId(n/2);
         Parent::notifier(Edge()).erase(arc);
@@ -737,14 +737,14 @@
         dir.push_back(arcFromId(n-1));
         Parent::notifier(Arc()).erase(dir);
-        _nodes[_arcs[n-1].target].first_out=_arcs[n].next_out;
-        _nodes[_arcs[n].target].first_out=_arcs[n-1].next_out;
-        _arcs.pop_back();
-        _arcs.pop_back();
-      }
-      while(s.node_num<_nodes.size()) {
-        int n=_nodes.size()-1;
+        nodes[arcs[n-1].target].first_out=arcs[n].next_out;
+        nodes[arcs[n].target].first_out=arcs[n-1].next_out;
+        arcs.pop_back();
+        arcs.pop_back();
+      }
+      while(s.node_num<nodes.size()) {
+        int n=nodes.size()-1;
         Node node = nodeFromId(n);
         Parent::notifier(Node()).erase(node);
-        _nodes.pop_back();
+        nodes.pop_back();
       }
     }
@@ -826,6 +826,6 @@
     };
 
-    std::vector<NodeT> _nodes;
-    std::vector<ArcT> _arcs;
+    std::vector<NodeT> nodes;
+    std::vector<ArcT> arcs;
 
     int first_red, first_blue;
@@ -916,5 +916,5 @@
 
     SmartBpGraphBase()
-      : _nodes(), _arcs(), first_red(-1), first_blue(-1),
+      : nodes(), arcs(), first_red(-1), first_blue(-1),
         max_red(-1), max_blue(-1) {}
 
@@ -923,30 +923,30 @@
     typedef True ArcNumTag;
 
-    int nodeNum() const { return _nodes.size(); }
+    int nodeNum() const { return nodes.size(); }
     int redNum() const { return max_red + 1; }
     int blueNum() const { return max_blue + 1; }
-    int edgeNum() const { return _arcs.size() / 2; }
-    int arcNum() const { return _arcs.size(); }
-
-    int maxNodeId() const { return _nodes.size()-1; }
+    int edgeNum() const { return arcs.size() / 2; }
+    int arcNum() const { return arcs.size(); }
+
+    int maxNodeId() const { return nodes.size()-1; }
     int maxRedId() const { return max_red; }
     int maxBlueId() const { return max_blue; }
-    int maxEdgeId() const { return _arcs.size() / 2 - 1; }
-    int maxArcId() const { return _arcs.size()-1; }
-
-    bool red(Node n) const { return _nodes[n._id].red; }
-    bool blue(Node n) const { return !_nodes[n._id].red; }
+    int maxEdgeId() const { return arcs.size() / 2 - 1; }
+    int maxArcId() const { return arcs.size()-1; }
+
+    bool red(Node n) const { return nodes[n._id].red; }
+    bool blue(Node n) const { return !nodes[n._id].red; }
 
     static RedNode asRedNodeUnsafe(Node n) { return RedNode(n._id); }
     static BlueNode asBlueNodeUnsafe(Node n) { return BlueNode(n._id); }
 
-    Node source(Arc a) const { return Node(_arcs[a._id ^ 1].target); }
-    Node target(Arc a) const { return Node(_arcs[a._id].target); }
+    Node source(Arc a) const { return Node(arcs[a._id ^ 1].target); }
+    Node target(Arc a) const { return Node(arcs[a._id].target); }
 
     RedNode redNode(Edge e) const {
-      return RedNode(_arcs[2 * e._id].target);
+      return RedNode(arcs[2 * e._id].target);
     }
     BlueNode blueNode(Edge e) const {
-      return BlueNode(_arcs[2 * e._id + 1].target);
+      return BlueNode(arcs[2 * e._id + 1].target);
     }
 
@@ -960,5 +960,5 @@
 
     void first(Node& node) const {
-      node._id = _nodes.size() - 1;
+      node._id = nodes.size() - 1;
     }
 
@@ -972,5 +972,5 @@
 
     void next(RedNode& node) const {
-      node._id = _nodes[node._id].partition_next;
+      node._id = nodes[node._id].partition_next;
     }
 
@@ -980,9 +980,9 @@
 
     void next(BlueNode& node) const {
-      node._id = _nodes[node._id].partition_next;
+      node._id = nodes[node._id].partition_next;
     }
 
     void first(Arc& arc) const {
-      arc._id = _arcs.size() - 1;
+      arc._id = arcs.size() - 1;
     }
 
@@ -992,5 +992,5 @@
 
     void first(Edge& arc) const {
-      arc._id = _arcs.size() / 2 - 1;
+      arc._id = arcs.size() / 2 - 1;
     }
 
@@ -1000,21 +1000,21 @@
 
     void firstOut(Arc &arc, const Node& v) const {
-      arc._id = _nodes[v._id].first_out;
+      arc._id = nodes[v._id].first_out;
     }
     void nextOut(Arc &arc) const {
-      arc._id = _arcs[arc._id].next_out;
+      arc._id = arcs[arc._id].next_out;
     }
 
     void firstIn(Arc &arc, const Node& v) const {
-      arc._id = ((_nodes[v._id].first_out) ^ 1);
+      arc._id = ((nodes[v._id].first_out) ^ 1);
       if (arc._id == -2) arc._id = -1;
     }
     void nextIn(Arc &arc) const {
-      arc._id = ((_arcs[arc._id ^ 1].next_out) ^ 1);
+      arc._id = ((arcs[arc._id ^ 1].next_out) ^ 1);
       if (arc._id == -2) arc._id = -1;
     }
 
     void firstInc(Edge &arc, bool& d, const Node& v) const {
-      int de = _nodes[v._id].first_out;
+      int de = nodes[v._id].first_out;
       if (de != -1) {
         arc._id = de / 2;
@@ -1026,5 +1026,5 @@
     }
     void nextInc(Edge &arc, bool& d) const {
-      int de = (_arcs[(arc._id * 2) | (d ? 1 : 0)].next_out);
+      int de = (arcs[(arc._id * 2) | (d ? 1 : 0)].next_out);
       if (de != -1) {
         arc._id = de / 2;
@@ -1037,6 +1037,6 @@
 
     static int id(Node v) { return v._id; }
-    int id(RedNode v) const { return _nodes[v._id].partition_index; }
-    int id(BlueNode v) const { return _nodes[v._id].partition_index; }
+    int id(RedNode v) const { return nodes[v._id].partition_index; }
+    int id(BlueNode v) const { return nodes[v._id].partition_index; }
     static int id(Arc e) { return e._id; }
     static int id(Edge e) { return e._id; }
@@ -1047,20 +1047,20 @@
 
     bool valid(Node n) const {
-      return n._id >= 0 && n._id < static_cast<int>(_nodes.size());
+      return n._id >= 0 && n._id < static_cast<int>(nodes.size());
     }
     bool valid(Arc a) const {
-      return a._id >= 0 && a._id < static_cast<int>(_arcs.size());
+      return a._id >= 0 && a._id < static_cast<int>(arcs.size());
     }
     bool valid(Edge e) const {
-      return e._id >= 0 && 2 * e._id < static_cast<int>(_arcs.size());
+      return e._id >= 0 && 2 * e._id < static_cast<int>(arcs.size());
     }
 
     RedNode addRedNode() {
-      int n = _nodes.size();
-      _nodes.push_back(NodeT());
-      _nodes[n].first_out = -1;
-      _nodes[n].red = true;
-      _nodes[n].partition_index = ++max_red;
-      _nodes[n].partition_next = first_red;
+      int n = nodes.size();
+      nodes.push_back(NodeT());
+      nodes[n].first_out = -1;
+      nodes[n].red = true;
+      nodes[n].partition_index = ++max_red;
+      nodes[n].partition_next = first_red;
       first_red = n;
 
@@ -1069,10 +1069,10 @@
 
     BlueNode addBlueNode() {
-      int n = _nodes.size();
-      _nodes.push_back(NodeT());
-      _nodes[n].first_out = -1;
-      _nodes[n].red = false;
-      _nodes[n].partition_index = ++max_blue;
-      _nodes[n].partition_next = first_blue;
+      int n = nodes.size();
+      nodes.push_back(NodeT());
+      nodes[n].first_out = -1;
+      nodes[n].red = false;
+      nodes[n].partition_index = ++max_blue;
+      nodes[n].partition_next = first_blue;
       first_blue = n;
 
@@ -1081,16 +1081,16 @@
 
     Edge addEdge(RedNode u, BlueNode v) {
-      int n = _arcs.size();
-      _arcs.push_back(ArcT());
-      _arcs.push_back(ArcT());
-
-      _arcs[n].target = u._id;
-      _arcs[n | 1].target = v._id;
-
-      _arcs[n].next_out = _nodes[v._id].first_out;
-      _nodes[v._id].first_out = n;
-
-      _arcs[n | 1].next_out = _nodes[u._id].first_out;
-      _nodes[u._id].first_out = (n | 1);
+      int n = arcs.size();
+      arcs.push_back(ArcT());
+      arcs.push_back(ArcT());
+
+      arcs[n].target = u._id;
+      arcs[n | 1].target = v._id;
+
+      arcs[n].next_out = nodes[v._id].first_out;
+      nodes[v._id].first_out = n;
+
+      arcs[n | 1].next_out = nodes[u._id].first_out;
+      nodes[u._id].first_out = (n | 1);
 
       return Edge(n / 2);
@@ -1098,6 +1098,6 @@
 
     void clear() {
-      _arcs.clear();
-      _nodes.clear();
+      arcs.clear();
+      nodes.clear();
       first_red = -1;
       first_blue = -1;
@@ -1214,5 +1214,5 @@
     /// to build the graph.
     /// \sa reserveEdge()
-    void reserveNode(int n) { _nodes.reserve(n); };
+    void reserveNode(int n) { nodes.reserve(n); };
 
     /// Reserve memory for edges.
@@ -1224,5 +1224,5 @@
     /// to build the graph.
     /// \sa reserveNode()
-    void reserveEdge(int m) { _arcs.reserve(2 * m); };
+    void reserveEdge(int m) { arcs.reserve(2 * m); };
 
   public:
@@ -1235,12 +1235,12 @@
     {
       s._graph = this;
-      s.node_num = _nodes.size();
-      s.arc_num = _arcs.size();
+      s.node_num = nodes.size();
+      s.arc_num = arcs.size();
     }
 
     void restoreSnapshot(const Snapshot &s)
     {
-      while(s.arc_num<_arcs.size()) {
-        int n=_arcs.size()-1;
+      while(s.arc_num<arcs.size()) {
+        int n=arcs.size()-1;
         Edge arc=edgeFromId(n/2);
         Parent::notifier(Edge()).erase(arc);
@@ -1249,16 +1249,16 @@
         dir.push_back(arcFromId(n-1));
         Parent::notifier(Arc()).erase(dir);
-        _nodes[_arcs[n-1].target].first_out=_arcs[n].next_out;
-        _nodes[_arcs[n].target].first_out=_arcs[n-1].next_out;
-        _arcs.pop_back();
-        _arcs.pop_back();
-      }
-      while(s.node_num<_nodes.size()) {
-        int n=_nodes.size()-1;
+        nodes[arcs[n-1].target].first_out=arcs[n].next_out;
+        nodes[arcs[n].target].first_out=arcs[n-1].next_out;
+        arcs.pop_back();
+        arcs.pop_back();
+      }
+      while(s.node_num<nodes.size()) {
+        int n=nodes.size()-1;
         Node node = nodeFromId(n);
         if (Parent::red(node)) {
-          first_red = _nodes[n].partition_next;
+          first_red = nodes[n].partition_next;
           if (first_red != -1) {
-            max_red = _nodes[first_red].partition_index;
+            max_red = nodes[first_red].partition_index;
           } else {
             max_red = -1;
@@ -1266,7 +1266,7 @@
           Parent::notifier(RedNode()).erase(asRedNodeUnsafe(node));
         } else {
-          first_blue = _nodes[n].partition_next;
+          first_blue = nodes[n].partition_next;
           if (first_blue != -1) {
-            max_blue = _nodes[first_blue].partition_index;
+            max_blue = nodes[first_blue].partition_index;
           } else {
             max_blue = -1;
@@ -1275,5 +1275,5 @@
         }
         Parent::notifier(Node()).erase(node);
-        _nodes.pop_back();
+        nodes.pop_back();
       }
     }
Index: lemon/soplex.cc
===================================================================
--- lemon/soplex.cc	(revision 1336)
+++ lemon/soplex.cc	(revision 1270)
@@ -38,6 +38,6 @@
 
   SoplexLp::SoplexLp(const SoplexLp& lp) {
-    _rows = lp._rows;
-    _cols = lp._cols;
+    rows = lp.rows;
+    cols = lp.cols;
 
     soplex = new soplex::SoPlex;
@@ -123,10 +123,10 @@
 
   void SoplexLp::_eraseColId(int i) {
-    _cols.eraseIndex(i);
-    _cols.relocateIndex(i, _cols.maxIndex());
+    cols.eraseIndex(i);
+    cols.relocateIndex(i, cols.maxIndex());
   }
   void SoplexLp::_eraseRowId(int i) {
-    _rows.eraseIndex(i);
-    _rows.relocateIndex(i, _rows.maxIndex());
+    rows.eraseIndex(i);
+    rows.relocateIndex(i, rows.maxIndex());
   }
 
@@ -433,6 +433,6 @@
     _row_names.clear();
     _row_names_ref.clear();
-    _cols.clear();
-    _rows.clear();
+    cols.clear();
+    rows.clear();
     _clear_temporals();
   }
Index: lemon/static_graph.h
===================================================================
--- lemon/static_graph.h	(revision 1328)
+++ lemon/static_graph.h	(revision 956)
@@ -204,5 +204,5 @@
 
       node_num = n;
-      arc_num = static_cast<int>(std::distance(first, last));
+      arc_num = std::distance(first, last);
 
       node_first_out = new int[node_num + 1];
Index: lemon/time_measure.h
===================================================================
--- lemon/time_measure.h	(revision 1340)
+++ lemon/time_measure.h	(revision 1270)
@@ -24,7 +24,5 @@
 ///\brief Tools for measuring cpu usage
 
-#include <lemon/config.h>
-
-#ifdef LEMON_WIN32
+#ifdef WIN32
 #include <lemon/bits/windows.h>
 #else
@@ -105,5 +103,5 @@
     void stamp()
     {
-#ifndef LEMON_WIN32
+#ifndef WIN32
       timeval tv;
       gettimeofday(&tv, 0);
Index: mon/vf2.h
===================================================================
--- lemon/vf2.h	(revision 1366)
+++ 	(revision )
@@ -1,667 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2015
- * EMAXA Kutato-fejleszto Kft. (EMAXA Research Ltd.)
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_VF2_H
-#define LEMON_VF2_H
-
-///\ingroup graph_properties
-///\file
-///\brief VF2 algorithm \cite cordella2004sub.
-
-#include <lemon/core.h>
-#include <lemon/concepts/graph.h>
-#include <lemon/dfs.h>
-#include <lemon/bfs.h>
-#include <test/test_tools.h>
-
-#include <vector>
-#include <set>
-
-namespace lemon
-{
-  namespace bits
-  {
-    namespace vf2
-    {
-      class AlwaysEq
-      {
-      public:
-        template<class T1, class T2>
-        bool operator()(T1, T2) const
-        {
-          return true;
-        }
-      };
-
-      template<class M1, class M2>
-      class MapEq
-      {
-        const M1 &_m1;
-        const M2 &_m2;
-      public:
-        MapEq(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
-        bool operator()(typename M1::Key k1, typename M2::Key k2) const
-        {
-          return _m1[k1] == _m2[k2];
-        }
-      };
-
-      template <class G>
-      class DfsLeaveOrder : public DfsVisitor<G>
-      {
-        const G &_g;
-        std::vector<typename G::Node> &_order;
-        int i;
-      public:
-        DfsLeaveOrder(const G &g, std::vector<typename G::Node> &order)
-          : i(countNodes(g)), _g(g), _order(order)
-        {}
-        void leave(const typename G::Node &node)
-        {
-          _order[--i]=node;
-        }
-      };
-
-      template <class G>
-      class BfsLeaveOrder : public BfsVisitor<G>
-      {
-        int i;
-        const G &_g;
-        std::vector<typename G::Node> &_order;
-      public:
-        BfsLeaveOrder(const G &g, std::vector<typename G::Node> &order)
-          : i(0), _g(g), _order(order)
-        {}
-        void process(const typename G::Node &node)
-        {
-          _order[i++]=node;
-        }
-      };
-    }
-  }
-
-  ///Graph mapping types.
-
-  ///\ingroup graph_isomorphism
-  ///The \ref Vf2 "VF2" algorithm is capable of finding different kind of
-  ///embeddings, this enum specifies its type.
-  ///
-  ///See \ref graph_isomorphism for a more detailed description.
-  enum Vf2MappingType {
-    /// Subgraph isomorphism
-    SUBGRAPH = 0,
-    /// Induced subgraph isomorphism
-    INDUCED = 1,
-    /// Graph isomorphism
-
-    /// If the two graph has the same number of nodes, than it is
-    /// equivalent to \ref INDUCED, and if they also have the same
-    /// number of edges, then it is also equivalent to \ref SUBGRAPH.
-    ///
-    /// However, using this setting is faster than the other two
-    /// options.
-    ISOMORPH = 2
-  };
-
-  ///%VF2 algorithm class.
-
-  ///\ingroup graph_isomorphism This class provides an efficient
-  ///implementation of the %VF2 algorithm \cite cordella2004sub
-  ///for variants of the (Sub)graph Isomorphism problem.
-  ///
-  ///There is also a \ref vf2() "function-type interface" called \ref vf2()
-  ///for the %VF2 algorithm, which is probably more convenient in most
-  ///use-cases.
-  ///
-  ///\tparam G1 The type of the graph to be embedded.
-  ///The default type is \ref ListDigraph.
-  ///\tparam G2 The type of the graph g1 will be embedded into.
-  ///The default type is \ref ListDigraph.
-  ///\tparam M The type of the NodeMap storing the mapping.
-  ///By default, it is G1::NodeMap<G2::Node>
-  ///\tparam NEQ A bool-valued binary functor determinining whether a node is
-  ///mappable to another. By default it is an always true operator.
-  ///
-  ///\sa vf2()
-#ifdef DOXYGEN
-  template<class G1, class G2, class M, class NEQ >
-#else
-  template<class G1=ListDigraph,
-           class G2=ListDigraph,
-           class M = typename G1::template NodeMap<G2::Node>,
-           class NEQ = bits::vf2::AlwaysEq >
-#endif
-  class Vf2
-  {
-    //Current depth in the DFS tree.
-    int _depth;
-    //Functor with bool operator()(G1::Node,G2::Node), which returns 1
-    //if and only if the 2 nodes are equivalent.
-    NEQ _nEq;
-
-    typename G2::template NodeMap<int> _conn;
-    //Current mapping. We index it by the nodes of g1, and match[v] is
-    //a node of g2.
-    M &_mapping;
-    //order[i] is the node of g1, for which we find a pair if depth=i
-    std::vector<typename G1::Node> order;
-    //currEdgeIts[i] is an edge iterator, witch is last used in the ith
-    //depth to find a pair for order[i].
-    std::vector<typename G2::IncEdgeIt> currEdgeIts;
-    //The small graph.
-    const G1 &_g1;
-    //The big graph.
-    const G2 &_g2;
-    //lookup tables for cut the searchtree
-    typename G1::template NodeMap<int> rNew1t,rInOut1t;
-
-    Vf2MappingType _mapping_type;
-
-    //cut the search tree
-    template<Vf2MappingType MT>
-    bool cut(const typename G1::Node n1,const typename G2::Node n2) const
-    {
-      int rNew2=0,rInOut2=0;
-      for(typename G2::IncEdgeIt e2(_g2,n2); e2!=INVALID; ++e2)
-        {
-          const typename G2::Node currNode=_g2.oppositeNode(n2,e2);
-          if(_conn[currNode]>0)
-            ++rInOut2;
-          else if(MT!=SUBGRAPH&&_conn[currNode]==0)
-            ++rNew2;
-        }
-      switch(MT)
-        {
-        case INDUCED:
-          return rInOut1t[n1]<=rInOut2&&rNew1t[n1]<=rNew2;
-        case SUBGRAPH:
-          return rInOut1t[n1]<=rInOut2;
-        case ISOMORPH:
-          return rInOut1t[n1]==rInOut2&&rNew1t[n1]==rNew2;
-        default:
-          return false;
-        }
-    }
-
-    template<Vf2MappingType MT>
-    bool feas(const typename G1::Node n1,const typename G2::Node n2)
-    {
-      if(!_nEq(n1,n2))
-        return 0;
-
-      for(typename G1::IncEdgeIt e1(_g1,n1); e1!=INVALID; ++e1)
-        {
-          const typename G1::Node currNode=_g1.oppositeNode(n1,e1);
-          if(_mapping[currNode]!=INVALID)
-            --_conn[_mapping[currNode]];
-        }
-      bool isIso=1;
-      for(typename G2::IncEdgeIt e2(_g2,n2); e2!=INVALID; ++e2)
-        {
-          const typename G2::Node currNode=_g2.oppositeNode(n2,e2);
-          if(_conn[currNode]<-1)
-            ++_conn[currNode];
-          else if(MT!=SUBGRAPH&&_conn[currNode]==-1)
-            {
-              isIso=0;
-              break;
-            }
-        }
-
-      for(typename G1::IncEdgeIt e1(_g1,n1); e1!=INVALID; ++e1)
-        {
-          const typename G1::Node currNode=_g1.oppositeNode(n1,e1);
-          if(_mapping[currNode]!=INVALID&&_conn[_mapping[currNode]]!=-1)
-            {
-              switch(MT)
-                {
-                case INDUCED:
-                case ISOMORPH:
-                  isIso=0;
-                  break;
-                case SUBGRAPH:
-                  if(_conn[_mapping[currNode]]<-1)
-                    isIso=0;
-                  break;
-                }
-              _conn[_mapping[currNode]]=-1;
-            }
-        }
-      return isIso&&cut<MT>(n1,n2);
-    }
-
-    void addPair(const typename G1::Node n1,const typename G2::Node n2)
-    {
-      _conn[n2]=-1;
-      _mapping.set(n1,n2);
-      for(typename G2::IncEdgeIt e2(_g2,n2); e2!=INVALID; ++e2)
-        if(_conn[_g2.oppositeNode(n2,e2)]!=-1)
-          ++_conn[_g2.oppositeNode(n2,e2)];
-    }
-
-    void subPair(const typename G1::Node n1,const typename G2::Node n2)
-    {
-      _conn[n2]=0;
-      _mapping.set(n1,INVALID);
-      for(typename G2::IncEdgeIt e2(_g2,n2); e2!=INVALID; ++e2)
-        {
-          const typename G2::Node currNode=_g2.oppositeNode(n2,e2);
-          if(_conn[currNode]>0)
-            --_conn[currNode];
-          else if(_conn[currNode]==-1)
-            ++_conn[n2];
-        }
-    }
-
-    void setOrder()//we will find pairs for the nodes of g1 in this order
-    {
-      // bits::vf2::DfsLeaveOrder<G1> v(_g1,order);
-      //   DfsVisit<G1,bits::vf2::DfsLeaveOrder<G1> >dfs(_g1, v);
-      //   dfs.run();
-
-      //it is more efficient in practice than DFS
-      bits::vf2::BfsLeaveOrder<G1> v(_g1,order);
-      BfsVisit<G1,bits::vf2::BfsLeaveOrder<G1> >bfs(_g1, v);
-      bfs.run();
-    }
-
-    template<Vf2MappingType MT>
-    bool extMatch()
-    {
-      while(_depth>=0)
-        {
-          //there are not nodes in g1, which has not pair in g2.
-          if(_depth==static_cast<int>(order.size()))
-            {
-              --_depth;
-              return true;
-            }
-          //the node of g2, which neighbours are the candidates for
-          //the pair of order[_depth]
-          typename G2::Node currPNode;
-          if(currEdgeIts[_depth]==INVALID)
-            {
-              typename G1::IncEdgeIt fstMatchedE(_g1,order[_depth]);
-              //if _mapping[order[_depth]]!=INVALID, we dont use
-              //fstMatchedE
-              if(_mapping[order[_depth]]==INVALID)
-                for(; fstMatchedE!=INVALID &&
-                      _mapping[_g1.oppositeNode(order[_depth],
-                                              fstMatchedE)]==INVALID;
-                    ++fstMatchedE) ; //find fstMatchedE
-              if(fstMatchedE==INVALID||_mapping[order[_depth]]!=INVALID)
-                {
-                  //We did not find an covered neighbour, this means
-                  //the graph is not connected(or _depth==0).  Every
-                  //uncovered(and there are some other properties due
-                  //to the spec. problem types) node of g2 is
-                  //candidate.  We can read the iterator of the last
-                  //tryed node from the match if it is not the first
-                  //try(match[order[_depth]]!=INVALID)
-                  typename G2::NodeIt n2(_g2);
-                  //if its not the first try
-                  if(_mapping[order[_depth]]!=INVALID)
-                    {
-                      n2=++typename G2::NodeIt(_g2,_mapping[order[_depth]]);
-                      subPair(order[_depth],_mapping[order[_depth]]);
-                    }
-                  for(; n2!=INVALID; ++n2)
-                    if(MT!=SUBGRAPH&&_conn[n2]==0)
-                      {
-                        if(feas<MT>(order[_depth],n2))
-                          break;
-                      }
-                    else if(MT==SUBGRAPH&&_conn[n2]>=0)
-                      if(feas<MT>(order[_depth],n2))
-                        break;
-                  // n2 is the next candidate
-                  if(n2!=INVALID)
-                    {
-                      addPair(order[_depth],n2);
-                      ++_depth;
-                    }
-                  else // there is no more candidate
-                    --_depth;
-                  continue;
-                }
-              else
-                {
-                  currPNode=_mapping[_g1.oppositeNode(order[_depth],
-                                                      fstMatchedE)];
-                  currEdgeIts[_depth]=typename G2::IncEdgeIt(_g2,currPNode);
-                }
-            }
-          else
-            {
-              currPNode=_g2.oppositeNode(_mapping[order[_depth]],
-                                         currEdgeIts[_depth]);
-              subPair(order[_depth],_mapping[order[_depth]]);
-              ++currEdgeIts[_depth];
-            }
-          for(; currEdgeIts[_depth]!=INVALID; ++currEdgeIts[_depth])
-            {
-              const typename G2::Node currNode =
-                _g2.oppositeNode(currPNode, currEdgeIts[_depth]);
-              //if currNode is uncovered
-              if(_conn[currNode]>0&&feas<MT>(order[_depth],currNode))
-                {
-                  addPair(order[_depth],currNode);
-                  break;
-                }
-            }
-          currEdgeIts[_depth]==INVALID?--_depth:++_depth;
-        }
-      return false;
-    }
-
-    //calc. the lookup table for cut the searchtree
-    void setRNew1tRInOut1t()
-    {
-      typename G1::template NodeMap<int> tmp(_g1,0);
-      for(unsigned int i=0; i<order.size(); ++i)
-        {
-          tmp[order[i]]=-1;
-          for(typename G1::IncEdgeIt e1(_g1,order[i]); e1!=INVALID; ++e1)
-            {
-              const typename G1::Node currNode=_g1.oppositeNode(order[i],e1);
-              if(tmp[currNode]>0)
-                ++rInOut1t[order[i]];
-              else if(tmp[currNode]==0)
-                ++rNew1t[order[i]];
-            }
-          for(typename G1::IncEdgeIt e1(_g1,order[i]); e1!=INVALID; ++e1)
-            {
-              const typename G1::Node currNode=_g1.oppositeNode(order[i],e1);
-              if(tmp[currNode]!=-1)
-                ++tmp[currNode];
-            }
-        }
-    }
-  public:
-    ///Constructor
-
-    ///Constructor
-
-    ///\param g1 The graph to be embedded into \e g2.
-    ///\param g2 The graph \e g1 will be embedded into.
-    ///\param m \ref concepts::ReadWriteMap "read-write" NodeMap
-    ///storing the found mapping.
-    ///\param neq A bool-valued binary functor determinining whether a node is
-    ///mappable to another. By default it is an always true operator.
-    Vf2(const G1 &g1, const G2 &g2,M &m, const NEQ &neq = NEQ() ) :
-      _nEq(neq), _conn(g2,0), _mapping(m), order(countNodes(g1)),
-      currEdgeIts(countNodes(g1),INVALID), _g1(g1), _g2(g2), rNew1t(g1,0),
-      rInOut1t(g1,0), _mapping_type(SUBGRAPH)
-    {
-      _depth=0;
-      setOrder();
-      setRNew1tRInOut1t();
-      for(typename G1::NodeIt n(g1);n!=INVALID;++n)
-        m[n]=INVALID;
-    }
-
-    ///Returns the current mapping type
-
-    ///Returns the current mapping type
-    ///
-    Vf2MappingType mappingType() const { return _mapping_type; }
-    ///Sets mapping type
-
-    ///Sets mapping type.
-    ///
-    ///The mapping type is set to \ref SUBGRAPH by default.
-    ///
-    ///\sa See \ref Vf2MappingType for the possible values.
-    void mappingType(Vf2MappingType m_type) { _mapping_type = m_type; }
-
-    ///Finds a mapping
-
-    ///It finds a mapping between from g1 into g2 according to the mapping
-    ///type set by \ref mappingType(Vf2MappingType) "mappingType()".
-    ///
-    ///By subsequent calls, it returns all possible mappings one-by-one.
-    ///
-    ///\retval true if a mapping is found.
-    ///\retval false if there is no (more) mapping.
-    bool find()
-    {
-      switch(_mapping_type)
-        {
-        case SUBGRAPH:
-          return extMatch<SUBGRAPH>();
-        case INDUCED:
-          return extMatch<INDUCED>();
-        case ISOMORPH:
-          return extMatch<ISOMORPH>();
-        default:
-          return false;
-        }
-    }
-  };
-
-  template<class G1, class G2>
-  class Vf2WizardBase
-  {
-  protected:
-    typedef G1 Graph1;
-    typedef G2 Graph2;
-
-    const G1 &_g1;
-    const G2 &_g2;
-
-    Vf2MappingType _mapping_type;
-
-    typedef typename G1::template NodeMap<typename G2::Node> Mapping;
-    bool _local_mapping;
-    void *_mapping;
-    void createMapping()
-    {
-      _mapping = new Mapping(_g1);
-    }
-
-    typedef bits::vf2::AlwaysEq NodeEq;
-    NodeEq _node_eq;
-
-    Vf2WizardBase(const G1 &g1,const G2 &g2)
-      : _g1(g1), _g2(g2), _mapping_type(SUBGRAPH), _local_mapping(true) {}
-  };
-
-  /// Auxiliary class for the function-type interface of %VF2 algorithm.
-
-  /// This auxiliary class implements the named parameters of
-  /// \ref vf2() "function-type interface" of \ref Vf2 algorithm.
-  ///
-  /// \warning This class should only be used through the function \ref vf2().
-  ///
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm.
-  template<class TR>
-  class Vf2Wizard : public TR
-  {
-    typedef TR Base;
-    typedef typename TR::Graph1 Graph1;
-    typedef typename TR::Graph2 Graph2;
-
-    typedef typename TR::Mapping Mapping;
-    typedef typename TR::NodeEq NodeEq;
-
-    using TR::_g1;
-    using TR::_g2;
-    using TR::_mapping_type;
-    using TR::_mapping;
-    using TR::_node_eq;
-
-  public:
-    ///Constructor
-    Vf2Wizard(const Graph1 &g1,const Graph2 &g2) : Base(g1,g2) {}
-
-    ///Copy constructor
-    Vf2Wizard(const Base &b) : Base(b) {}
-
-
-    template<class T>
-    struct SetMappingBase : public Base {
-      typedef T Mapping;
-      SetMappingBase(const Base &b) : Base(b) {}
-    };
-
-    ///\brief \ref named-templ-param "Named parameter" for setting
-    ///the mapping.
-    ///
-    ///\ref named-templ-param "Named parameter" function for setting
-    ///the map that stores the found embedding.
-    template<class T>
-    Vf2Wizard< SetMappingBase<T> > mapping(const T &t)
-    {
-      Base::_mapping=reinterpret_cast<void*>(const_cast<T*>(&t));
-      Base::_local_mapping = false;
-      return Vf2Wizard<SetMappingBase<T> >(*this);
-    }
-
-    template<class NE>
-    struct SetNodeEqBase : public Base {
-      typedef NE NodeEq;
-      NodeEq _node_eq;
-      SetNodeEqBase(const Base &b, const NE &node_eq)
-        : Base(b), _node_eq(node_eq) {}
-    };
-
-    ///\brief \ref named-templ-param "Named parameter" for setting
-    ///the node equivalence relation.
-    ///
-    ///\ref named-templ-param "Named parameter" function for setting
-    ///the equivalence relation between the nodes.
-    ///
-    ///\param node_eq A bool-valued binary functor determinining
-    ///whether a node is mappable to another. By default it is an
-    ///always true operator.
-    template<class T>
-    Vf2Wizard< SetNodeEqBase<T> > nodeEq(const T &node_eq)
-    {
-      return Vf2Wizard<SetNodeEqBase<T> >(SetNodeEqBase<T>(*this,node_eq));
-    }
-
-    ///\brief \ref named-templ-param "Named parameter" for setting
-    ///the node labels.
-    ///
-    ///\ref named-templ-param "Named parameter" function for setting
-    ///the node labels defining equivalence relation between them.
-    ///
-    ///\param m1 It is arbitrary \ref concepts::ReadMap "readable node map"
-    ///of g1.
-    ///\param m2 It is arbitrary \ref concepts::ReadMap "readable node map"
-    ///of g2.
-    ///
-    ///The value type of these maps must be equal comparable.
-    template<class M1, class M2>
-    Vf2Wizard< SetNodeEqBase<bits::vf2::MapEq<M1,M2> > >
-    nodeLabels(const M1 &m1,const M2 &m2)
-    {
-      return nodeEq(bits::vf2::MapEq<M1,M2>(m1,m2));
-    }
-
-    ///\brief \ref named-templ-param "Named parameter" for setting
-    ///the mapping type.
-    ///
-    ///\ref named-templ-param "Named parameter" for setting
-    ///the mapping type.
-    ///
-    ///The mapping type is set to \ref SUBGRAPH by default.
-    ///
-    ///\sa See \ref Vf2MappingType for the possible values.
-    Vf2Wizard<Base> &mappingType(Vf2MappingType m_type)
-    {
-      _mapping_type = m_type;
-      return *this;
-    }
-
-    ///\brief \ref named-templ-param "Named parameter" for setting
-    ///the mapping type to \ref INDUCED.
-    ///
-    ///\ref named-templ-param "Named parameter" for setting
-    ///the mapping type to \ref INDUCED.
-    Vf2Wizard<Base> &induced()
-    {
-      _mapping_type = INDUCED;
-      return *this;
-    }
-
-    ///\brief \ref named-templ-param "Named parameter" for setting
-    ///the mapping type to \ref ISOMORPH.
-    ///
-    ///\ref named-templ-param "Named parameter" for setting
-    ///the mapping type to \ref ISOMORPH.
-    Vf2Wizard<Base> &iso()
-    {
-      _mapping_type = ISOMORPH;
-      return *this;
-    }
-
-    ///Runs VF2 algorithm.
-
-    ///This method runs VF2 algorithm.
-    ///
-    ///\retval true if a mapping is found.
-    ///\retval false if there is no (more) mapping.
-    bool run()
-    {
-      if(Base::_local_mapping)
-        Base::createMapping();
-
-      Vf2<Graph1, Graph2, Mapping, NodeEq >
-        alg(_g1, _g2, *reinterpret_cast<Mapping*>(_mapping), _node_eq);
-
-      alg.mappingType(_mapping_type);
-
-      bool ret = alg.find();
-
-      if(Base::_local_mapping)
-        delete reinterpret_cast<Mapping*>(_mapping);
-
-      return ret;
-    }
-  };
-
-  ///Function-type interface for VF2 algorithm.
-
-  /// \ingroup graph_isomorphism
-  ///Function-type interface for VF2 algorithm \cite cordella2004sub.
-  ///
-  ///This function has several \ref named-func-param "named parameters"
-  ///declared as the members of class \ref Vf2Wizard.
-  ///The following examples show how to use these parameters.
-  ///\code
-  ///  // Find an embedding of graph g into graph h
-  ///  ListGraph::NodeMap<ListGraph::Node> m(g);
-  ///  vf2(g,h).mapping(m).run();
-  ///
-  ///  // Check whether graphs g and h are isomorphic
-  ///  bool is_iso = vf2(g,h).iso().run();
-  ///\endcode
-  ///\warning Don't forget to put the \ref Vf2Wizard::run() "run()"
-  ///to the end of the expression.
-  ///\sa Vf2Wizard
-  ///\sa Vf2
-  template<class G1, class G2>
-  Vf2Wizard<Vf2WizardBase<G1,G2> > vf2(const G1 &g1, const G2 &g2)
-  {
-    return Vf2Wizard<Vf2WizardBase<G1,G2> >(g1,g2);
-  }
-
-}
-
-#endif
Index: test/CMakeLists.txt
===================================================================
--- test/CMakeLists.txt	(revision 1350)
+++ test/CMakeLists.txt	(revision 1264)
@@ -55,5 +55,4 @@
   tsp_test
   unionfind_test
-  vf2_test
 )
 
Index: test/arc_look_up_test.cc
===================================================================
--- test/arc_look_up_test.cc	(revision 1312)
+++ test/arc_look_up_test.cc	(revision 1270)
@@ -25,4 +25,5 @@
 using namespace lemon;
 
+const int lgfn = 4;
 const std::string lgf =
   "@nodes\n"
Index: test/bellman_ford_test.cc
===================================================================
--- test/bellman_ford_test.cc	(revision 1337)
+++ test/bellman_ford_test.cc	(revision 1270)
@@ -102,8 +102,4 @@
 
     for (BF::ActiveIt it(const_bf_test); it != INVALID; ++it) {}
-    for (auto n: const_bf_test.activeNodes()) { ::lemon::ignore_unused_variable_warning(n); }
-    for (Digraph::Node n: const_bf_test.activeNodes()) {
-      ::lemon::ignore_unused_variable_warning(n);
-    }
   }
   {
Index: test/bpgraph_test.cc
===================================================================
--- test/bpgraph_test.cc	(revision 1292)
+++ test/bpgraph_test.cc	(revision 1270)
@@ -79,5 +79,4 @@
     e2 = G.addEdge(bn1, rn1),
     e3 = G.addEdge(rn1, bn2);
-  ::lemon::ignore_unused_variable_warning(e2,e3);
 
   checkGraphNodeList(G, 3);
@@ -121,5 +120,4 @@
     e1 = G.addEdge(n1, n2), e2 = G.addEdge(n1, n3),
     e3 = G.addEdge(n4, n2), e4 = G.addEdge(n4, n3);
-  ::lemon::ignore_unused_variable_warning(e1,e3,e4);
 
   // Check edge deletion
@@ -170,5 +168,4 @@
     e1 = G.addEdge(n1, n2), e2 = G.addEdge(n1, n3),
     e3 = G.addEdge(n4, n2), e4 = G.addEdge(n4, n3);
-  ::lemon::ignore_unused_variable_warning(e1,e3,e4);
 
   G.changeRed(e2, n4);
@@ -223,5 +220,4 @@
     e1 = G.addEdge(n1, n2),
     e2 = G.addEdge(n1, n3);
-  ::lemon::ignore_unused_variable_warning(e1,e2);
 
   checkGraphNodeList(G, 3);
@@ -309,5 +305,4 @@
     e1 = g.addEdge(n1, n2),
     e2 = g.addEdge(n1, n3);
-  ::lemon::ignore_unused_variable_warning(e2);
 
   check(g.valid(n1), "Wrong validity check");
Index: test/graph_test.h
===================================================================
--- test/graph_test.h	(revision 1337)
+++ test/graph_test.h	(revision 1270)
@@ -39,25 +39,4 @@
     check(n==INVALID,"Wrong Node list linking.");
     check(countNodes(G)==cnt,"Wrong Node number.");
-
-#ifdef LEMON_CXX11
-    {
-      typename Graph::NodeIt n(G);
-      for(auto u: G.nodes())
-        {
-          check(n==u,"Wrong STL Node iterator.");
-          ++n;
-        }
-      check(n==INVALID,"Wrong STL Node iterator.");
-    }
-    {
-      typename Graph::NodeIt n(G);
-      for(typename Graph::Node u: G.nodes())
-        {
-          check(n==u,"Wrong STL Node iterator.");
-          ++n;
-        }
-      check(n==INVALID,"Wrong STL Node iterator.");
-    }
-#endif
   }
 
@@ -78,24 +57,4 @@
     check(n==INVALID,"Wrong red Node list linking.");
     check(countRedNodes(G)==cnt,"Wrong red Node number.");
-#ifdef LEMON_CXX11
-    {
-      typename Graph::RedNodeIt n(G);
-      for(auto u: G.redNodes())
-        {
-          check(n==u,"Wrong STL RedNode iterator.");
-          ++n;
-        }
-      check(n==INVALID,"Wrong STL RedNode iterator.");
-    }
-    {
-      typename Graph::RedNodeIt n(G);
-      for(typename Graph::RedNode u: G.redNodes())
-        {
-          check(n==u,"Wrong STL RedNode iterator.");
-          ++n;
-        }
-      check(n==INVALID,"Wrong STL RedNode iterator.");
-    }
-#endif
   }
 
@@ -116,25 +75,4 @@
     check(n==INVALID,"Wrong blue Node list linking.");
     check(countBlueNodes(G)==cnt,"Wrong blue Node number.");
-#ifdef LEMON_CXX11
-    {
-      typename Graph::BlueNodeIt n(G);
-      for(auto u: G.blueNodes())
-        {
-          check(n==u,"Wrong STL BlueNode iterator.");
-          ++n;
-        }
-      check(n==INVALID,"Wrong STL BlueNode iterator.");
-    }
-    {
-      typename Graph::BlueNodeIt n(G);
-      for(typename Graph::BlueNode u: G.blueNodes())
-        {
-          check(n==u,"Wrong STL BlueNode iterator.");
-          ++n;
-        }
-      check(n==INVALID,"Wrong STL BlueNode iterator.");
-    }
-#endif
-
   }
 
@@ -153,25 +91,4 @@
     check(e==INVALID,"Wrong Arc list linking.");
     check(countArcs(G)==cnt,"Wrong Arc number.");
-#ifdef LEMON_CXX11
-    {
-      typename Graph::ArcIt a(G);
-      for(auto e: G.arcs())
-        {
-          check(a==e,"Wrong STL Arc iterator.");
-          ++a;
-        }
-      check(a==INVALID,"Wrong STL Arc iterator.");
-    }
-    {
-      typename Graph::ArcIt a(G);
-      for(typename Graph::Arc e: G.arcs())
-        {
-          check(a==e,"Wrong STL Arc iterator.");
-          ++a;
-        }
-      check(a==INVALID,"Wrong STL Arc iterator.");
-    }
-#endif
-
   }
 
@@ -189,25 +106,4 @@
     check(e==INVALID,"Wrong OutArc list linking.");
     check(countOutArcs(G,n)==cnt,"Wrong OutArc number.");
-#ifdef LEMON_CXX11
-    {
-      typename Graph::OutArcIt a(G,n);
-      for(auto e: G.outArcs(n))
-        {
-          check(a==e,"Wrong STL OutArc iterator.");
-          ++a;
-        }
-      check(a==INVALID,"Wrong STL OutArc iterator.");
-    }
-    {
-      typename Graph::OutArcIt a(G,n);
-      for(typename Graph::Arc e: G.outArcs(n))
-        {
-          check(a==e,"Wrong STL OutArc iterator.");
-          ++a;
-        }
-      check(a==INVALID,"Wrong STL OutArc iterator.");
-    }
-#endif
-
   }
 
@@ -225,24 +121,4 @@
     check(e==INVALID,"Wrong InArc list linking.");
     check(countInArcs(G,n)==cnt,"Wrong InArc number.");
-#ifdef LEMON_CXX11
-    {
-      typename Graph::InArcIt a(G,n);
-      for(auto e: G.inArcs(n))
-        {
-          check(a==e,"Wrong STL InArc iterator.");
-          ++a;
-        }
-      check(a==INVALID,"Wrong STL InArc iterator.");
-    }
-    {
-      typename Graph::InArcIt a(G,n);
-      for(typename Graph::Arc e: G.inArcs(n))
-        {
-          check(a==e,"Wrong STL InArc iterator.");
-          ++a;
-        }
-      check(a==INVALID,"Wrong STL InArc iterator.");
-    }
-#endif
   }
 
@@ -259,25 +135,4 @@
     check(e==INVALID,"Wrong Edge list linking.");
     check(countEdges(G)==cnt,"Wrong Edge number.");
-#ifdef LEMON_CXX11
-    {
-      typename Graph::EdgeIt a(G);
-      for(auto e: G.edges())
-        {
-          check(a==e,"Wrong STL Edge iterator.");
-          ++a;
-        }
-      check(a==INVALID,"Wrong STL Edge iterator.");
-    }
-    {
-      typename Graph::EdgeIt a(G);
-      for(typename Graph::Edge e: G.edges())
-        {
-          check(a==e,"Wrong STL Edge iterator.");
-          ++a;
-        }
-      check(a==INVALID,"Wrong STL Edge iterator.");
-    }
-#endif
-
   }
 
@@ -296,25 +151,4 @@
     check(e==INVALID,"Wrong IncEdge list linking.");
     check(countIncEdges(G,n)==cnt,"Wrong IncEdge number.");
-#ifdef LEMON_CXX11
-    {
-      typename Graph::IncEdgeIt a(G,n);
-      for(auto e: G.incEdges(n))
-        {
-          check(a==e,"Wrong STL IncEdge iterator.");
-          ++a;
-        }
-      check(a==INVALID,"Wrong STL IncEdge iterator.");
-    }
-    {
-      typename Graph::IncEdgeIt a(G,n);
-      for(typename Graph::Edge e: G.incEdges(n))
-        {
-          check(a==e,"Wrong STL IncEdge iterator.");
-          ++a;
-        }
-      check(a==INVALID,"Wrong STL IncEdge iterator.");
-    }
-#endif
-
   }
 
Index: test/lp_test.cc
===================================================================
--- test/lp_test.cc	(revision 1337)
+++ test/lp_test.cc	(revision 1270)
@@ -21,5 +21,5 @@
 #include "test_tools.h"
 #include <lemon/tolerance.h>
-#include <lemon/concept_check.h>
+
 #include <lemon/config.h>
 
@@ -40,7 +40,4 @@
 #endif
 
-#ifdef LEMON_HAVE_LP
-#include <lemon/lp.h>
-#endif
 using namespace lemon;
 
@@ -48,9 +45,4 @@
   int count=0;
   for (LpBase::ColIt c(lp); c!=INVALID; ++c) ++count;
-#ifdef LEMON_CXX11
-  int cnt = 0;
-  for(auto c: lp.cols()) { cnt++; ::lemon::ignore_unused_variable_warning(c); }
-  check(count == cnt, "Wrong STL iterator");
-#endif
   return count;
 }
@@ -59,9 +51,4 @@
   int count=0;
   for (LpBase::RowIt r(lp); r!=INVALID; ++r) ++count;
-#ifdef LEMON_CXX11
-  int cnt = 0;
-  for(auto r: lp.rows()) { cnt++; ::lemon::ignore_unused_variable_warning(r); }
-  check(count == cnt, "Wrong STL iterator");
-#endif
   return count;
 }
@@ -430,13 +417,4 @@
   lpTest(lp_skel);
 
-#ifdef LEMON_HAVE_LP
-  {
-    Lp lp,lp2;
-    lpTest(lp);
-    aTest(lp2);
-    cloneTest<Lp>();
-  }
-#endif
-
 #ifdef LEMON_HAVE_GLPK
   {
Index: test/maps_test.cc
===================================================================
--- test/maps_test.cc	(revision 1337)
+++ test/maps_test.cc	(revision 1270)
@@ -731,28 +731,4 @@
     check(n == 3, "Wrong number");
     check(map1.falseNum() == 3, "Wrong number");
-
-#ifdef LEMON_CXX11
-    {
-      int c = 0;
-      for(auto v: map1.items(false)) { c++; ::lemon::ignore_unused_variable_warning(v); }
-      check(c == map1.falseNum(), "Wrong number");
-    }
-    {
-      int c = 0;
-      for(auto v: map1.items(true)) { c++; ::lemon::ignore_unused_variable_warning(v); }
-      check(c == map1.trueNum(), "Wrong number");
-    }
-    {
-      int c = 0;
-      for(auto v: map1.falseKeys()) { c++; ::lemon::ignore_unused_variable_warning(v); }
-      check(c == map1.falseNum(), "Wrong number");
-    }
-    {
-      int c = 0;
-      for(auto v: map1.trueKeys()) { c++; ::lemon::ignore_unused_variable_warning(v); }
-      check(c == map1.trueNum(), "Wrong number");
-    }
-#endif
-
   }
 
@@ -805,13 +781,4 @@
     }
     check(n == num, "Wrong number");
-#ifdef LEMON_CXX11
-    {
-      int c = 0;
-      for(auto v: map1.items(0)) { c++; ::lemon::ignore_unused_variable_warning(v); }
-      check(c == (num + 1) / 2, "Wrong number");
-      for(auto v: map1.items(1)) { c++; ::lemon::ignore_unused_variable_warning(v); }
-      check(c == num, "Wrong number");
-    }
-#endif
 
   }
@@ -872,14 +839,4 @@
     }
     check(n == num, "Wrong number");
-
-#ifdef LEMON_CXX11
-    {
-      int c = 0;
-      for(auto v: map1.items(0.0)) { c++; ::lemon::ignore_unused_variable_warning(v); }
-      check(c == (num + 1) / 2, "Wrong number");
-      for(auto v: map1.items(1.0)) { c++; ::lemon::ignore_unused_variable_warning(v); }
-      check(c == num, "Wrong number");
-    }
-#endif
 
   }
Index: test/max_flow_test.cc
===================================================================
--- test/max_flow_test.cc	(revision 1270)
+++ test/max_flow_test.cc	(revision 1381)
@@ -166,6 +166,4 @@
   typedef concepts::Digraph Digraph;
   typedef concepts::ReadMap<Digraph::Arc, Value> CapMap;
-  typedef Elevator<Digraph, Digraph::Node> Elev;
-  typedef LinkedElevator<Digraph, Digraph::Node> LinkedElev;
 
   Digraph g;
Index: test/min_cost_flow_test.cc
===================================================================
--- test/min_cost_flow_test.cc	(revision 1318)
+++ test/min_cost_flow_test.cc	(revision 1270)
@@ -396,10 +396,4 @@
   checkMcf(mcf3, mcf3.run(param), neg2_gr, neg2_l, neg2_u, neg2_c, neg2_s,
            mcf3.OPTIMAL, true,     -300, test_str + "-18", GEQ);
-
-  // Tests for empty graph
-  Digraph gr0;
-  MCF mcf0(gr0);
-  mcf0.run(param);
-  check(mcf0.totalCost() == 0, "Wrong total cost");  
 }
 
Index: test/mip_test.cc
===================================================================
--- test/mip_test.cc	(revision 1300)
+++ test/mip_test.cc	(revision 795)
@@ -31,8 +31,4 @@
 #ifdef LEMON_HAVE_CBC
 #include <lemon/cbc.h>
-#endif
-
-#ifdef LEMON_HAVE_MIP
-#include <lemon/lp.h>
 #endif
 
@@ -133,12 +129,4 @@
 {
 
-#ifdef LEMON_HAVE_MIP
-  {
-    Mip mip1;
-    aTest(mip1);
-    cloneTest<Mip>();
-  }
-#endif
-
 #ifdef LEMON_HAVE_GLPK
   {
Index: test/radix_sort_test.cc
===================================================================
--- test/radix_sort_test.cc	(revision 1341)
+++ test/radix_sort_test.cc	(revision 1270)
@@ -16,6 +16,4 @@
  *
  */
-
-#include <lemon/core.h>
 
 #include <lemon/time_measure.h>
Index: test/random_test.cc
===================================================================
--- test/random_test.cc	(revision 1379)
+++ test/random_test.cc	(revision 463)
@@ -22,31 +22,4 @@
 int seed_array[] = {1, 2};
 
-int rnd_seq32[] = {
-2732, 43567, 42613, 52416, 45891, 21243, 30403, 32103, 
-62501, 33003, 12172, 5192, 32511, 50057, 43723, 7813, 
-23720, 35343, 6637, 30280, 44566, 31019, 18898, 33867, 
-5994, 1688, 11513, 59011, 48056, 25544, 39168, 25365, 
-17530, 8366, 27063, 49861, 55169, 63848, 11863, 49608
-};
-int rnd_seq64[] = {
-56382, 63883, 59577, 64750, 9644, 59886, 57647, 18152, 
-28520, 64078, 17818, 49294, 26424, 26697, 53684, 19209, 
-35404, 12121, 12837, 11827, 32156, 58333, 62553, 7907, 
-64427, 39399, 21971, 48789, 46981, 15716, 53335, 65256, 
-12999, 15308, 10906, 42162, 47587, 43006, 53921, 18716
-};
-
-void seq_test() {
-  for(int i=0;i<5;i++) {
-    lemon::Random32 r32(i);
-    lemon::Random64 r64(i);
-    for(int j=0;j<8;j++) {
-      check(r32[65536]==rnd_seq32[i*8+j], "Wrong random sequence");
-      check(r64[65536]==rnd_seq64[i*8+j], "Wrong random sequence");
-    }
-  }
-}
-
-
 int main()
 {
@@ -64,5 +37,4 @@
                   (sizeof(seed_array) / sizeof(seed_array[0])));
 
-  seq_test();
   return 0;
 }
Index: test/tsp_test.cc
===================================================================
--- test/tsp_test.cc	(revision 1303)
+++ test/tsp_test.cc	(revision 1270)
@@ -67,11 +67,10 @@
 
   int node_cnt = 0;
-  for (typename Container::const_iterator it = p.begin(); it != p.end(); ++it)
-    {
-      FullGraph::Node node = *it;
-      if (used[node]) return false;
-      used[node] = true;
-      ++node_cnt;
-    }
+  for (typename Container::const_iterator it = p.begin(); it != p.end(); ++it) {
+    FullGraph::Node node = *it;
+    if (used[node]) return false;
+    used[node] = true;
+    ++node_cnt;
+  }
 
   return (node_cnt == gr.nodeNum());
@@ -133,6 +132,5 @@
     int esize = n <= 1 ? 0 : n;
 
-    ConstMap<Edge, int> cost_map(1);
-    TSP alg(g, cost_map);
+    TSP alg(g, constMap<Edge, int>(1));
 
     check(alg.run() == esize, alg_name + ": Wrong total cost");
@@ -267,8 +265,6 @@
   tspTestSmall<GreedyTsp<ConstMap<Edge, int> > >("Greedy");
   tspTestSmall<NearestInsertionTsp<ConstMap<Edge, int> > >("Nearest Insertion");
-  tspTestSmall<FarthestInsertionTsp<ConstMap<Edge, int> > >
-    ("Farthest Insertion");
-  tspTestSmall<CheapestInsertionTsp<ConstMap<Edge, int> > >
-    ("Cheapest Insertion");
+  tspTestSmall<FarthestInsertionTsp<ConstMap<Edge, int> > >("Farthest Insertion");
+  tspTestSmall<CheapestInsertionTsp<ConstMap<Edge, int> > >("Cheapest Insertion");
   tspTestSmall<RandomInsertionTsp<ConstMap<Edge, int> > >("Random Insertion");
   tspTestSmall<ChristofidesTsp<ConstMap<Edge, int> > >("Christofides");
Index: st/vf2_test.cc
===================================================================
--- test/vf2_test.cc	(revision 1352)
+++ 	(revision )
@@ -1,366 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2015
- * EMAXA Kutato-fejleszto Kft. (EMAXA Research Ltd.)
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#include <lemon/vf2.h>
-#include <lemon/concepts/digraph.h>
-#include <lemon/smart_graph.h>
-#include <lemon/lgf_reader.h>
-#include <lemon/concepts/maps.h>
-
-#include <test/test_tools.h>
-#include <sstream>
-
-using namespace lemon;
-
-char petersen_lgf[] =
-  "@nodes\n"
-  "label col1 col2\n"
-  "0 1 1\n"
-  "1 1 2\n"
-  "2 1 3\n"
-  "3 1 4\n"
-  "4 2 5\n"
-  "5 2 1\n"
-  "6 2 2\n"
-  "7 2 3\n"
-  "8 2 4\n"
-  "9 2 5\n"
-  "@arcs\n"
-  "     -\n"
-  "0 1\n"
-  "1 2\n"
-  "2 3\n"
-  "3 4\n"
-  "4 0\n"
-  "0 5\n"
-  "1 6\n"
-  "2 7\n"
-  "3 8\n"
-  "4 9\n"
-  "5 8\n"
-  "5 7\n"
-  "9 6\n"
-  "9 7\n"
-  "6 8\n";
-
-char c5_lgf[] =
-  "@nodes\n"
-  "label col\n"
-  "0 1\n"
-  "1 2\n"
-  "2 3\n"
-  "3 4\n"
-  "4 5\n"
-  "@arcs\n"
-  "     -\n"
-  "0 1\n"
-  "1 2\n"
-  "2 3\n"
-  "3 4\n"
-  "4 0\n";
-
-char c7_lgf[] =
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "4\n"
-  "5\n"
-  "6\n"
-  "@arcs\n"
-  "     -\n"
-  "0 1\n"
-  "1 2\n"
-  "2 3\n"
-  "3 4\n"
-  "4 5\n"
-  "5 6\n"
-  "6 0\n";
-
-char c10_lgf[] =
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "4\n"
-  "5\n"
-  "6\n"
-  "7\n"
-  "8\n"
-  "9\n"
-  "@arcs\n"
-  "     -\n"
-  "0 1\n"
-  "1 2\n"
-  "2 3\n"
-  "3 4\n"
-  "4 5\n"
-  "5 6\n"
-  "6 7\n"
-  "7 8\n"
-  "8 9\n"
-  "9 0\n";
-
-char p10_lgf[] =
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "4\n"
-  "5\n"
-  "6\n"
-  "7\n"
-  "8\n"
-  "9\n"
-  "@arcs\n"
-  "     -\n"
-  "0 1\n"
-  "1 2\n"
-  "2 3\n"
-  "3 4\n"
-  "4 5\n"
-  "5 6\n"
-  "6 7\n"
-  "7 8\n"
-  "8 9\n";
-
-SmartGraph petersen, c5, c7, c10, p10;
-SmartGraph::NodeMap<int> petersen_col1(petersen);
-SmartGraph::NodeMap<int> petersen_col2(petersen);
-SmartGraph::NodeMap<int> c5_col(c5);
-
-void make_graphs() {
-  std::stringstream ss(petersen_lgf);
-  graphReader(petersen, ss)
-    .nodeMap("col1",petersen_col1)
-    .nodeMap("col2",petersen_col2)
-    .run();
-
-  ss.clear();
-  ss.str("");
-  ss<<c5_lgf;
-  //std::stringstream ss2(c5_lgf);
-  graphReader(c5, ss)
-    .nodeMap("col",c5_col)
-    .run();
-
-  ss.clear();
-  ss.str("");
-  ss<<c7_lgf;
-  graphReader(c7, ss).run();
-
-  ss.clear();
-  ss.str("");
-  ss<<c10_lgf;
-  graphReader(c10, ss).run();
-
-  ss.clear();
-  ss.str("");
-  ss<<p10_lgf;
-  graphReader(p10, ss).run();
-
-}
-
-class EqComparable {
-public:
-  bool operator==(const EqComparable&) { return false; }
-};
-
-template<class A, class B>
-class EqClass {
-public:
-  bool operator()(A, B) { return false; }
-};
-
-template<class G1,class G2>
-void checkVf2Compile()
-{
-  G1 g;
-  G2 h;
-  concepts::ReadWriteMap<typename G1::Node, typename G2::Node> r;
-  bool succ;
-  ::lemon::ignore_unused_variable_warning(succ);
-
-  succ = vf2(g,h).run();
-  succ = vf2(g,h).induced().run();
-  succ = vf2(g,h).iso().run();
-  succ = vf2(g,h).mapping(r).run();
-  succ = vf2(g,h).induced().mapping(r).run();
-  succ = vf2(g,h).iso().mapping(r).run();
-  concepts::ReadMap<typename G1::Node, EqComparable> l1;
-  concepts::ReadMap<typename G2::Node, EqComparable> l2;
-  succ = vf2(g,h).nodeLabels(l1,l2).mapping(r).run();
-  succ = vf2(g,h).nodeEq(EqClass<typename G1::Node,typename G2::Node>())
-    .mapping(r).run();
-}
-
-void justCompile()
-{
-  checkVf2Compile<concepts::Graph,concepts::Graph>();
-  checkVf2Compile<concepts::Graph,SmartGraph>();
-  checkVf2Compile<SmartGraph,concepts::Graph>();
-}
-
-template<class G1, class G2, class I>
-void checkSub(const G1 &g1, const G2 &g2, const I &i)
-{
-  {
-    std::set<typename G2::Node> image;
-    for(typename G1::NodeIt n(g1);n!=INVALID;++n)
-      {
-          check(i[n]!=INVALID, "Wrong isomorphism: incomplete mapping.");
-          check(image.count(i[n])==0,"Wrong isomorphism: not injective.");
-          image.insert(i[n]);
-      }
-  }
-  for(typename G1::EdgeIt e(g1);e!=INVALID;++e)
-    check(findEdge(g2,i[g1.u(e)],i[g1.v(e)])!=INVALID,
-          "Wrong isomorphism: missing edge(checkSub).");
-}
-
-template<class G1, class G2, class I>
-void checkInd(const G1 &g1, const G2 &g2, const I &i)
-  {
-  std::set<typename G2::Node> image;
-  for(typename G1::NodeIt n(g1);n!=INVALID;++n)
-    {
-    check(i[n]!=INVALID, "Wrong isomorphism: incomplete mapping.");
-    check(image.count(i[n])==0,"Wrong isomorphism: not injective.");
-    image.insert(i[n]);
-    }
-  for(typename G1::NodeIt n(g1); n!=INVALID; ++n)
-    for(typename G1::NodeIt m(g1); m!=INVALID; ++m)
-      if((findEdge(g1,n,m)==INVALID) != (findEdge(g2,i[n],i[m])==INVALID))
-        {
-        std::cout << "Wrong isomorphism: edge mismatch";
-        exit(1);
-        }
-  }
-
-template<class G1,class G2>
-int checkSub(const G1 &g1, const G2 &g2)
-{
-  typename G1:: template NodeMap<typename G2::Node> iso(g1,INVALID);
-  if(vf2(g1,g2).mapping(iso).run())
-    {
-      checkSub(g1,g2,iso);
-      return true;
-    }
-  else return false;
-}
-
-template<class G1,class G2>
-int checkInd(const G1 &g1, const G2 &g2)
-{
-  typename G1:: template NodeMap<typename G2::Node> iso(g1,INVALID);
-  if(vf2(g1,g2).induced().mapping(iso).run())
-    {
-      checkInd(g1,g2,iso);
-      return true;
-    }
-  else return false;
-}
-
-template<class G1,class G2>
-int checkIso(const G1 &g1, const G2 &g2)
-{
-  typename G1:: template NodeMap<typename G2::Node> iso(g1,INVALID);
-  if(vf2(g1,g2).iso().mapping(iso).run())
-    {
-      check(countNodes(g1)==countNodes(g2),
-            "Wrong iso alg.: they are not isomophic.");
-      checkInd(g1,g2,iso);
-      return true;
-    }
-  else return false;
-}
-
-template<class G1, class G2, class L1, class L2, class I>
-void checkLabel(const G1 &g1, const G2 &,
-                const L1 &l1, const L2 &l2,const I &i)
-{
-  for(typename G1::NodeIt n(g1);n!=INVALID;++n)
-    {
-      check(l1[n]==l2[i[n]],"Wrong isomorphism: label mismatch.");
-    }
-}
-
-template<class G1,class G2,class L1,class L2>
-int checkSub(const G1 &g1, const G2 &g2, const L1 &l1, const L2 &l2)
-{
-  typename G1:: template NodeMap<typename G2::Node> iso(g1,INVALID);
-  if(vf2(g1,g2).nodeLabels(l1,l2).mapping(iso).run())
-    {
-      checkSub(g1,g2,iso);
-      checkLabel(g1,g2,l1,l2,iso);
-      return true;
-    }
-  else return false;
-}
-
-int main() {
-  make_graphs();
-  check(checkSub(c5,petersen), "There should exist a C5->Petersen mapping.");
-  check(!checkSub(c7,petersen),
-        "There should not exist a C7->Petersen mapping.");
-  check(checkSub(p10,petersen), "There should exist a P10->Petersen mapping.");
-  check(!checkSub(c10,petersen),
-        "There should not exist a C10->Petersen mapping.");
-  check(checkSub(petersen,petersen),
-        "There should exist a Petersen->Petersen mapping.");
-
-  check(checkInd(c5,petersen),
-        "There should exist a C5->Petersen spanned mapping.");
-  check(!checkInd(c7,petersen),
-        "There should exist a C7->Petersen spanned mapping.");
-  check(!checkInd(p10,petersen),
-        "There should not exist a P10->Petersen spanned mapping.");
-  check(!checkInd(c10,petersen),
-        "There should not exist a C10->Petersen spanned mapping.");
-  check(checkInd(petersen,petersen),
-        "There should exist a Petersen->Petersen spanned mapping.");
-
-  check(!checkSub(petersen,c10),
-        "There should not exist a Petersen->C10 mapping.");
-  check(checkSub(p10,c10),
-        "There should exist a P10->C10 mapping.");
-  check(!checkInd(p10,c10),
-        "There should not exist a P10->C10 spanned mapping.");
-  check(!checkSub(c10,p10),
-        "There should not exist a C10->P10 mapping.");
-
-  check(!checkIso(p10,c10),
-        "P10 and C10 are not isomorphic.");
-  check(checkIso(c10,c10),
-        "C10 and C10 are isomorphic.");
-
-  check(!vf2(p10,c10).iso().run(),
-        "P10 and C10 are not isomorphic.");
-  check(vf2(c10,c10).iso().run(),
-        "C10 and C10 are isomorphic.");
-
-  check(!checkSub(c5,petersen,c5_col,petersen_col1),
-        "There should exist a C5->Petersen mapping.");
-  check(checkSub(c5,petersen,c5_col,petersen_col2),
-        "There should exist a C5->Petersen mapping.");
-}
Index: tools/dimacs-solver.cc
===================================================================
--- tools/dimacs-solver.cc	(revision 1271)
+++ tools/dimacs-solver.cc	(revision 1270)
@@ -128,6 +128,5 @@
   if (report) {
     std::cerr << "Run NetworkSimplex: " << ti << "\n\n";
-    std::cerr << "Feasible flow: " << (res == MCF::OPTIMAL ? "found" :
-                                       "not found") << '\n';
+    std::cerr << "Feasible flow: " << (res == MCF::OPTIMAL ? "found" : "not found") << '\n';
     if (res) std::cerr << "Min flow cost: "
                        << ns.template totalCost<LargeValue>() << '\n';
Index: tools/lgf-gen.cc
===================================================================
--- tools/lgf-gen.cc	(revision 1308)
+++ tools/lgf-gen.cc	(revision 701)
@@ -247,5 +247,5 @@
   struct BeachIt;
 
-  typedef std::multimap<double, BeachIt*> SpikeHeap;
+  typedef std::multimap<double, BeachIt> SpikeHeap;
 
   typedef std::multimap<Part, SpikeHeap::iterator, YLess> Beach;
@@ -330,5 +330,4 @@
 
       if (bit->second != spikeheap.end()) {
-        delete bit->second->second;
         spikeheap.erase(bit->second);
       }
@@ -344,6 +343,6 @@
           circle_form(points[prev], points[curr], points[site])) {
         double x = circle_point(points[prev], points[curr], points[site]);
-        pit = spikeheap.insert(std::make_pair(x, new BeachIt(beach.end())));
-        pit->second->it =
+        pit = spikeheap.insert(std::make_pair(x, BeachIt(beach.end())));
+        pit->second.it =
           beach.insert(std::make_pair(Part(prev, curr, site), pit));
       } else {
@@ -357,6 +356,6 @@
           circle_form(points[site], points[curr],points[next])) {
         double x = circle_point(points[site], points[curr], points[next]);
-        nit = spikeheap.insert(std::make_pair(x, new BeachIt(beach.end())));
-        nit->second->it =
+        nit = spikeheap.insert(std::make_pair(x, BeachIt(beach.end())));
+        nit->second.it =
           beach.insert(std::make_pair(Part(site, curr, next), nit));
       } else {
@@ -368,5 +367,5 @@
       sweep = spit->first;
 
-      Beach::iterator bit = spit->second->it;
+      Beach::iterator bit = spit->second.it;
 
       int prev = bit->first.prev;
@@ -401,20 +400,8 @@
       int nnt = nbit->first.next;
 
-      if (bit->second != spikeheap.end())
-        {
-          delete bit->second->second;
-          spikeheap.erase(bit->second);
-        }
-      if (pbit->second != spikeheap.end())
-        {
-          delete pbit->second->second;
-          spikeheap.erase(pbit->second);
-        }
-      if (nbit->second != spikeheap.end())
-        {
-          delete nbit->second->second;
-          spikeheap.erase(nbit->second);
-        }
-      
+      if (bit->second != spikeheap.end()) spikeheap.erase(bit->second);
+      if (pbit->second != spikeheap.end()) spikeheap.erase(pbit->second);
+      if (nbit->second != spikeheap.end()) spikeheap.erase(nbit->second);
+
       beach.erase(nbit);
       beach.erase(bit);
@@ -426,6 +413,6 @@
         double x = circle_point(points[ppv], points[prev], points[next]);
         if (x < sweep) x = sweep;
-        pit = spikeheap.insert(std::make_pair(x, new BeachIt(beach.end())));
-        pit->second->it =
+        pit = spikeheap.insert(std::make_pair(x, BeachIt(beach.end())));
+        pit->second.it =
           beach.insert(std::make_pair(Part(ppv, prev, next), pit));
       } else {
@@ -438,6 +425,6 @@
         double x = circle_point(points[prev], points[next], points[nnt]);
         if (x < sweep) x = sweep;
-        nit = spikeheap.insert(std::make_pair(x, new BeachIt(beach.end())));
-        nit->second->it =
+        nit = spikeheap.insert(std::make_pair(x, BeachIt(beach.end())));
+        nit->second.it =
           beach.insert(std::make_pair(Part(prev, next, nnt), nit));
       } else {
